Convert DispatchEventFromNativeUiEvent and its callers to use OnceCallback

This cl doesn't bring any functionality change, but changes
DispatchEventFromNativeUiEvent and its callers to use OnceCallback
and BindOnce.

Bug: 714018
Change-Id: Ibfbda691fab9ae2e4e597d7b18917312d795fb02
Reviewed-on: https://chromium-review.googlesource.com/808285Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Maksim Sisov <msisov@igalia.com>
Cr-Commit-Position: refs/heads/master@{#521757}

ui/events/ozone/evdev/input_injector_evdev_unittest.cc

@@ -27,7 +27,7 @@ class EventObserver {
  public:
   void EventDispatchCallback(Event* event) {
     DispatchEventFromNativeUiEvent(
-        event, base::Bind(&EventObserver::OnEvent, base::Unretained(this)));
+        event, base::BindOnce(&EventObserver::OnEvent, base::Unretained(this)));
   }
 
   void OnEvent(Event* event) {

ui/events/ozone/events_ozone.cc

@@ -8,26 +8,27 @@
 
 namespace ui {
 
-void DispatchEventFromNativeUiEvent(const base::NativeEvent& native_event,
-                                    base::Callback<void(ui::Event*)> callback) {
+void DispatchEventFromNativeUiEvent(
+    const base::NativeEvent& native_event,
+    base::OnceCallback<void(ui::Event*)> callback) {
   ui::Event* native_ui_event = static_cast<ui::Event*>(native_event);
   if (native_ui_event->IsKeyEvent()) {
     ui::KeyEvent key_event(native_event);
-    callback.Run(&key_event);
+    std::move(callback).Run(&key_event);
   } else if (native_ui_event->IsMouseWheelEvent()) {
     ui::MouseWheelEvent wheel_event(native_event);
-    callback.Run(&wheel_event);
+    std::move(callback).Run(&wheel_event);
   } else if (native_ui_event->IsMouseEvent()) {
     ui::MouseEvent mouse_event(native_event);
-    callback.Run(&mouse_event);
+    std::move(callback).Run(&mouse_event);
   } else if (native_ui_event->IsTouchEvent()) {
     ui::TouchEvent touch_event(native_event);
-    callback.Run(&touch_event);
+    std::move(callback).Run(&touch_event);
   } else if (native_ui_event->IsScrollEvent()) {
     ui::ScrollEvent scroll_event(native_event);
-    callback.Run(&scroll_event);
+    std::move(callback).Run(&scroll_event);
   } else if (native_ui_event->IsGestureEvent()) {
-    callback.Run(native_ui_event);
+    std::move(callback).Run(native_ui_event);
     // TODO(mohsen): Use the same pattern for scroll/touch/wheel events.
     // Apparently, there is no need for them to wrap the |native_event|.
   } else {

ui/events/ozone/events_ozone.h

@@ -32,7 +32,7 @@ class Event;
 //
 EVENTS_EXPORT void DispatchEventFromNativeUiEvent(
     const base::NativeEvent& native_event,
-    base::Callback<void(ui::Event*)> callback);
+    base::OnceCallback<void(ui::Event*)> callback);
 
 }  // namespace ui
 

ui/ozone/platform/cast/platform_window_cast.cc

@@ -52,8 +52,8 @@ bool PlatformWindowCast::CanDispatchEvent(const ui::PlatformEvent& ne) {
 uint32_t PlatformWindowCast::DispatchEvent(
     const ui::PlatformEvent& native_event) {
   DispatchEventFromNativeUiEvent(
-      native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                               base::Unretained(delegate_)));
+      native_event, base::BindOnce(&PlatformWindowDelegate::DispatchEvent,
+                                   base::Unretained(delegate_)));
 
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }

ui/ozone/platform/drm/host/drm_window_host.cc

@@ -183,8 +183,8 @@ uint32_t DrmWindowHost::DispatchEvent(const PlatformEvent& native_event) {
     located_event->set_root_location_f(location);
   }
   DispatchEventFromNativeUiEvent(
-      native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                               base::Unretained(delegate_)));
+      native_event, base::BindOnce(&PlatformWindowDelegate::DispatchEvent,
+                                   base::Unretained(delegate_)));
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 

ui/ozone/platform/wayland/wayland_window.cc

@@ -202,8 +202,8 @@ bool WaylandWindow::CanDispatchEvent(const PlatformEvent& native_event) {
 
 uint32_t WaylandWindow::DispatchEvent(const PlatformEvent& native_event) {
   DispatchEventFromNativeUiEvent(
-      native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                               base::Unretained(delegate_)));
+      native_event, base::BindOnce(&PlatformWindowDelegate::DispatchEvent,
+                                   base::Unretained(delegate_)));
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 

ui/platform_window/x11/x11_window_ozone.cc

@@ -77,8 +77,8 @@ uint32_t X11WindowOzone::DispatchEvent(const PlatformEvent& platform_event) {
   // This is unfortunately needed otherwise events that depend on global state
   // (eg. double click) are broken.
   DispatchEventFromNativeUiEvent(
-      platform_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                                 base::Unretained(delegate())));
+      platform_event, base::BindOnce(&PlatformWindowDelegate::DispatchEvent,
+                                     base::Unretained(delegate())));
   return POST_DISPATCH_STOP_PROPAGATION;
 }