re-land the "SourceEventType added to LatencyInfo."

ui/events/event.cc

 // Copyright (c) 2012 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/event.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 
@@ skipping 121 matching lines @@
     CASE_TYPE(ET_UMA_DATA);
     case ui::ET_LAST: NOTREACHED(); return std::string();
     // Don't include default, so that we get an error when new type is added.
   }
 #undef CASE_TYPE
 
   NOTREACHED();
   return std::string();
 }
 
+ui::SourceEventType EventTypeToLatencySourceEventType(ui::EventType type) {
+  switch (type) {
+    case ui::ET_UNKNOWN:
+    // SourceEventType for PointerEvents/GestureEvents can be either TOUCH or
+    // WHEEL. The proper value is assigned in the constructors.
+    case ui::ET_POINTER_DOWN:
+    case ui::ET_POINTER_MOVED:
+    case ui::ET_POINTER_UP:
+    case ui::ET_POINTER_CANCELLED:
+    case ui::ET_POINTER_ENTERED:
+    case ui::ET_POINTER_EXITED:
+    case ui::ET_POINTER_CAPTURE_CHANGED:
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+    case ui::ET_GESTURE_SCROLL_END:
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+    case ui::ET_GESTURE_TAP:
+    case ui::ET_GESTURE_TAP_DOWN:
+    case ui::ET_GESTURE_TAP_CANCEL:
+    case ui::ET_GESTURE_TAP_UNCONFIRMED:
+    case ui::ET_GESTURE_DOUBLE_TAP:
+    case ui::ET_GESTURE_BEGIN:
+    case ui::ET_GESTURE_END:
+    case ui::ET_GESTURE_TWO_FINGER_TAP:
+    case ui::ET_GESTURE_PINCH_BEGIN:
+    case ui::ET_GESTURE_PINCH_END:
+    case ui::ET_GESTURE_PINCH_UPDATE:
+    case ui::ET_GESTURE_LONG_PRESS:
+    case ui::ET_GESTURE_LONG_TAP:
+    case ui::ET_GESTURE_SWIPE:
+    case ui::ET_GESTURE_SHOW_PRESS:
+    // Flings can be GestureEvents too.
+    case ui::ET_SCROLL_FLING_START:
+    case ui::ET_SCROLL_FLING_CANCEL:
+      return ui::SourceEventType::UNKNOWN;
+
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_DRAGGED:
+    case ui::ET_MOUSE_RELEASED:
+    case ui::ET_MOUSE_MOVED:
+    case ui::ET_MOUSE_ENTERED:
+    case ui::ET_MOUSE_EXITED:
+    case ui::ET_KEY_PRESSED:
+    case ui::ET_KEY_RELEASED:
+    case ui::ET_MOUSE_CAPTURE_CHANGED:
+    case ui::ET_DROP_TARGET_EVENT:
+    case ui::ET_CANCEL_MODE:
+    case ui::ET_UMA_DATA:
+      return ui::SourceEventType::OTHER;
+
+    case ui::ET_TOUCH_RELEASED:
+    case ui::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_MOVED:
+    case ui::ET_TOUCH_CANCELLED:
+      return ui::SourceEventType::TOUCH;
+
+    case ui::ET_MOUSEWHEEL:
+    case ui::ET_POINTER_WHEEL_CHANGED:
+    case ui::ET_SCROLL:
+      return ui::SourceEventType::WHEEL;
+
+    case ui::ET_LAST:
+      NOTREACHED();
+      return ui::SourceEventType::UNKNOWN;
+  }
+  NOTREACHED();
+  return ui::SourceEventType::UNKNOWN;
+}
+
 bool IsX11SendEventTrue(const base::NativeEvent& event) {
 #if defined(USE_X11)
   return event && event->xany.send_event;
 #else
   return false;
 #endif
 }
 
 bool X11EventHasNonStandardState(const base::NativeEvent& event) {
 #if defined(USE_X11)
@@ skipping 184 matching lines @@
     : type_(type),
       time_stamp_(time_stamp),
       flags_(flags),
       native_event_(base::NativeEvent()),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
       result_(ER_UNHANDLED),
       source_device_id_(ED_UNKNOWN_DEVICE) {
-  if (type_ < ET_LAST)
+  if (type_ < ET_LAST) {
+    latency()->set_source_event_type(EventTypeToLatencySourceEventType(type));
     name_ = EventTypeName(type_);
+  }
 }
 
 Event::Event(const base::NativeEvent& native_event,
              EventType type,
              int flags)
     : type_(type),
       time_stamp_(EventTimeFromNative(native_event)),
       flags_(flags),
       native_event_(native_event),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
       result_(ER_UNHANDLED),
       source_device_id_(ED_UNKNOWN_DEVICE) {
   base::TimeDelta delta = EventTimeForNow() - time_stamp_;
-  if (type_ < ET_LAST)
+  if (type_ < ET_LAST) {
+    latency()->set_source_event_type(EventTypeToLatencySourceEventType(type));
     name_ = EventTypeName(type_);
+  }
   base::HistogramBase::Sample delta_sample =
       static_cast<base::HistogramBase::Sample>(delta.InMicroseconds());
   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Browser", delta_sample, 1, 1000000,
                               100);
   ComputeEventLatencyOS(native_event);
 
   // Though it seems inefficient to generate the string twice, the first
   // instance will be used only for DCHECK builds and the second won't be
   // executed at all if the histogram was previously accessed here.
   STATIC_HISTOGRAM_POINTER_GROUP(
@@ skipping 30 matching lines @@
       result_(ER_UNHANDLED),
       source_device_id_(copy.source_device_id_) {
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
 }
 
 void Event::SetType(EventType type) {
   if (type_ < ET_LAST)
     name_ = std::string();
   type_ = type;
-  if (type_ < ET_LAST)
+  if (type_ < ET_LAST) {
     name_ = EventTypeName(type_);
+    latency()->set_source_event_type(EventTypeToLatencySourceEventType(type));
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CancelModeEvent
 
 CancelModeEvent::CancelModeEvent()
     : Event(ET_CANCEL_MODE, base::TimeTicks(), 0) {
   set_cancelable(false);
 }
 
@@ skipping 461 matching lines @@
       return true;
     default:
       return false;
   }
 }
 
 PointerEvent::PointerEvent(const PointerEvent& pointer_event)
     : LocatedEvent(pointer_event),
       pointer_id_(pointer_event.pointer_id()),
       changed_button_flags_(pointer_event.changed_button_flags()),
-      details_(pointer_event.pointer_details()) {}
+      details_(pointer_event.pointer_details()) {
+  if (details_.pointer_type == EventPointerType::POINTER_TYPE_TOUCH)
+    latency()->set_source_event_type(ui::SourceEventType::TOUCH);
+  else if (pointer_event.type() == ET_POINTER_WHEEL_CHANGED)
+    latency()->set_source_event_type(ui::SourceEventType::WHEEL);
+  else
+    latency()->set_source_event_type(ui::SourceEventType::OTHER);
+}
 
 PointerEvent::PointerEvent(const MouseEvent& mouse_event)
     : LocatedEvent(mouse_event),
       pointer_id_(kMousePointerId),
       changed_button_flags_(mouse_event.changed_button_flags()),
       details_(mouse_event.pointer_details()) {
   DCHECK(CanConvertFrom(mouse_event));
   switch (mouse_event.type()) {
     case ET_MOUSE_PRESSED:
       SetType(ET_POINTER_DOWN);
+      latency()->set_source_event_type(ui::SourceEventType::OTHER);
       break;
 
     case ET_MOUSE_DRAGGED:
     case ET_MOUSE_MOVED:
       SetType(ET_POINTER_MOVED);
+      latency()->set_source_event_type(ui::SourceEventType::OTHER);
       break;
 
     case ET_MOUSE_ENTERED:
       SetType(ET_POINTER_ENTERED);
+      latency()->set_source_event_type(ui::SourceEventType::OTHER);
       break;
 
     case ET_MOUSE_EXITED:
       SetType(ET_POINTER_EXITED);
+      latency()->set_source_event_type(ui::SourceEventType::OTHER);
       break;
 
     case ET_MOUSE_RELEASED:
       SetType(ET_POINTER_UP);
+      latency()->set_source_event_type(ui::SourceEventType::OTHER);
       break;
 
     case ET_MOUSEWHEEL:
       SetType(ET_POINTER_WHEEL_CHANGED);
       details_ = PointerDetails(EventPointerType::POINTER_TYPE_MOUSE,
                                 mouse_event.AsMouseWheelEvent()->offset());
+      latency()->set_source_event_type(ui::SourceEventType::WHEEL);
       break;
 
     case ET_MOUSE_CAPTURE_CHANGED:
       SetType(ET_POINTER_CAPTURE_CHANGED);
       break;
 
     default:
       NOTREACHED();
   }
 }
@@ skipping 17 matching lines @@
       SetType(ET_POINTER_UP);
       break;
 
     case ET_TOUCH_CANCELLED:
       SetType(ET_POINTER_CANCELLED);
       break;
 
     default:
       NOTREACHED();
   }
+  latency()->set_source_event_type(ui::SourceEventType::TOUCH);
 }
 
 PointerEvent::PointerEvent(EventType type,
                            const gfx::Point& location,
                            const gfx::Point& root_location,
                            int flags,
                            int pointer_id,
                            int changed_button_flags,
                            const PointerDetails& pointer_details,
                            base::TimeTicks time_stamp)
     : LocatedEvent(type,
                    gfx::PointF(location),
                    gfx::PointF(root_location),
                    time_stamp,
                    flags),
       pointer_id_(pointer_id),
       changed_button_flags_(changed_button_flags),
