BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 100 insertions, 68 deletions

diff --git a/chromium/cc/metrics/event_metrics.cc b/chromium/cc/metrics/event_metrics.cc
index 326eaee70a1..951cdfc2ceb 100644
--- a/chromium/cc/metrics/event_metrics.cc
+++ b/chromium/cc/metrics/event_metrics.cc
@@ -4,98 +4,130 @@
 
 #include "cc/metrics/event_metrics.h"
 
+#include <utility>
+
 #include "base/check.h"
 #include "base/memory/ptr_util.h"
 #include "base/notreached.h"
 #include "base/stl_util.h"
 
 namespace cc {
+namespace {
+
+constexpr struct {
+  EventMetrics::EventType metrics_event_type;
+  ui::EventType ui_event_type;
+  const char* name;
+} kWhitelistedEvents[] = {
+#define EVENT_TYPE(name, ui_type) \
+  { EventMetrics::EventType::k##name, ui_type, #name }
+    EVENT_TYPE(MousePressed, ui::ET_MOUSE_PRESSED),
+    EVENT_TYPE(MouseReleased, ui::ET_MOUSE_RELEASED),
+    EVENT_TYPE(MouseWheel, ui::ET_MOUSEWHEEL),
+    EVENT_TYPE(KeyPressed, ui::ET_KEY_PRESSED),
+    EVENT_TYPE(KeyReleased, ui::ET_KEY_RELEASED),
+    EVENT_TYPE(TouchPressed, ui::ET_TOUCH_PRESSED),
+    EVENT_TYPE(TouchReleased, ui::ET_TOUCH_RELEASED),
+    EVENT_TYPE(TouchMoved, ui::ET_TOUCH_MOVED),
+    EVENT_TYPE(GestureScrollBegin, ui::ET_GESTURE_SCROLL_BEGIN),
+    EVENT_TYPE(GestureScrollUpdate, ui::ET_GESTURE_SCROLL_UPDATE),
+    EVENT_TYPE(GestureScrollEnd, ui::ET_GESTURE_SCROLL_END),
+    EVENT_TYPE(GestureDoubleTap, ui::ET_GESTURE_DOUBLE_TAP),
+    EVENT_TYPE(GestureLongPress, ui::ET_GESTURE_LONG_PRESS),
+    EVENT_TYPE(GestureLongTap, ui::ET_GESTURE_LONG_TAP),
+    EVENT_TYPE(GestureShowPress, ui::ET_GESTURE_SHOW_PRESS),
+    EVENT_TYPE(GestureTap, ui::ET_GESTURE_TAP),
+    EVENT_TYPE(GestureTapCancel, ui::ET_GESTURE_TAP_CANCEL),
+    EVENT_TYPE(GestureTapDown, ui::ET_GESTURE_TAP_DOWN),
+    EVENT_TYPE(GestureTapUnconfirmed, ui::ET_GESTURE_TAP_UNCONFIRMED),
+    EVENT_TYPE(GestureTwoFingerTap, ui::ET_GESTURE_TWO_FINGER_TAP),
+#undef EVENT_TYPE
+};
+static_assert(base::size(kWhitelistedEvents) ==
+                  static_cast<int>(EventMetrics::EventType::kMaxValue) + 1,
+              "EventMetrics::EventType has changed.");
+
+constexpr struct {
+  EventMetrics::ScrollType metrics_scroll_type;
+  ui::ScrollInputType ui_scroll_type;
+  const char* name;
+} kScrollTypes[] = {
+#define SCROLL_TYPE(name, ui_type) \
+  { EventMetrics::ScrollType::k##name, ui_type, #name }
+    SCROLL_TYPE(Autoscroll, ui::ScrollInputType::kAutoscroll),
+    SCROLL_TYPE(Scrollbar, ui::ScrollInputType::kScrollbar),
+    SCROLL_TYPE(Touchscreen, ui::ScrollInputType::kTouchscreen),
+    SCROLL_TYPE(Wheel, ui::ScrollInputType::kWheel),
+#undef SCROLL_TYPE
+};
+static_assert(base::size(kScrollTypes) ==
+                  static_cast<int>(EventMetrics::ScrollType::kMaxValue) + 1,
+              "EventMetrics::ScrollType has changed.");
+
+base::Optional<EventMetrics::EventType> ToWhitelistedEventType(
+    ui::EventType ui_event_type) {
+  for (size_t i = 0; i < base::size(kWhitelistedEvents); i++) {
+    if (ui_event_type == kWhitelistedEvents[i].ui_event_type) {
+      EventMetrics::EventType metrics_event_type =
+          static_cast<EventMetrics::EventType>(i);
+      DCHECK_EQ(metrics_event_type, kWhitelistedEvents[i].metrics_event_type);
+      return metrics_event_type;
+    }
+  }
+  return base::nullopt;
+}
+
+base::Optional<EventMetrics::ScrollType> ToScrollType(
+    const base::Optional<ui::ScrollInputType>& scroll_input_type) {
+  if (!scroll_input_type)
+    return base::nullopt;
+
+  for (size_t i = 0; i < base::size(kScrollTypes); i++) {
+    if (*scroll_input_type == kScrollTypes[i].ui_scroll_type) {
+      EventMetrics::ScrollType metrics_scroll_type =
+          static_cast<EventMetrics::ScrollType>(i);
+      DCHECK_EQ(metrics_scroll_type, kScrollTypes[i].metrics_scroll_type);
+      return metrics_scroll_type;
+    }
+  }
+  NOTREACHED();
+  return base::nullopt;
+}
+
+}  // namespace
 
 std::unique_ptr<EventMetrics> EventMetrics::Create(
     ui::EventType type,
     base::TimeTicks time_stamp,
     base::Optional<ui::ScrollInputType> scroll_input_type) {
-  switch (type) {
-    case ui::ET_MOUSE_PRESSED:
-    case ui::ET_MOUSE_RELEASED:
-    case ui::ET_MOUSEWHEEL:
-    case ui::ET_KEY_PRESSED:
-    case ui::ET_KEY_RELEASED:
-    case ui::ET_TOUCH_PRESSED:
-    case ui::ET_TOUCH_RELEASED:
-    case ui::ET_TOUCH_MOVED:
-    case ui::ET_GESTURE_SCROLL_BEGIN:
-    case ui::ET_GESTURE_SCROLL_UPDATE:
-    case ui::ET_GESTURE_SCROLL_END:
-      return base::WrapUnique(
-          new EventMetrics(type, time_stamp, scroll_input_type));
-    default:
-      return nullptr;
-  }
+  base::Optional<EventType> whitelisted_type = ToWhitelistedEventType(type);
+  if (!whitelisted_type)
+    return nullptr;
+  return base::WrapUnique(new EventMetrics(*whitelisted_type, time_stamp,
+                                           ToScrollType(scroll_input_type)));
 }
 
-EventMetrics::EventMetrics(
-    ui::EventType type,
-    base::TimeTicks time_stamp,
-    base::Optional<ui::ScrollInputType> scroll_input_type)
-    : type_(type),
-      time_stamp_(time_stamp),
-      scroll_input_type_(scroll_input_type) {}
+EventMetrics::EventMetrics(EventType type,
+                           base::TimeTicks time_stamp,
+                           base::Optional<ScrollType> scroll_type)
+    : type_(type), time_stamp_(time_stamp), scroll_type_(scroll_type) {}
 
 EventMetrics::EventMetrics(const EventMetrics&) = default;
 EventMetrics& EventMetrics::operator=(const EventMetrics&) = default;
 
 const char* EventMetrics::GetTypeName() const {
-  switch (type_) {
-    case ui::ET_MOUSE_PRESSED:
-      return "MousePressed";
-    case ui::ET_MOUSE_RELEASED:
-      return "MouseReleased";
-    case ui::ET_MOUSEWHEEL:
-      return "MouseWheel";
-    case ui::ET_KEY_PRESSED:
-      // TODO(crbug/1071645): Currently, all ET_KEY_PRESSED events are reported
-      // under EventLatency.KeyPressed histogram. This includes both key-down
-      // and key-char events. Consider reporting them separately.
-      return "KeyPressed";
-    case ui::ET_KEY_RELEASED:
-      return "KeyReleased";
-    case ui::ET_TOUCH_PRESSED:
-      return "TouchPressed";
-    case ui::ET_TOUCH_RELEASED:
-      return "TouchReleased";
-    case ui::ET_TOUCH_MOVED:
-      return "TouchMoved";
-    case ui::ET_GESTURE_SCROLL_BEGIN:
-      return "GestureScrollBegin";
-    case ui::ET_GESTURE_SCROLL_UPDATE:
-      return "GestureScrollUpdate";
-    case ui::ET_GESTURE_SCROLL_END:
-      return "GestureScrollEnd";
-    default:
-      NOTREACHED();
-      return nullptr;
-  }
+  return kWhitelistedEvents[static_cast<int>(type_)].name;
 }
 
 const char* EventMetrics::GetScrollTypeName() const {
-  DCHECK(scroll_input_type_) << "Event is not a scroll event";
-
-  switch (*scroll_input_type_) {
-    case ui::ScrollInputType::kTouchscreen:
-      return "Touchscreen";
-    case ui::ScrollInputType::kWheel:
-      return "Wheel";
-    case ui::ScrollInputType::kAutoscroll:
-      return "Autoscroll";
-    case ui::ScrollInputType::kScrollbar:
-      return "Scrollbar";
-  }
+  DCHECK(scroll_type_) << "Event is not a scroll event.";
+
+  return kScrollTypes[static_cast<int>(*scroll_type_)].name;
 }
 
 bool EventMetrics::operator==(const EventMetrics& other) const {
-  return std::tie(type_, time_stamp_, scroll_input_type_) ==
-         std::tie(other.type_, other.time_stamp_, other.scroll_input_type_);
+  return std::tie(type_, time_stamp_, scroll_type_) ==
+         std::tie(other.type_, other.time_stamp_, other.scroll_type_);
 }
 
 // EventMetricsSet