ozone: evdev: Dispatch events in task

ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 
 #include "base/strings/stringprintf.h"
@@ skipping 202 matching lines @@
                                  move->dx,
                                  move->dy,
                                  move->ordinal_dx,
                                  move->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   cursor_->MoveCursor(gfx::Vector2dF(move->dx, move->dy));
   // TODO(spang): Use move->ordinal_dx, move->ordinal_dy
   // TODO(spang): Use move->start_time, move->end_time
-  MouseEvent event(ET_MOUSE_MOVED,
-                   cursor_->location(),
-                   cursor_->location(),
-                   modifiers_->GetModifierFlags(),
-                   /* changed_button_flags */ 0);
-  Dispatch(&event);
+  Dispatch(make_scoped_ptr(new MouseEvent(ET_MOUSE_MOVED,
+                                          cursor_->location(),
+                                          cursor_->location(),
+                                          modifiers_->GetModifierFlags(),
+                                          /* changed_button_flags */ 0)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureScroll(
     const Gesture* gesture,
     const GestureScroll* scroll) {
   DVLOG(3) << base::StringPrintf("Gesture Scroll: (%f, %f) [%f, %f]",
                                  scroll->dx,
                                  scroll->dy,
                                  scroll->ordinal_dx,
                                  scroll->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   // TODO(spang): Support SetNaturalScroll
   // TODO(spang): Use scroll->start_time
-  ScrollEvent event(ET_SCROLL,
-                    cursor_->location(),
-                    StimeToTimedelta(gesture->end_time),
-                    modifiers_->GetModifierFlags(),
-                    scroll->dx,
-                    scroll->dy,
-                    scroll->ordinal_dx,
-                    scroll->ordinal_dy,
-                    kGestureScrollFingerCount);
-  Dispatch(&event);
+  Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL,
+                                           cursor_->location(),
+                                           StimeToTimedelta(gesture->end_time),
+                                           modifiers_->GetModifierFlags(),
+                                           scroll->dx,
+                                           scroll->dy,
+                                           scroll->ordinal_dx,
+                                           scroll->ordinal_dy,
+                                           kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureButtonsChange(
     const Gesture* gesture,
     const GestureButtonsChange* buttons) {
   DVLOG(3) << base::StringPrintf("Gesture Button Change: down=0x%02x up=0x%02x",
                                  buttons->down,
                                  buttons->up);
 
   if (!cursor_)
@@ skipping 38 matching lines @@
                   fling->fling_state);
 
   if (!cursor_)
     return;  // No cursor!
 
   EventType type =
       (fling->fling_state == GESTURES_FLING_START ? ET_SCROLL_FLING_START
                                                   : ET_SCROLL_FLING_CANCEL);
 
   // Fling is like 2-finger scrolling but with velocity instead of displacement.
-  ScrollEvent event(type,
-                    cursor_->location(),
-                    StimeToTimedelta(gesture->end_time),
-                    modifiers_->GetModifierFlags(),
-                    fling->vx,
-                    fling->vy,
-                    fling->ordinal_vx,
-                    fling->ordinal_vy,
-                    kGestureScrollFingerCount);
-  Dispatch(&event);
+  Dispatch(make_scoped_ptr(new ScrollEvent(type,
+                                           cursor_->location(),
+                                           StimeToTimedelta(gesture->end_time),
+                                           modifiers_->GetModifierFlags(),
+                                           fling->vx,
+                                           fling->vy,
+                                           fling->ordinal_vx,
+                                           fling->ordinal_vy,
+                                           kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipe(const Gesture* gesture,
                                                     const GestureSwipe* swipe) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe: (%f, %f) [%f, %f]",
                                  swipe->dx,
                                  swipe->dy,
                                  swipe->ordinal_dx,
                                  swipe->ordinal_dy);
 
   if (!cursor_)
     return;  // No cursor!
 
   // Swipe is 3-finger scrolling.
-  ScrollEvent event(ET_SCROLL,
-                    cursor_->location(),
-                    StimeToTimedelta(gesture->end_time),
-                    modifiers_->GetModifierFlags(),
-                    swipe->dx,
-                    swipe->dy,
-                    swipe->ordinal_dx,
-                    swipe->ordinal_dy,
-                    kGestureSwipeFingerCount);
-  Dispatch(&event);
+  Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL,
+                                           cursor_->location(),
+                                           StimeToTimedelta(gesture->end_time),
+                                           modifiers_->GetModifierFlags(),
+                                           swipe->dx,
+                                           swipe->dy,
+                                           swipe->ordinal_dx,
+                                           swipe->ordinal_dy,
+                                           kGestureSwipeFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipeLift(
     const Gesture* gesture,
     const GestureSwipeLift* swipelift) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe Lift");
 
   if (!cursor_)
     return;  // No cursor!
 
   // Turn a swipe lift into a fling start.
   // TODO(spang): Figure out why and put it in this comment.
 
-  ScrollEvent event(ET_SCROLL_FLING_START,
-                    cursor_->location(),
-                    StimeToTimedelta(gesture->end_time),
-                    modifiers_->GetModifierFlags(),
-                    /* x_offset */ 0,
-                    /* y_offset */ 0,
-                    /* x_offset_ordinal */ 0,
-                    /* y_offset_ordinal */ 0,
-                    kGestureScrollFingerCount);
-  Dispatch(&event);
-
+  Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL_FLING_START,
+                                           cursor_->location(),
+                                           StimeToTimedelta(gesture->end_time),
+                                           modifiers_->GetModifierFlags(),
+                                           /* x_offset */ 0,
+                                           /* y_offset */ 0,
+                                           /* x_offset_ordinal */ 0,
+                                           /* y_offset_ordinal */ 0,
+                                           kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGesturePinch(const Gesture* gesture,
                                                     const GesturePinch* pinch) {
   DVLOG(3) << base::StringPrintf(
                   "Gesture Pinch: dz=%f [%f]", pinch->dz, pinch->ordinal_dz);
 
   if (!cursor_)
     return;  // No cursor!
 
   NOTIMPLEMENTED();
 }
 
 void GestureInterpreterLibevdevCros::OnGestureMetrics(
     const Gesture* gesture,
     const GestureMetrics* metrics) {
   DVLOG(3) << base::StringPrintf("Gesture Metrics: [%f, %f] type=%d",
                                  metrics->data[0],
                                  metrics->data[1],
                                  metrics->type);
   NOTIMPLEMENTED();
 }
 
-void GestureInterpreterLibevdevCros::Dispatch(Event* event) {
-  dispatch_callback_.Run(event);
+void GestureInterpreterLibevdevCros::Dispatch(scoped_ptr<Event> event) {
+  dispatch_callback_.Run(event.Pass());
 }
 
 void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int modifier,
                                                          bool down) {
   const gfx::PointF& loc = cursor_->location();
   int flag = modifiers_->GetEventFlagFromModifier(modifier);
   EventType type = (down ? ET_MOUSE_PRESSED : ET_MOUSE_RELEASED);
   modifiers_->UpdateModifier(modifier, down);
-  MouseEvent event(type, loc, loc, modifiers_->GetModifierFlags() | flag, flag);
-  Dispatch(&event);
+  Dispatch(make_scoped_ptr(new MouseEvent(
+      type, loc, loc, modifiers_->GetModifierFlags() | flag, flag)));
 }
 
 void GestureInterpreterLibevdevCros::DispatchChangedKeys(Evdev* evdev,
                                                          const timeval& time) {
   unsigned long key_state_diff[EVDEV_BITS_TO_LONGS(KEY_CNT)];
 
   // Find changed keys.
   for (unsigned long i = 0; i < arraysize(key_state_diff); ++i)
     key_state_diff[i] = evdev->key_state_bitmask[i] ^ prev_key_state_[i];
 
   // Dispatch events for changed keys.
   for (unsigned long i = 0; i < KEY_CNT; ++i) {
     if (EvdevBitIsSet(key_state_diff, i)) {
       bool value = EvdevBitIsSet(evdev->key_state_bitmask, i);
       keyboard_->OnKeyChange(i, value);
     }
   }
 
   // Update internal key state.
   for (unsigned long i = 0; i < EVDEV_BITS_TO_LONGS(KEY_CNT); ++i)
     prev_key_state_[i] = evdev->key_state_bitmask[i];
 }
 
 }  // namespace ui