-      details_(pointer_details) {}
+      details_(pointer_details) {
+  if (details_.pointer_type == EventPointerType::POINTER_TYPE_TOUCH)
+    latency()->set_source_event_type(ui::SourceEventType::TOUCH);
+  else if (type == ET_POINTER_WHEEL_CHANGED)
+    latency()->set_source_event_type(ui::SourceEventType::WHEEL);
+  else
+    latency()->set_source_event_type(ui::SourceEventType::OTHER);
+}
 
 const int PointerEvent::kMousePointerId = std::numeric_limits<int32_t>::max();
 
 ////////////////////////////////////////////////////////////////////////////////
 // KeyEvent
 
 // static
 KeyEvent* KeyEvent::last_key_event_ = NULL;
 
 // static
@@ skipping 102 matching lines @@
 }
 
 KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) {
   if (this != &rhs) {
     Event::operator=(rhs);
     key_code_ = rhs.key_code_;
     code_ = rhs.code_;
     key_ = rhs.key_;
     is_char_ = rhs.is_char_;
   }
+  latency()->set_source_event_type(ui::SourceEventType::OTHER);
   return *this;
 }
 
 KeyEvent::~KeyEvent() {}
 
 void KeyEvent::ApplyLayout() const {
   ui::DomCode code = code_;
   if (code == DomCode::NONE) {
     // Catch old code that tries to do layout without a physical key, and try
     // to recover using the KeyboardCode. Once key events are fully defined
@@ skipping 155 matching lines @@
   } else if (type() == ET_SCROLL_FLING_START ||
              type() == ET_SCROLL_FLING_CANCEL) {
     GetFlingData(native_event,
                  &x_offset_, &y_offset_,
                  &x_offset_ordinal_, &y_offset_ordinal_,
                  NULL);
   } else {
     NOTREACHED() << "Unexpected event type " << type()
         << " when constructing a ScrollEvent.";
   }
+  if (IsScrollEvent())
+    latency()->set_source_event_type(ui::SourceEventType::WHEEL);
+  else
+    latency()->set_source_event_type(ui::SourceEventType::TOUCH);
 }
 
 ScrollEvent::ScrollEvent(EventType type,
                          const gfx::Point& location,
                          base::TimeTicks time_stamp,
                          int flags,
                          float x_offset,
                          float y_offset,
                          float x_offset_ordinal,
                          float y_offset_ordinal,
                          int finger_count)
     : MouseEvent(type, location, location, time_stamp, flags, 0),
       x_offset_(x_offset),
       y_offset_(y_offset),
       x_offset_ordinal_(x_offset_ordinal),
       y_offset_ordinal_(y_offset_ordinal),
       finger_count_(finger_count) {
   CHECK(IsScrollEvent());
+  latency()->set_source_event_type(ui::SourceEventType::WHEEL);
 }
 
 void ScrollEvent::Scale(const float factor) {
   x_offset_ *= factor;
   y_offset_ *= factor;
   x_offset_ordinal_ *= factor;
   y_offset_ordinal_ *= factor;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureEvent
 
 GestureEvent::GestureEvent(float x,
                            float y,
                            int flags,
                            base::TimeTicks time_stamp,
                            const GestureEventDetails& details,
                            uint32_t unique_touch_event_id)
     : LocatedEvent(details.type(),
                    gfx::PointF(x, y),
                    gfx::PointF(x, y),
                    time_stamp,
                    flags | EF_FROM_TOUCH),
       details_(details),
-      unique_touch_event_id_(unique_touch_event_id) {}
+      unique_touch_event_id_(unique_touch_event_id) {
+  latency()->set_source_event_type(ui::SourceEventType::TOUCH);
+}
 
 GestureEvent::~GestureEvent() {
 }
 
 }  // namespace ui