Scope WebInputEvent types to enum namespaces.

WebInputEvent::Type and WebTouchPoint::State are adjusted in this change.

This allows us to alias this enumeration to a mojo defined type that
will come in another CL.

No functional changes in this CL, largely completed via sed.

Change-Id: I0657aacf782a437f9432e721bba349f8fdf797e0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2159698
Reviewed-by: Avi Drissman <avi@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#761210}

content/app_shim_remote_cocoa/ns_view_bridge_factory_impl.mm

@@ -111,7 +111,7 @@ class RenderWidgetHostNSViewBridgeOwner
                     bool is_synthetically_injected) override {
     // The gesture type is not yet known, but assign a type to avoid
     // serialization asserts (the type will be stripped on the other side).
-    begin_event.SetType(blink::WebInputEvent::kGestureScrollBegin);
+    begin_event.SetType(blink::WebInputEvent::Type::kGestureScrollBegin);
     host_->GestureBegin(TranslateEvent(begin_event), is_synthetically_injected);
   }
   void GestureUpdate(blink::WebGestureEvent update_event) override {

content/app_shim_remote_cocoa/render_widget_host_view_cocoa.mm

@@ -715,7 +715,7 @@ void ExtractUnderlines(NSAttributedString* string,
     if (!_mouseEventWasIgnored) {
       WebMouseEvent exitEvent =
           WebMouseEventBuilder::Build(theEvent, self, _pointerType);
-      exitEvent.SetType(WebInputEvent::kMouseLeave);
+      exitEvent.SetType(WebInputEvent::Type::kMouseLeave);
       exitEvent.button = WebMouseEvent::Button::kNoButton;
       _hostHelper->ForwardMouseEvent(exitEvent);
     }
@@ -729,7 +729,7 @@ void ExtractUnderlines(NSAttributedString* string,
     // due to the hitTest, send a mouse enter event to the host view.
     WebMouseEvent enterEvent =
         WebMouseEventBuilder::Build(theEvent, self, _pointerType);
-    enterEvent.SetType(WebInputEvent::kMouseMove);
+    enterEvent.SetType(WebInputEvent::Type::kMouseMove);
     enterEvent.button = WebMouseEvent::Button::kNoButton;
     _hostHelper->RouteOrProcessMouseEvent(enterEvent);
   }
@@ -952,8 +952,8 @@ void ExtractUnderlines(NSAttributedString* string,
   NativeWebKeyboardEvent event =
       NativeWebKeyboardEvent::CreateForRenderer(theEvent);
   ui::LatencyInfo latency_info;
-  if (event.GetType() == blink::WebInputEvent::kRawKeyDown ||
-      event.GetType() == blink::WebInputEvent::kChar) {
+  if (event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
+      event.GetType() == blink::WebInputEvent::Type::kChar) {
     latency_info.set_source_event_type(ui::SourceEventType::KEY_PRESS);
   }
 
@@ -1109,7 +1109,7 @@ void ExtractUnderlines(NSAttributedString* string,
     // So before sending the real key down event, we need to send a fake key up
     // event to balance it.
     NativeWebKeyboardEvent fakeEvent = event;
-    fakeEvent.SetType(blink::WebInputEvent::kKeyUp);
+    fakeEvent.SetType(blink::WebInputEvent::Type::kKeyUp);
     fakeEvent.skip_in_browser = true;
     ui::LatencyInfo fake_event_latency_info = latency_info;
     fake_event_latency_info.set_source_event_type(ui::SourceEventType::OTHER);
@@ -1124,7 +1124,7 @@ void ExtractUnderlines(NSAttributedString* string,
     if (!textInserted && _textToBeInserted.length() == 1) {
       // If a single character was inserted, then we just send it as a keypress
       // event.
-      event.SetType(blink::WebInputEvent::kChar);
+      event.SetType(blink::WebInputEvent::Type::kChar);
       event.text[0] = _textToBeInserted[0];
       event.text[1] = 0;
       event.skip_in_browser = true;
@@ -1136,7 +1136,7 @@ void ExtractUnderlines(NSAttributedString* string,
       // We don't get insertText: calls if ctrl or cmd is down, or the key event
       // generates an insert command. So synthesize a keypress event for these
       // cases, unless the key event generated any other command.
-      event.SetType(blink::WebInputEvent::kChar);
+      event.SetType(blink::WebInputEvent::Type::kChar);
       event.skip_in_browser = true;
       _hostHelper->ForwardKeyboardEvent(event, latency_info);
     }
@@ -1195,7 +1195,7 @@ void ExtractUnderlines(NSAttributedString* string,
   if ([event type] == NSEventTypeMagnify ||
       [event type] == NSEventTypeEndGesture) {
     WebGestureEvent endEvent(WebGestureEventBuilder::Build(event, self));
-    endEvent.SetType(WebInputEvent::kGesturePinchEnd);
+    endEvent.SetType(WebInputEvent::Type::kGesturePinchEnd);
     endEvent.SetSourceDevice(blink::WebGestureDevice::kTouchpad);
     endEvent.SetNeedsWheelEvent(true);
     _hostHelper->GestureEnd(endEvent);
@@ -2048,8 +2048,8 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
   // If we switch windows (or are removed from the view hierarchy), cancel any
   // open mouse-downs.
   if (_hasOpenMouseDown) {
-    WebMouseEvent event(WebInputEvent::kMouseUp, WebInputEvent::kNoModifiers,
-                        ui::EventTimeForNow());
+    WebMouseEvent event(WebInputEvent::Type::kMouseUp,
+                        WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     event.button = WebMouseEvent::Button::kLeft;
     _hostHelper->ForwardMouseEvent(event);
     _hasOpenMouseDown = NO;

content/browser/android/gesture_listener_manager.cc

@@ -27,39 +27,39 @@ namespace {
 
 int ToGestureEventType(WebInputEvent::Type type) {
   switch (type) {
-    case WebInputEvent::kGestureScrollBegin:
+    case WebInputEvent::Type::kGestureScrollBegin:
       return ui::GESTURE_EVENT_TYPE_SCROLL_START;
-    case WebInputEvent::kGestureScrollEnd:
+    case WebInputEvent::Type::kGestureScrollEnd:
       return ui::GESTURE_EVENT_TYPE_SCROLL_END;
-    case WebInputEvent::kGestureScrollUpdate:
+    case WebInputEvent::Type::kGestureScrollUpdate:
       return ui::GESTURE_EVENT_TYPE_SCROLL_BY;
-    case WebInputEvent::kGestureFlingStart:
+    case WebInputEvent::Type::kGestureFlingStart:
       return ui::GESTURE_EVENT_TYPE_FLING_START;
-    case WebInputEvent::kGestureFlingCancel:
+    case WebInputEvent::Type::kGestureFlingCancel:
       return ui::GESTURE_EVENT_TYPE_FLING_CANCEL;
-    case WebInputEvent::kGestureShowPress:
+    case WebInputEvent::Type::kGestureShowPress:
       return ui::GESTURE_EVENT_TYPE_SHOW_PRESS;
-    case WebInputEvent::kGestureTap:
+    case WebInputEvent::Type::kGestureTap:
       return ui::GESTURE_EVENT_TYPE_SINGLE_TAP_CONFIRMED;
-    case WebInputEvent::kGestureTapUnconfirmed:
+    case WebInputEvent::Type::kGestureTapUnconfirmed:
       return ui::GESTURE_EVENT_TYPE_SINGLE_TAP_UNCONFIRMED;
-    case WebInputEvent::kGestureTapDown:
+    case WebInputEvent::Type::kGestureTapDown:
       return ui::GESTURE_EVENT_TYPE_TAP_DOWN;
-    case WebInputEvent::kGestureTapCancel:
+    case WebInputEvent::Type::kGestureTapCancel:
       return ui::GESTURE_EVENT_TYPE_TAP_CANCEL;
-    case WebInputEvent::kGestureDoubleTap:
+    case WebInputEvent::Type::kGestureDoubleTap:
       return ui::GESTURE_EVENT_TYPE_DOUBLE_TAP;
-    case WebInputEvent::kGestureLongPress:
+    case WebInputEvent::Type::kGestureLongPress:
       return ui::GESTURE_EVENT_TYPE_LONG_PRESS;
-    case WebInputEvent::kGestureLongTap:
+    case WebInputEvent::Type::kGestureLongTap:
       return ui::GESTURE_EVENT_TYPE_LONG_TAP;
-    case WebInputEvent::kGesturePinchBegin:
+    case WebInputEvent::Type::kGesturePinchBegin:
       return ui::GESTURE_EVENT_TYPE_PINCH_BEGIN;
-    case WebInputEvent::kGesturePinchEnd:
+    case WebInputEvent::Type::kGesturePinchEnd:
       return ui::GESTURE_EVENT_TYPE_PINCH_END;
-    case WebInputEvent::kGesturePinchUpdate:
+    case WebInputEvent::Type::kGesturePinchUpdate:
       return ui::GESTURE_EVENT_TYPE_PINCH_BY;
-    case WebInputEvent::kGestureTwoFingerTap:
+    case WebInputEvent::Type::kGestureTwoFingerTap:
     default:
       NOTREACHED() << "Invalid source gesture type: "
                    << WebInputEvent::GetName(type);
@@ -162,10 +162,10 @@ void GestureListenerManager::DidStopFlinging() {
 }
 
 bool GestureListenerManager::FilterInputEvent(const WebInputEvent& event) {
-  if (event.GetType() != WebInputEvent::kGestureTap &&
-      event.GetType() != WebInputEvent::kGestureLongTap &&
-      event.GetType() != WebInputEvent::kGestureLongPress &&
-      event.GetType() != WebInputEvent::kMouseDown)
+  if (event.GetType() != WebInputEvent::Type::kGestureTap &&
+      event.GetType() != WebInputEvent::Type::kGestureLongTap &&
+      event.GetType() != WebInputEvent::Type::kGestureLongPress &&
+      event.GetType() != WebInputEvent::Type::kMouseDown)
     return false;
 
   JNIEnv* env = AttachCurrentThread();
@@ -175,7 +175,7 @@ bool GestureListenerManager::FilterInputEvent(const WebInputEvent& event) {
 
   web_contents_->GetNativeView()->RequestFocus();
 
-  if (event.GetType() == WebInputEvent::kMouseDown)
+  if (event.GetType() == WebInputEvent::Type::kMouseDown)
     return false;
 
   const WebGestureEvent& gesture = static_cast<const WebGestureEvent&>(event);

content/browser/android/overscroll_controller_android.cc

@@ -151,23 +151,23 @@ bool OverscrollControllerAndroid::WillHandleGestureEvent(
 
   bool handled = false;
   switch (event.GetType()) {
-    case blink::WebInputEvent::kGestureScrollBegin:
+    case blink::WebInputEvent::Type::kGestureScrollBegin:
       refresh_effect_->OnScrollBegin(
           gfx::ScalePoint(event.PositionInWidget(), dpi_scale_));
       break;
 
-    case blink::WebInputEvent::kGestureScrollUpdate: {
+    case blink::WebInputEvent::Type::kGestureScrollUpdate: {
       gfx::Vector2dF scroll_delta(event.data.scroll_update.delta_x,
                                   event.data.scroll_update.delta_y);
       scroll_delta.Scale(dpi_scale_);
       handled = refresh_effect_->WillHandleScrollUpdate(scroll_delta);
     } break;
 
-    case blink::WebInputEvent::kGestureScrollEnd:
+    case blink::WebInputEvent::Type::kGestureScrollEnd:
       refresh_effect_->OnScrollEnd(gfx::Vector2dF());
       break;
 
-    case blink::WebInputEvent::kGestureFlingStart: {
+    case blink::WebInputEvent::Type::kGestureFlingStart: {
       if (refresh_effect_->IsActive()) {
         gfx::Vector2dF scroll_velocity(event.data.fling_start.velocity_x,
                                        event.data.fling_start.velocity_y);
@@ -187,7 +187,7 @@ bool OverscrollControllerAndroid::WillHandleGestureEvent(
       }
     } break;
 
-    case blink::WebInputEvent::kGesturePinchBegin:
+    case blink::WebInputEvent::Type::kGesturePinchBegin:
       refresh_effect_->ReleaseWithoutActivation();
       break;
 
@@ -206,12 +206,12 @@ void OverscrollControllerAndroid::OnGestureEventAck(
 
   // The overscroll effect requires an explicit release signal that may not be
   // sent from the renderer compositor.
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd ||
-      event.GetType() == blink::WebInputEvent::kGestureFlingStart) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd ||
+      event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
     OnOverscrolled(DidOverscrollParams());
   }
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate &&
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate &&
       refresh_effect_) {
     // The effect should only be allowed if the scroll events go unconsumed.
     if (refresh_effect_->IsAwaitingScrollUpdateAck() &&

content/browser/android/overscroll_controller_android_unittest.cc

@@ -207,7 +207,7 @@ TEST_F(OverscrollControllerAndroidUnitTest,
   controller_->OnOverscrolled(params);
 
   // Generate a consumed scroll update.
-  blink::WebGestureEvent event(blink::WebInputEvent::kGestureScrollUpdate,
+  blink::WebGestureEvent event(blink::WebInputEvent::Type::kGestureScrollUpdate,
                                blink::WebInputEvent::kNoModifiers,
                                ui::EventTimeForNow());
   controller_->OnGestureEventAck(

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

@@ -263,7 +263,7 @@ IN_PROC_BROWSER_TEST_F(SyntheticKeyEventTest, DISABLED_KeyboardEventAck) {
   auto filter = std::make_unique<InputMsgWatcher>(
       RenderWidgetHostImpl::From(
           shell()->web_contents()->GetRenderViewHost()->GetWidget()),
-      blink::WebInputEvent::kRawKeyDown);
+      blink::WebInputEvent::Type::kRawKeyDown);
 
   SendCommand("Debugger.enable", nullptr);
   SendKeyEvent("rawKeyDown", 0, 13, 13, "Enter", false);
@@ -289,7 +289,7 @@ IN_PROC_BROWSER_TEST_F(SyntheticMouseEventTest, MouseEventAck) {
   auto filter = std::make_unique<InputMsgWatcher>(
       RenderWidgetHostImpl::From(
           shell()->web_contents()->GetRenderViewHost()->GetWidget()),
-      blink::WebInputEvent::kMouseDown);
+      blink::WebInputEvent::Type::kMouseDown);
 
   SendCommand("Debugger.enable", nullptr);
   SendMouseEvent("mousePressed", 15, 15, "left", false);

content/browser/devtools/protocol/input_handler.cc

@@ -160,26 +160,26 @@ bool GetMouseEventButton(const std::string& button,
 
 blink::WebInputEvent::Type GetMouseEventType(const std::string& type) {
   if (type == Input::DispatchMouseEvent::TypeEnum::MousePressed)
-    return blink::WebInputEvent::kMouseDown;
+    return blink::WebInputEvent::Type::kMouseDown;
   if (type == Input::DispatchMouseEvent::TypeEnum::MouseReleased)
-    return blink::WebInputEvent::kMouseUp;
+    return blink::WebInputEvent::Type::kMouseUp;
   if (type == Input::DispatchMouseEvent::TypeEnum::MouseMoved)
-    return blink::WebInputEvent::kMouseMove;
+    return blink::WebInputEvent::Type::kMouseMove;
   if (type == Input::DispatchMouseEvent::TypeEnum::MouseWheel)
-    return blink::WebInputEvent::kMouseWheel;
-  return blink::WebInputEvent::kUndefined;
+    return blink::WebInputEvent::Type::kMouseWheel;
+  return blink::WebInputEvent::Type::kUndefined;
 }
 
 blink::WebInputEvent::Type GetTouchEventType(const std::string& type) {
   if (type == Input::DispatchTouchEvent::TypeEnum::TouchStart)
-    return blink::WebInputEvent::kTouchStart;
+    return blink::WebInputEvent::Type::kTouchStart;
   if (type == Input::DispatchTouchEvent::TypeEnum::TouchEnd)
-    return blink::WebInputEvent::kTouchEnd;
+    return blink::WebInputEvent::Type::kTouchEnd;
   if (type == Input::DispatchTouchEvent::TypeEnum::TouchMove)
-    return blink::WebInputEvent::kTouchMove;
+    return blink::WebInputEvent::Type::kTouchMove;
   if (type == Input::DispatchTouchEvent::TypeEnum::TouchCancel)
-    return blink::WebInputEvent::kTouchCancel;
-  return blink::WebInputEvent::kUndefined;
+    return blink::WebInputEvent::Type::kTouchCancel;
+  return blink::WebInputEvent::Type::kUndefined;
 }
 
 blink::WebPointerProperties::PointerType GetPointerType(
@@ -218,23 +218,23 @@ bool GenerateTouchPoints(
       return false;
     event->touches[event->touches_length] = it.second;
     event->touches[event->touches_length].state =
-        type == blink::WebInputEvent::kTouchCancel
+        type == blink::WebInputEvent::Type::kTouchCancel
             ? blink::WebTouchPoint::kStateCancelled
             : blink::WebTouchPoint::kStateStationary;
     event->touches_length++;
   }
-  if (type == blink::WebInputEvent::kTouchCancel ||
-      type == blink::WebInputEvent::kTouchEnd) {
-    event->touches[0].state = type == blink::WebInputEvent::kTouchCancel
+  if (type == blink::WebInputEvent::Type::kTouchCancel ||
+      type == blink::WebInputEvent::Type::kTouchEnd) {
+    event->touches[0].state = type == blink::WebInputEvent::Type::kTouchCancel
                                   ? blink::WebTouchPoint::kStateCancelled
                                   : blink::WebTouchPoint::kStateReleased;
     event->SetType(type);
   } else if (points.find(changing.id) == points.end()) {
     event->touches[0].state = blink::WebTouchPoint::kStatePressed;
-    event->SetType(blink::WebInputEvent::kTouchStart);
+    event->SetType(blink::WebInputEvent::Type::kTouchStart);
   } else {
     event->touches[0].state = blink::WebTouchPoint::kStateMoved;
-    event->SetType(blink::WebInputEvent::kTouchMove);
+    event->SetType(blink::WebInputEvent::Type::kTouchMove);
   }
   return true;
 }
@@ -432,7 +432,7 @@ class InputHandler::InputInjector
     }
 
     if ((blink::WebInputEvent::IsMouseEventType(event.GetType()) ||
-         event.GetType() == blink::WebInputEvent::kMouseWheel) &&
+         event.GetType() == blink::WebInputEvent::Type::kMouseWheel) &&
         !pending_mouse_callbacks_.empty()) {
       pending_mouse_callbacks_.front()->sendSuccess();
       pending_mouse_callbacks_.pop_front();
@@ -542,13 +542,13 @@ void InputHandler::DispatchKeyEvent(
   blink::WebInputEvent::Type web_event_type;
 
   if (type == Input::DispatchKeyEvent::TypeEnum::KeyDown) {
-    web_event_type = blink::WebInputEvent::kKeyDown;
+    web_event_type = blink::WebInputEvent::Type::kKeyDown;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::KeyUp) {
-    web_event_type = blink::WebInputEvent::kKeyUp;
+    web_event_type = blink::WebInputEvent::Type::kKeyUp;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::Char) {
-    web_event_type = blink::WebInputEvent::kChar;
+    web_event_type = blink::WebInputEvent::Type::kChar;
   } else if (type == Input::DispatchKeyEvent::TypeEnum::RawKeyDown) {
-    web_event_type = blink::WebInputEvent::kRawKeyDown;
+    web_event_type = blink::WebInputEvent::Type::kRawKeyDown;
   } else {
     callback->sendFailure(Response::InvalidParams(
         base::StringPrintf("Unexpected event type '%s'", type.c_str())));
@@ -652,7 +652,7 @@ void InputHandler::DispatchMouseEvent(
     Maybe<std::string> pointer_type,
     std::unique_ptr<DispatchMouseEventCallback> callback) {
   blink::WebInputEvent::Type type = GetMouseEventType(event_type);
-  if (type == blink::WebInputEvent::kUndefined) {
+  if (type == blink::WebInputEvent::Type::kUndefined) {
     callback->sendFailure(Response::InvalidParams(
         base::StringPrintf("Unexpected event type '%s'", event_type.c_str())));
     return;
@@ -676,7 +676,7 @@ void InputHandler::DispatchMouseEvent(
   std::unique_ptr<blink::WebMouseEvent> mouse_event;
   blink::WebMouseWheelEvent* wheel_event = nullptr;
 
-  if (type == blink::WebInputEvent::kMouseWheel) {
+  if (type == blink::WebInputEvent::Type::kMouseWheel) {
     wheel_event = new blink::WebMouseWheelEvent(type, modifiers, timestamp);
     mouse_event.reset(wheel_event);
     if (!delta_x.isJust() || !delta_y.isJust()) {
@@ -762,7 +762,7 @@ void InputHandler::DispatchWebTouchEvent(
     protocol::Maybe<double> maybe_timestamp,
     std::unique_ptr<DispatchTouchEventCallback> callback) {
   blink::WebInputEvent::Type type = GetTouchEventType(event_type);
-  if (type == blink::WebInputEvent::kUndefined) {
+  if (type == blink::WebInputEvent::Type::kUndefined) {
     callback->sendFailure(Response::InvalidParams(
         base::StringPrintf("Unexpected event type '%s'", event_type.c_str())));
     return;
@@ -773,19 +773,21 @@ void InputHandler::DispatchWebTouchEvent(
       false, 0, 0);
   base::TimeTicks timestamp = GetEventTimeTicks(maybe_timestamp);
 
-  if ((type == blink::WebInputEvent::kTouchStart ||
-       type == blink::WebInputEvent::kTouchMove) &&
+  if ((type == blink::WebInputEvent::Type::kTouchStart ||
+       type == blink::WebInputEvent::Type::kTouchMove) &&
       touch_points->empty()) {
     callback->sendFailure(Response::InvalidParams(
         "TouchStart and TouchMove must have at least one touch point."));
     return;
   }
-  if (type == blink::WebInputEvent::kTouchCancel && !touch_points->empty()) {
+  if (type == blink::WebInputEvent::Type::kTouchCancel &&
+      !touch_points->empty()) {
     callback->sendFailure(
         Response::InvalidParams("TouchCancel must not have any touch points."));
     return;
   }
-  if (type != blink::WebInputEvent::kTouchStart && touch_points_.empty()) {
+  if (type != blink::WebInputEvent::Type::kTouchStart &&
+      touch_points_.empty()) {
     callback->sendFailure(Response::InvalidParams(
         "Must send a TouchStart first to start a new touch."));
     return;
@@ -819,7 +821,7 @@ void InputHandler::DispatchWebTouchEvent(
   bool ok = true;
   for (auto& id_point : points) {
     if (touch_points_.find(id_point.first) != touch_points_.end() &&
-        type == blink::WebInputEvent::kTouchMove &&
+        type == blink::WebInputEvent::Type::kTouchMove &&
         touch_points_[id_point.first].PositionInWidget() ==
             id_point.second.PositionInWidget()) {
       continue;
@@ -828,21 +830,21 @@ void InputHandler::DispatchWebTouchEvent(
     events.emplace_back(type, modifiers, timestamp);
     ok &= GenerateTouchPoints(&events.back(), type, touch_points_,
                               id_point.second);
-    if (type == blink::WebInputEvent::kTouchStart ||
-        type == blink::WebInputEvent::kTouchMove) {
+    if (type == blink::WebInputEvent::Type::kTouchStart ||
+        type == blink::WebInputEvent::Type::kTouchMove) {
       touch_points_[id_point.first] = id_point.second;
-    } else if (type == blink::WebInputEvent::kTouchEnd) {
+    } else if (type == blink::WebInputEvent::Type::kTouchEnd) {
       touch_points_.erase(id_point.first);
     }
   }
 
   if (touch_points->size() == 0 && touch_points_.size() > 0) {
-    if (type == blink::WebInputEvent::kTouchCancel) {
+    if (type == blink::WebInputEvent::Type::kTouchCancel) {
       events.emplace_back(type, modifiers, timestamp);
       ok &= GenerateTouchPoints(&events.back(), type, touch_points_,
                                 touch_points_.begin()->second);
       touch_points_.clear();
-    } else if (type == blink::WebInputEvent::kTouchEnd) {
+    } else if (type == blink::WebInputEvent::Type::kTouchEnd) {
       for (auto it = touch_points_.begin(); it != touch_points_.end();) {
         events.emplace_back(type, modifiers, timestamp);
         ok &= GenerateTouchPoints(&events.back(), type, touch_points_,
@@ -898,7 +900,7 @@ void InputHandler::OnWidgetForDispatchWebTouchEvent(
   gfx::Vector2dF delta = *transformed - original;
   for (size_t i = 0; i < events.size(); i++) {
     events[i].dispatch_type =
-        events[i].GetType() == blink::WebInputEvent::kTouchCancel
+        events[i].GetType() == blink::WebInputEvent::Type::kTouchCancel
             ? blink::WebInputEvent::DispatchType::kEventNonBlocking
             : blink::WebInputEvent::DispatchType::kBlocking;
     events[i].moved_beyond_slop_region = true;
@@ -1116,14 +1118,14 @@ Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type,
                                                   Maybe<int> click_count) {
   blink::WebInputEvent::Type event_type;
   if (type == Input::EmulateTouchFromMouseEvent::TypeEnum::MouseWheel) {
-    event_type = blink::WebInputEvent::kMouseWheel;
+    event_type = blink::WebInputEvent::Type::kMouseWheel;
     if (!delta_x.isJust() || !delta_y.isJust()) {
       return Response::InvalidParams(
           "'deltaX' and 'deltaY' are expected for mouseWheel event");
     }
   } else {
     event_type = GetMouseEventType(type);
-    if (event_type == blink::WebInputEvent::kUndefined) {
+    if (event_type == blink::WebInputEvent::Type::kUndefined) {
       return Response::InvalidParams(
           base::StringPrintf("Unexpected event type '%s'", type.c_str()));
     }

content/browser/devtools/protocol/native_input_event_builder_mac.mm

@@ -16,8 +16,8 @@ namespace protocol {
 gfx::NativeEvent NativeInputEventBuilder::CreateEvent(
     const NativeWebKeyboardEvent& event) {
   NSEventType type = NSKeyUp;
-  if (event.GetType() == blink::WebInputEvent::kRawKeyDown ||
-      event.GetType() == blink::WebInputEvent::kKeyDown)
+  if (event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
+      event.GetType() == blink::WebInputEvent::Type::kKeyDown)
     type = NSKeyDown;
   const base::char16* textStartAddr = &event.text[0];
   const int textLength =

content/browser/download/download_browsertest.cc

@@ -3807,14 +3807,14 @@ IN_PROC_BROWSER_TEST_F(DownloadContentTest,
 
   // Alt-click the link.
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseDown, blink::WebInputEvent::kAltKey,
+      blink::WebInputEvent::Type::kMouseDown, blink::WebInputEvent::kAltKey,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.button = blink::WebMouseEvent::Button::kLeft;
   mouse_event.SetPositionInWidget(15, 15);
   mouse_event.click_count = 1;
   shell()->web_contents()->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
-  mouse_event.SetType(blink::WebInputEvent::kMouseUp);
+  mouse_event.SetType(blink::WebInputEvent::Type::kMouseUp);
   shell()->web_contents()->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
 

content/browser/frame_host/cross_process_frame_connector.cc

@@ -225,9 +225,9 @@ void CrossProcessFrameConnector::ForwardAckedTouchpadZoomEvent(
 
 bool CrossProcessFrameConnector::BubbleScrollEvent(
     const blink::WebGestureEvent& event) {
-  DCHECK(event.GetType() == blink::WebInputEvent::kGestureScrollBegin ||
-         event.GetType() == blink::WebInputEvent::kGestureScrollUpdate ||
-         event.GetType() == blink::WebInputEvent::kGestureScrollEnd);
+  DCHECK(event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin ||
+         event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
+         event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd);
   auto* parent_view = GetParentRenderWidgetHostView();
 
   if (!parent_view)

content/browser/pointer_lock_browsertest.cc

@@ -269,7 +269,8 @@ IN_PROC_BROWSER_TEST_F(PointerLockBrowserTest, MAYBE_PointerLockEventRouting) {
 
   // Send a mouse move to root frame before lock to set last mouse position.
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseMove, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseMove,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.pointer_type = blink::WebPointerProperties::PointerType::kMouse;
   mouse_event.SetPositionInWidget(6, 7);
@@ -524,7 +525,8 @@ IN_PROC_BROWSER_TEST_F(PointerLockBrowserTest,
 
   // Send a mouse move to root frame before lock to set last mouse position.
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseMove, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseMove,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.pointer_type = blink::WebPointerProperties::PointerType::kMouse;
   mouse_event.SetPositionInWidget(6, 7);
@@ -556,7 +558,8 @@ IN_PROC_BROWSER_TEST_F(PointerLockBrowserTest,
   root_observer.Wait();
 
   blink::WebMouseWheelEvent wheel_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   wheel_event.SetPositionInScreen(10, 11);
   wheel_event.delta_x = -12;
@@ -759,7 +762,8 @@ IN_PROC_BROWSER_TEST_F(PointerLockBrowserTestWithOptions,
 
   // Send a mouse move to root frame before lock.
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseMove, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseMove,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.pointer_type = blink::WebPointerProperties::PointerType::kMouse;
   mouse_event.SetPositionInWidget(6, 7);

content/browser/portal/portal_browsertest.cc

@@ -403,10 +403,10 @@ IN_PROC_BROWSER_TEST_F(PortalHitTestBrowserTest, DispatchInputEvent) {
   gfx::Point root_location =
       portal_view->TransformPointToRootCoordSpace(gfx::Point(5, 5));
   InputEventAckWaiter waiter(main_frame->GetRenderWidgetHost(),
-                             blink::WebInputEvent::kMouseDown);
-  SimulateRoutedMouseEvent(web_contents_impl, blink::WebInputEvent::kMouseDown,
-                           blink::WebPointerProperties::Button::kLeft,
-                           root_location);
+                             blink::WebInputEvent::Type::kMouseDown);
+  SimulateRoutedMouseEvent(
+      web_contents_impl, blink::WebInputEvent::Type::kMouseDown,
+      blink::WebPointerProperties::Button::kLeft, root_location);
   waiter.Wait();
 
   // Check that the click event was only received by the main frame.
@@ -483,10 +483,10 @@ IN_PROC_BROWSER_TEST_F(PortalHitTestBrowserTest, NoInputToOOPIFInPortal) {
   gfx::Point root_location =
       oopif_view->TransformPointToRootCoordSpace(gfx::Point(5, 5));
   InputEventAckWaiter waiter(main_frame->GetRenderWidgetHost(),
-                             blink::WebInputEvent::kMouseDown);
-  SimulateRoutedMouseEvent(web_contents_impl, blink::WebInputEvent::kMouseDown,
-                           blink::WebPointerProperties::Button::kLeft,
-                           root_location);
+                             blink::WebInputEvent::Type::kMouseDown);
+  SimulateRoutedMouseEvent(
+      web_contents_impl, blink::WebInputEvent::Type::kMouseDown,
+      blink::WebPointerProperties::Button::kLeft, root_location);
   waiter.Wait();
 
   // Check that the click event was only received by the main frame.
@@ -598,9 +598,9 @@ IN_PROC_BROWSER_TEST_F(PortalHitTestBrowserTest,
   gfx::Point root_location =
       oopif_view->TransformPointToRootCoordSpace(gfx::Point(10, 10));
   InputEventAckWaiter waiter(oopif->GetRenderWidgetHost(),
-                             blink::WebInputEvent::kMouseDown);
+                             blink::WebInputEvent::Type::kMouseDown);
   SimulateRoutedMouseEvent(
-      shell()->web_contents(), blink::WebInputEvent::kMouseDown,
+      shell()->web_contents(), blink::WebInputEvent::Type::kMouseDown,
       blink::WebPointerProperties::Button::kLeft, root_location);
   waiter.Wait();
 

content/browser/renderer_host/direct_manipulation_win_browsertest.cc

@@ -321,7 +321,7 @@ IN_PROC_BROWSER_TEST_F(PrecisionTouchpadBrowserTest, PreventDefaultPinchZoom) {
   // ACK result itself isn't relevant in this test.
   auto input_msg_watcher = std::make_unique<InputMsgWatcher>(
       web_contents->GetRenderViewHost()->GetWidget(),
-      blink::WebInputEvent::kGesturePinchUpdate);
+      blink::WebInputEvent::Type::kGesturePinchUpdate);
 
   // First, test a standard zoom.
   UpdateContents(kInitialZoom, 0, 0);
@@ -405,7 +405,7 @@ IN_PROC_BROWSER_TEST_F(PrecisionTouchpadBrowserTest, PreventDefaultScroll) {
   // ACK result itself isn't relevant in this test.
   auto input_msg_watcher = std::make_unique<InputMsgWatcher>(
       web_contents->GetRenderViewHost()->GetWidget(),
-      blink::WebInputEvent::kMouseWheel);
+      blink::WebInputEvent::Type::kMouseWheel);
 
   // First, test scrolling vertically
   UpdateContents(1, 0, -kInitialScrollDistance);

content/browser/renderer_host/input/fling_browsertest.cc

@@ -149,7 +149,7 @@ class BrowserSideFlingBrowserTest : public ContentBrowserTest {
                   render_widget_host,
                   blink::WebInputEvent::Type::kGestureScrollBegin);
     blink::WebGestureEvent gesture_scroll_begin(
-        blink::WebGestureEvent::kGestureScrollBegin,
+        blink::WebGestureEvent::Type::kGestureScrollBegin,
         blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     gesture_scroll_begin.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
     gesture_scroll_begin.data.scroll_begin.delta_hint_units =
@@ -172,7 +172,7 @@ class BrowserSideFlingBrowserTest : public ContentBrowserTest {
 
     //  Send a GFS.
     blink::WebGestureEvent gesture_fling_start(
-        blink::WebGestureEvent::kGestureFlingStart,
+        blink::WebGestureEvent::Type::kGestureFlingStart,
         blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     gesture_fling_start.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
     gesture_fling_start.data.fling_start.velocity_x = fling_velocity.x();
@@ -218,7 +218,7 @@ class BrowserSideFlingBrowserTest : public ContentBrowserTest {
 
     //  Send a GFS.
     blink::WebGestureEvent gesture_fling_start(
-        blink::WebGestureEvent::kGestureFlingStart,
+        blink::WebGestureEvent::Type::kGestureFlingStart,
         blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     gesture_fling_start.SetSourceDevice(blink::WebGestureDevice::kTouchpad);
     gesture_fling_start.data.fling_start.velocity_x = fling_velocity.x();
@@ -432,7 +432,7 @@ IN_PROC_BROWSER_TEST_F(BrowserSideFlingBrowserTest,
   auto input_msg_watcher = std::make_unique<InputMsgWatcher>(
       GetWidgetHost(), blink::WebInputEvent::Type::kGestureScrollEnd);
   blink::WebGestureEvent gesture_fling_cancel(
-      blink::WebGestureEvent::kGestureFlingCancel,
+      blink::WebGestureEvent::Type::kGestureFlingCancel,
       blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
   gesture_fling_cancel.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
 

content/browser/renderer_host/input/gesture_event_queue_unittest.cc

@@ -524,7 +524,8 @@ TEST_F(GestureEventQueueWithCompositorEventQueueTest,
   // Simulate GSB ACK.
   SendInputEventACK(WebInputEvent::Type::kGestureScrollBegin,
                     blink::mojom::InputEventResultState::kConsumed);
-  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, last_acked_event().GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollBegin,
+            last_acked_event().GetType());
   EXPECT_EQ(2U, GestureEventQueueSize());
 
   // Simulate GSE ACK first since it's usually dispatched non-blocking.
@@ -590,7 +591,8 @@ TEST_F(GestureEventQueueWithCompositorEventQueueTest,
                     blink::mojom::InputEventResultState::kConsumed);
   SendInputEventACK(WebInputEvent::Type::kGesturePinchUpdate,
                     blink::mojom::InputEventResultState::kConsumed);
-  EXPECT_EQ(WebInputEvent::kGesturePinchUpdate, last_acked_event().GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGesturePinchUpdate,
+            last_acked_event().GetType());
   EXPECT_EQ(0U, GestureEventQueueSize());
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 }

content/browser/renderer_host/input/input_router_impl_unittest.cc

@@ -205,7 +205,7 @@ class MockInputRouterImplClient : public InputRouterImplClient {
   int in_flight_event_count() const {
     return input_router_client_.in_flight_event_count();
   }
-  int last_in_flight_event_type() const {
+  blink::WebInputEvent::Type last_in_flight_event_type() const {
     return input_router_client_.last_in_flight_event_type();
   }
   void set_allow_send_event(bool allow) {

content/browser/renderer_host/input/render_widget_host_latency_tracker_unittest.cc

@@ -756,8 +756,8 @@ TEST_F(RenderWidgetHostLatencyTrackerTest, MAYBE_ScrollbarEndToEndHistograms) {
   contents()->NavigateAndCommit(url);
   ResetHistograms();
   {
-    auto mouse_move =
-        SyntheticWebMouseEventBuilder::Build(blink::WebMouseEvent::kMouseMove);
+    auto mouse_move = SyntheticWebMouseEventBuilder::Build(
+        blink::WebMouseEvent::Type::kMouseMove);
     base::TimeTicks now = base::TimeTicks::Now();
 
     const ui::LatencyComponentType scroll_components[] = {
@@ -851,8 +851,8 @@ TEST_F(RenderWidgetHostLatencyTrackerTest,
   }
 
   {
-    auto mouse_move =
-        SyntheticWebMouseEventBuilder::Build(blink::WebMouseEvent::kMouseMove);
+    auto mouse_move = SyntheticWebMouseEventBuilder::Build(
+        blink::WebMouseEvent::Type::kMouseMove);
     ui::LatencyInfo mouse_latency;
     AddFakeComponents(*tracker(), &mouse_latency);
     tracker()->OnInputEvent(mouse_move, &mouse_latency);
@@ -863,8 +863,8 @@ TEST_F(RenderWidgetHostLatencyTrackerTest,
   }
 
   {
-    auto key_event =
-        SyntheticWebKeyboardEventBuilder::Build(blink::WebKeyboardEvent::kChar);
+    auto key_event = SyntheticWebKeyboardEventBuilder::Build(
+        blink::WebKeyboardEvent::Type::kChar);
     ui::LatencyInfo key_latency;
     key_latency.set_source_event_type(ui::SourceEventType::KEY_PRESS);
     AddFakeComponents(*tracker(), &key_latency);
@@ -1144,7 +1144,7 @@ TEST_F(RenderWidgetHostLatencyTrackerTest, KeyBlockingAndQueueingTime) {
        {blink::mojom::InputEventResultState::kNotConsumed,
         blink::mojom::InputEventResultState::kConsumed}) {
     {
-      NativeWebKeyboardEvent event(blink::WebKeyboardEvent::kRawKeyDown,
+      NativeWebKeyboardEvent event(blink::WebKeyboardEvent::Type::kRawKeyDown,
                                    blink::WebInputEvent::kNoModifiers,
                                    base::TimeTicks::Now());
       ui::LatencyInfo latency_info;

content/browser/renderer_host/input/wheel_scroll_latching_browsertest.cc

@@ -287,7 +287,7 @@ IN_PROC_BROWSER_TEST_F(WheelScrollLatchingBrowserTest,
 #endif
   // Send a GSB event to start scrolling the scrollableDiv.
   blink::WebGestureEvent gesture_scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchpad);
@@ -302,7 +302,8 @@ IN_PROC_BROWSER_TEST_F(WheelScrollLatchingBrowserTest,
 
   // Send the first GSU event.
   blink::WebGestureEvent gesture_scroll_update(gesture_scroll_begin);
-  gesture_scroll_update.SetType(blink::WebGestureEvent::kGestureScrollUpdate);
+  gesture_scroll_update.SetType(
+      blink::WebGestureEvent::Type::kGestureScrollUpdate);
   gesture_scroll_update.data.scroll_update.delta_units =
       precise ? ui::ScrollGranularity::kScrollByPrecisePixel
               : ui::ScrollGranularity::kScrollByPixel;

content/browser/renderer_host/mock_render_widget_host.cc

@@ -102,7 +102,7 @@ MockRenderWidgetHost::MockRenderWidgetHost(
       new_content_rendering_timeout_fired_(false),
       widget_impl_(std::move(widget_impl)),
       fling_scheduler_(std::make_unique<FlingScheduler>(this)) {
-  acked_touch_event_type_ = blink::WebInputEvent::kUndefined;
+  acked_touch_event_type_ = blink::WebInputEvent::Type::kUndefined;
 }
 
 }  // namespace content

content/browser/renderer_host/native_web_keyboard_event_aura.cc

@@ -60,11 +60,11 @@ class TranslatedKeyEvent : public ui::KeyEvent {
   static TranslatedKeyEvent* Create(const blink::WebKeyboardEvent& web_event) {
     ui::EventType type = ui::ET_KEY_RELEASED;
     bool is_char = false;
-    if (web_event.GetType() == blink::WebInputEvent::kChar) {
+    if (web_event.GetType() == blink::WebInputEvent::Type::kChar) {
       is_char = true;
       type = ui::ET_KEY_PRESSED;
-    } else if (web_event.GetType() == blink::WebInputEvent::kRawKeyDown ||
-               web_event.GetType() == blink::WebInputEvent::kKeyDown) {
+    } else if (web_event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
+               web_event.GetType() == blink::WebInputEvent::Type::kKeyDown) {
       type = ui::ET_KEY_PRESSED;
     }
     // look up the DomCode in the table because we can't trust the
@@ -130,7 +130,7 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent(const ui::KeyEvent& key_event,
     : WebKeyboardEvent(ui::MakeWebKeyboardEvent(key_event)),
       os_event(nullptr),
       skip_in_browser(false) {
-  type_ = blink::WebInputEvent::kChar;
+  type_ = blink::WebInputEvent::Type::kChar;
   windows_key_code = character;
   text[0] = character;
   unmodified_text[0] = character;

content/browser/renderer_host/native_web_keyboard_event_mac.mm

@@ -53,9 +53,9 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent(
     : WebKeyboardEvent(web_event), os_event(nullptr), skip_in_browser(false) {
   NSEventType type = NSKeyUp;
   int flags = modifiersForEvent(web_event.GetModifiers());
-  if (web_event.GetType() == blink::WebInputEvent::kChar ||
-      web_event.GetType() == blink::WebInputEvent::kRawKeyDown ||
-      web_event.GetType() == blink::WebInputEvent::kKeyDown) {
+  if (web_event.GetType() == blink::WebInputEvent::Type::kChar ||
+      web_event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
+      web_event.GetType() == blink::WebInputEvent::Type::kKeyDown) {
     type = NSKeyDown;
   }
   size_t text_length = WebKeyboardEventTextLength(web_event.text);

content/browser/renderer_host/overscroll_controller.cc

@@ -35,7 +35,7 @@ bool IsGestureEventFromAutoscroll(const blink::WebGestureEvent event) {
 }
 
 bool IsGestureScrollUpdateInertialEvent(const blink::WebInputEvent& event) {
-  if (event.GetType() != blink::WebInputEvent::kGestureScrollUpdate)
+  if (event.GetType() != blink::WebInputEvent::Type::kGestureScrollUpdate)
     return false;
 
   const blink::WebGestureEvent& gesture =
@@ -58,9 +58,9 @@ OverscrollController::~OverscrollController() {}
 bool OverscrollController::ShouldProcessEvent(
     const blink::WebInputEvent& event) {
   switch (event.GetType()) {
-    case blink::WebInputEvent::kGestureScrollBegin:
-    case blink::WebInputEvent::kGestureScrollUpdate:
-    case blink::WebInputEvent::kGestureScrollEnd: {
+    case blink::WebInputEvent::Type::kGestureScrollBegin:
+    case blink::WebInputEvent::Type::kGestureScrollUpdate:
+    case blink::WebInputEvent::Type::kGestureScrollEnd: {
       const blink::WebGestureEvent& gesture =
           static_cast<const blink::WebGestureEvent&>(event);
 
@@ -70,13 +70,13 @@ bool OverscrollController::ShouldProcessEvent(
 
       ui::ScrollGranularity granularity;
       switch (event.GetType()) {
-        case blink::WebInputEvent::kGestureScrollBegin:
+        case blink::WebInputEvent::Type::kGestureScrollBegin:
           granularity = gesture.data.scroll_begin.delta_hint_units;
           break;
-        case blink::WebInputEvent::kGestureScrollUpdate:
+        case blink::WebInputEvent::Type::kGestureScrollUpdate:
           granularity = gesture.data.scroll_update.delta_units;
           break;
-        case blink::WebInputEvent::kGestureScrollEnd:
+        case blink::WebInputEvent::Type::kGestureScrollEnd:
           granularity = gesture.data.scroll_end.delta_units;
           break;
         default:
@@ -104,10 +104,10 @@ bool OverscrollController::WillHandleEvent(const blink::WebInputEvent& event) {
 
   // TODO(mohsen): Consider filtering mouse-wheel events during overscroll. See
   // https://crbug.com/772106.
-  if (event.GetType() == blink::WebInputEvent::kMouseWheel)
+  if (event.GetType() == blink::WebInputEvent::Type::kMouseWheel)
     return false;
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
     ignore_following_inertial_events_ = false;
     first_inertial_event_time_.reset();
     time_since_last_ignored_scroll_ =
@@ -116,7 +116,7 @@ bool OverscrollController::WillHandleEvent(const blink::WebInputEvent& event) {
     return false;
   }
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd) {
     if (scroll_state_ == ScrollState::CONTENT_CONSUMING ||
         overscroll_ignored_) {
       last_ignored_scroll_time_ = event.TimeStamp();
@@ -134,7 +134,7 @@ bool OverscrollController::WillHandleEvent(const blink::WebInputEvent& event) {
   if (scroll_state_ != ScrollState::NONE || overscroll_delta_x_ ||
       overscroll_delta_y_) {
     switch (event.GetType()) {
-      case blink::WebInputEvent::kGestureFlingStart:
+      case blink::WebInputEvent::Type::kGestureFlingStart:
         reset_scroll_state = true;
         break;
 
@@ -175,8 +175,8 @@ bool OverscrollController::WillHandleEvent(const blink::WebInputEvent& event) {
   // In overscrolling state, consume scroll-update and fling-start events when
   // they do not contribute to overscroll in order to prevent content scroll.
   return scroll_state_ == ScrollState::OVERSCROLLING &&
-         (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate ||
-          event.GetType() == blink::WebInputEvent::kGestureFlingStart);
+         (event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
+          event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart);
 }
 
 void OverscrollController::OnDidOverscroll(
@@ -203,8 +203,8 @@ void OverscrollController::ReceivedEventACK(const blink::WebInputEvent& event,
     // Similarly, if a mouse-wheel event is consumed, probably the page has
     // implemented its own scroll-like behavior and no overscroll should happen.
     if (scroll_state_ == ScrollState::NONE &&
-        (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate ||
-         event.GetType() == blink::WebInputEvent::kMouseWheel)) {
+        (event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
+         event.GetType() == blink::WebInputEvent::Type::kMouseWheel)) {
       scroll_state_ = ScrollState::CONTENT_CONSUMING;
     }
     // In overscrolling state, only return if we are in an overscroll mode;
@@ -216,7 +216,7 @@ void OverscrollController::ReceivedEventACK(const blink::WebInputEvent& event,
     }
   }
 
-  if (event.GetType() == blink::WebInputEvent::kMouseWheel)
+  if (event.GetType() == blink::WebInputEvent::Type::kMouseWheel)
     return;
 
   ProcessEventForOverscroll(event);
@@ -243,15 +243,15 @@ bool OverscrollController::DispatchEventCompletesAction(
 
   // Complete the overscroll gesture if there was a mouse move or a scroll-end
   // after the threshold.
-  if (event.GetType() != blink::WebInputEvent::kMouseMove &&
-      event.GetType() != blink::WebInputEvent::kGestureScrollEnd &&
-      event.GetType() != blink::WebInputEvent::kGestureFlingStart &&
-      event.GetType() != blink::WebInputEvent::kGestureScrollUpdate)
+  if (event.GetType() != blink::WebInputEvent::Type::kMouseMove &&
+      event.GetType() != blink::WebInputEvent::Type::kGestureScrollEnd &&
+      event.GetType() != blink::WebInputEvent::Type::kGestureFlingStart &&
+      event.GetType() != blink::WebInputEvent::Type::kGestureScrollUpdate)
     return false;
 
   // Complete the overscroll gesture for inertial scroll (fling) event from
   // touchpad.
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate) {
     if (overscroll_source_ != OverscrollSource::TOUCHPAD)
       return false;
     DCHECK(IsGestureEventFromTouchpad(event));
@@ -262,7 +262,7 @@ bool OverscrollController::DispatchEventCompletesAction(
       return false;
   }
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd &&
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd &&
       overscroll_source_ == OverscrollSource::TOUCHPAD) {
     DCHECK(IsGestureEventFromTouchpad(event));
     // Complete the action for a GSE with touchpad source only when it is in
@@ -277,7 +277,7 @@ bool OverscrollController::DispatchEventCompletesAction(
   if (!delegate_)
     return false;
 
-  if (event.GetType() == blink::WebInputEvent::kGestureFlingStart) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
     // Check to see if the fling is in the same direction of the overscroll.
     const blink::WebGestureEvent gesture =
         static_cast<const blink::WebGestureEvent&>(event);
@@ -323,10 +323,10 @@ bool OverscrollController::DispatchEventResetsState(
     const blink::WebInputEvent& event) const {
   switch (event.GetType()) {
     // GestureScrollBegin/End ACK will reset overscroll state when necessary.
-    case blink::WebInputEvent::kGestureScrollBegin:
-    case blink::WebInputEvent::kGestureScrollEnd:
-    case blink::WebInputEvent::kGestureScrollUpdate:
-    case blink::WebInputEvent::kGestureFlingCancel:
+    case blink::WebInputEvent::Type::kGestureScrollBegin:
+    case blink::WebInputEvent::Type::kGestureScrollEnd:
+    case blink::WebInputEvent::Type::kGestureScrollUpdate:
+    case blink::WebInputEvent::Type::kGestureFlingCancel:
       return false;
 
     default:
@@ -340,12 +340,12 @@ bool OverscrollController::ProcessEventForOverscroll(
     const blink::WebInputEvent& event) {
   bool event_processed = false;
   switch (event.GetType()) {
-    case blink::WebInputEvent::kGestureScrollBegin: {
+    case blink::WebInputEvent::Type::kGestureScrollBegin: {
       if (overscroll_mode_ != OVERSCROLL_NONE)
         SetOverscrollMode(OVERSCROLL_NONE, OverscrollSource::NONE);
       break;
     }
-    case blink::WebInputEvent::kGestureScrollEnd: {
+    case blink::WebInputEvent::Type::kGestureScrollEnd: {
       // Only reset the state on  GestureScrollEnd generated from the touchpad
       // when the scrolling is in inertial state.
       const blink::WebGestureEvent gesture_event =
@@ -373,7 +373,7 @@ bool OverscrollController::ProcessEventForOverscroll(
       }
       break;
     }
-    case blink::WebInputEvent::kGestureScrollUpdate: {
+    case blink::WebInputEvent::Type::kGestureScrollUpdate: {
       const blink::WebGestureEvent& gesture =
           static_cast<const blink::WebGestureEvent&>(event);
       bool is_gesture_scroll_update_inertial_event =
@@ -401,7 +401,7 @@ bool OverscrollController::ProcessEventForOverscroll(
       }
       break;
     }
-    case blink::WebInputEvent::kGestureFlingStart: {
+    case blink::WebInputEvent::Type::kGestureFlingStart: {
       const float kFlingVelocityThreshold = 1100.f;
       const blink::WebGestureEvent& gesture =
           static_cast<const blink::WebGestureEvent&>(event);

content/browser/renderer_host/overscroll_controller_unittest.cc

@@ -175,9 +175,9 @@ TEST_F(OverscrollControllerTest,
   const base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchpad,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchpad, timestamp));
   SimulateAck(false);
 
   EXPECT_FALSE(SimulateGestureScrollUpdate(
@@ -222,9 +222,9 @@ TEST_F(OverscrollControllerTest, OnlyProcessLimitedInertialGSUEvents) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchpad,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchpad, timestamp));
   SimulateAck(false);
 
   EXPECT_FALSE(SimulateGestureScrollUpdate(
@@ -280,9 +280,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshDisabled) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchpad,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchpad, timestamp));
   SimulateAck(false);
 
   // Simulate a touchpad gesture scroll-update event that passes the start
@@ -310,9 +310,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshDisabled) {
 
   timestamp += base::TimeDelta::FromSeconds(1);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -330,9 +330,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshDisabled) {
 
   // Simulate a touchscreen gesture scroll-end which would normally end
   // pull-to-refresh, and ACK it as not processed. Nothing should happen.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -349,9 +349,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabled) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchpad,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchpad, timestamp));
   SimulateAck(false);
 
   // Simulate a touchpad gesture scroll-update event that passes the start
@@ -378,9 +378,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabled) {
 
   timestamp += base::TimeDelta::FromSeconds(1);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -397,9 +397,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabled) {
 
   // Simulate a touchscreen gesture scroll-end and ACK it as not processed. It
   // should abort pull-to-refresh.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -416,9 +416,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabledTouchscreen) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchpad,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchpad, timestamp));
   SimulateAck(false);
 
   // Simulate a touchpad gesture scroll-update event that passes the start
@@ -446,9 +446,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabledTouchscreen) {
 
   timestamp += base::TimeDelta::FromSeconds(1);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -465,9 +465,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshEnabledTouchscreen) {
 
   // Simulate a touchscreen gesture scroll-end and ACK it as not processed. It
   // should abort pull-to-refresh.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -512,9 +512,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -531,9 +531,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which would normally end
   // pull-to-refresh, and ACK it as not processed. Nothing should happen.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -543,9 +543,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
   // 2) Scroll before cool off -> PTR not triggered.
   timestamp += base::TimeDelta::FromMilliseconds(500);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -563,9 +563,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which would normally end
   // pull-to-refresh, and ACK it as not processed. Nothing should happen.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -575,9 +575,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
   // 3) Scroll before cool off -> PTR not triggered.
   timestamp += base::TimeDelta::FromMilliseconds(500);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -595,9 +595,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which would normally end
   // pull-to-refresh, and ACK it as not processed. Nothing should happen.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -607,9 +607,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
   // 4) Scroll after cool off -> PTR triggered.
   timestamp += base::TimeDelta::FromSeconds(1);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -626,9 +626,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which will end pull-to-refresh,
   // and ACK it as not processed. Pull-to-refresh should be aborted.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -638,9 +638,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
   // 5) Scroll before cool off -> PTR triggered.
   timestamp += base::TimeDelta::FromMilliseconds(500);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -657,9 +657,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshBeforeCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which will end pull-to-refresh,
   // and ACK it as not processed. Pull-to-refresh should be aborted.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -681,9 +681,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
   base::TimeTicks timestamp =
       blink::WebInputEvent::GetStaticTimeStampForTests();
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -700,9 +700,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which would normally end
   // pull-to-refresh, and ACK it as not processed. Nothing should happen.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -712,9 +712,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
   // 2) Scroll after cool off -> PTR triggered.
   timestamp += base::TimeDelta::FromSeconds(1);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -731,9 +731,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which will end pull-to-refresh,
   // and ACK it as not processed. Pull-to-refresh should be aborted.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());
@@ -743,9 +743,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
   // 3) Scroll before cool off -> PTR triggered.
   timestamp += base::TimeDelta::FromMilliseconds(500);
 
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollBegin,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollBegin,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
 
   // Simulate a touchscreen gesture scroll-update event that passes the start
@@ -762,9 +762,9 @@ TEST_F(OverscrollControllerTest, PullToRefreshAfterCoolOff) {
 
   // Simulate a touchscreen gesture scroll-end which will end pull-to-refresh,
   // and ACK it as not processed. Pull-to-refresh should be aborted.
-  EXPECT_FALSE(SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebGestureDevice::kTouchscreen,
-                                    timestamp));
+  EXPECT_FALSE(
+      SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
+                           blink::WebGestureDevice::kTouchscreen, timestamp));
   SimulateAck(false);
   EXPECT_EQ(OVERSCROLL_NONE, controller_mode());
   EXPECT_EQ(OverscrollSource::NONE, controller_source());

content/browser/renderer_host/render_view_host_impl.cc

@@ -959,7 +959,7 @@ RenderViewHostImpl::GetAssociatedPageBroadcast() {
 
 void RenderViewHostImpl::RenderWidgetDidForwardMouseEvent(
     const blink::WebMouseEvent& mouse_event) {
-  if (mouse_event.GetType() == WebInputEvent::kMouseWheel &&
+  if (mouse_event.GetType() == WebInputEvent::Type::kMouseWheel &&
       GetWidget()->IsIgnoringInputEvents()) {
     delegate_->OnIgnoredUIEvent();
   }
@@ -968,7 +968,7 @@ void RenderViewHostImpl::RenderWidgetDidForwardMouseEvent(
 bool RenderViewHostImpl::MayRenderWidgetForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   if (GetWidget()->IsIgnoringInputEvents()) {
-    if (key_event.GetType() == WebInputEvent::kRawKeyDown)
+    if (key_event.GetType() == WebInputEvent::Type::kRawKeyDown)
       delegate_->OnIgnoredUIEvent();
     return false;
   }

content/browser/renderer_host/render_widget_host_browsertest.cc

@@ -194,7 +194,7 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostTouchEmulatorBrowserTest,
         new SyntheticSmoothDragGesture(params));
 
     InputEventAckWaiter scroll_end_ack_waiter(
-        host(), blink::WebInputEvent::kGestureScrollEnd);
+        host(), blink::WebInputEvent::Type::kGestureScrollEnd);
     base::RunLoop run_loop;
     host()->QueueSyntheticGesture(
         std::move(gesture),
@@ -211,7 +211,7 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostTouchEmulatorBrowserTest,
     TestInputEventObserver::EventTypeVector dispatched_events =
         observer.GetAndResetDispatchedEventTypes();
     auto it_gse = std::find(dispatched_events.begin(), dispatched_events.end(),
-                            blink::WebInputEvent::kGestureScrollEnd);
+                            blink::WebInputEvent::Type::kGestureScrollEnd);
     EXPECT_NE(dispatched_events.end(), it_gse);
   } while (!touch_emulator->suppress_next_fling_cancel_for_testing());
 }
@@ -235,139 +235,163 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostTouchEmulatorBrowserTest,
 
   // Simulate a mouse move without any pressed buttons. This should not
   // generate any touch events.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 10, 0, false);
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 10, 0,
+                           false);
   TestInputEventObserver::EventTypeVector dispatched_events =
       observer.GetAndResetDispatchedEventTypes();
   EXPECT_EQ(0u, dispatched_events.size());
 
   // Mouse press becomes touch start which in turn becomes tap.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseDown, 10, 10, 0, true);
-  WaitForAckWith(blink::WebInputEvent::kTouchStart);
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseDown, 10, 10, 0,
+                           true);
+  WaitForAckWith(blink::WebInputEvent::Type::kTouchStart);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapDown, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapDown, dispatched_events[1]);
 
   // Mouse drag generates touch move, cancels tap and starts scroll.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 30, 0, true);
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 30, 0,
+                           true);
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(4u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapCancel, dispatched_events[1]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin, dispatched_events[2]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate, dispatched_events[3]);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapCancel,
+            dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
+            dispatched_events[2]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
+            dispatched_events[3]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   EXPECT_EQ(0u, observer.GetAndResetDispatchedEventTypes().size());
 
   // Mouse drag with shift becomes pinch.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 35,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 35,
                            blink::WebInputEvent::kShiftKey, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
 
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchBegin, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchBegin,
+            dispatched_events[1]);
 
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 50,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 50,
                            blink::WebInputEvent::kShiftKey, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
 
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchUpdate, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchUpdate,
+            dispatched_events[1]);
 
   // Mouse drag without shift becomes scroll again.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 60, 0, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 60, 0,
+                           true);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
 
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(3u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchEnd, dispatched_events[1]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate, dispatched_events[2]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchEnd, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
+            dispatched_events[2]);
 
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 70, 0, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 70, 0,
+                           true);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
+            dispatched_events[1]);
 
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseUp, 10, 70, 0, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchEnd, observer.acked_touch_event_type());
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseUp, 10, 70, 0,
+                           true);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchEnd,
+            observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchEnd, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchEnd, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
+            dispatched_events[1]);
 
   // Mouse move does nothing.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 80, 0, false);
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 80, 0,
+                           false);
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   EXPECT_EQ(0u, dispatched_events.size());
 
   // Another mouse down continues scroll.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseDown, 10, 80, 0, true);
-  WaitForAckWith(blink::WebInputEvent::kTouchStart);
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseDown, 10, 80, 0,
+                           true);
+  WaitForAckWith(blink::WebInputEvent::Type::kTouchStart);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapDown, dispatched_events[1]);
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 100, 0, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapDown, dispatched_events[1]);
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 100, 0,
+                           true);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(4u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapCancel, dispatched_events[1]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin, dispatched_events[2]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate, dispatched_events[3]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapCancel,
+            dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
+            dispatched_events[2]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
+            dispatched_events[3]);
   EXPECT_EQ(0u, observer.GetAndResetDispatchedEventTypes().size());
 
   // Another pinch.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 110,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 110,
                            blink::WebInputEvent::kShiftKey, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   EXPECT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchBegin, dispatched_events[1]);
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 120,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchBegin,
+            dispatched_events[1]);
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 120,
                            blink::WebInputEvent::kShiftKey, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   EXPECT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchUpdate, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchUpdate,
+            dispatched_events[1]);
 
   // Turn off emulation during a pinch.
   host()->GetTouchEmulator()->Disable();
-  EXPECT_EQ(blink::WebInputEvent::kTouchCancel,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchCancel,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(3u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchCancel, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGesturePinchEnd, dispatched_events[1]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd, dispatched_events[2]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchCancel, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGesturePinchEnd, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
+            dispatched_events[2]);
 
   // Mouse event should pass untouched.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 10,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 10,
                            blink::WebInputEvent::kShiftKey, true);
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(1u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kMouseMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kMouseMove, dispatched_events[0]);
 
   // Turn on emulation.
   host()->GetTouchEmulator()->Enable(
@@ -375,36 +399,42 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostTouchEmulatorBrowserTest,
       ui::GestureProviderConfigType::GENERIC_MOBILE);
 
   // Another touch.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseDown, 10, 10, 0, true);
-  WaitForAckWith(blink::WebInputEvent::kTouchStart);
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseDown, 10, 10, 0,
+                           true);
+  WaitForAckWith(blink::WebInputEvent::Type::kTouchStart);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchStart, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapDown, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchStart, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapDown, dispatched_events[1]);
 
   // Scroll.
-  SimulateRoutedMouseEvent(blink::WebInputEvent::kMouseMove, 10, 30, 0, true);
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove,
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 30, 0,
+                           true);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove,
             observer.acked_touch_event_type());
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(4u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchMove, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapCancel, dispatched_events[1]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin, dispatched_events[2]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate, dispatched_events[3]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchMove, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapCancel,
+            dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
+            dispatched_events[2]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
+            dispatched_events[3]);
   EXPECT_EQ(0u, observer.GetAndResetDispatchedEventTypes().size());
 
   // Turn off emulation during a scroll.
   host()->GetTouchEmulator()->Disable();
-  EXPECT_EQ(blink::WebInputEvent::kTouchCancel,
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchCancel,
             observer.acked_touch_event_type());
 
   dispatched_events = observer.GetAndResetDispatchedEventTypes();
   ASSERT_EQ(2u, dispatched_events.size());
-  EXPECT_EQ(blink::WebInputEvent::kTouchCancel, dispatched_events[0]);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd, dispatched_events[1]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kTouchCancel, dispatched_events[0]);
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
+            dispatched_events[1]);
 
   host()->RemoveInputEventObserver(&observer);
 }
@@ -480,7 +510,7 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostSitePerProcessTest,
   // Open the <select> menu by focusing it and sending a space key
   // at the focused node. This creates a popup widget.
   NativeWebKeyboardEvent event(
-      blink::WebKeyboardEvent::kChar, blink::WebInputEvent::kNoModifiers,
+      blink::WebKeyboardEvent::Type::kChar, blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   event.text[0] = ' ';
 

content/browser/renderer_host/render_widget_host_impl.cc

@@ -1234,8 +1234,8 @@ void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
                mouse_event.PositionInWidget().x(), "y",
                mouse_event.PositionInWidget().y());
 
-  DCHECK_GE(mouse_event.GetType(), blink::WebInputEvent::kMouseTypeFirst);
-  DCHECK_LE(mouse_event.GetType(), blink::WebInputEvent::kMouseTypeLast);
+  DCHECK_GE(mouse_event.GetType(), blink::WebInputEvent::Type::kMouseTypeFirst);
+  DCHECK_LE(mouse_event.GetType(), blink::WebInputEvent::Type::kMouseTypeLast);
 
   for (size_t i = 0; i < mouse_event_callbacks_.size(); ++i) {
     if (mouse_event_callbacks_[i].Run(mouse_event))
@@ -1331,7 +1331,8 @@ void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo(
   DCHECK_NE(gesture_event.SourceDevice(),
             blink::WebGestureDevice::kUninitialized);
 
-  if (gesture_event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+  if (gesture_event.GetType() ==
+      blink::WebInputEvent::Type::kGestureScrollBegin) {
     DCHECK(
         !is_in_gesture_scroll_[static_cast<int>(gesture_event.SourceDevice())]);
     is_in_gesture_scroll_[static_cast<int>(gesture_event.SourceDevice())] =
@@ -1339,7 +1340,7 @@ void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo(
     scroll_peak_gpu_mem_tracker_ =
         PeakGpuMemoryTracker::Create(PeakGpuMemoryTracker::Usage::SCROLL);
   } else if (gesture_event.GetType() ==
-             blink::WebInputEvent::kGestureScrollEnd) {
+             blink::WebInputEvent::Type::kGestureScrollEnd) {
     DCHECK(
         is_in_gesture_scroll_[static_cast<int>(gesture_event.SourceDevice())]);
     is_in_gesture_scroll_[static_cast<int>(gesture_event.SourceDevice())] =
@@ -1360,7 +1361,7 @@ void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo(
     }
     scroll_peak_gpu_mem_tracker_ = nullptr;
   } else if (gesture_event.GetType() ==
-             blink::WebInputEvent::kGestureFlingStart) {
+             blink::WebInputEvent::Type::kGestureFlingStart) {
     if (gesture_event.SourceDevice() == blink::WebGestureDevice::kTouchpad) {
       // TODO(sahel): Remove the VR specific case when motion events are used
       // for Android VR event processing and VR touchpad scrolling is handled by
@@ -1429,8 +1430,8 @@ void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   ui::LatencyInfo latency_info;
 
-  if (key_event.GetType() == WebInputEvent::kRawKeyDown ||
-      key_event.GetType() == WebInputEvent::kChar) {
+  if (key_event.GetType() == WebInputEvent::Type::kRawKeyDown ||
+      key_event.GetType() == WebInputEvent::Type::kChar) {
     latency_info.set_source_event_type(ui::SourceEventType::KEY_PRESS);
   }
   ForwardKeyboardEventWithLatencyInfo(key_event, latency_info);
@@ -1466,7 +1467,7 @@ void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
   if (KeyPressListenersHandleEvent(key_event)) {
     // Some keypresses that are accepted by the listener may be followed by Char
     // and KeyUp events, which should be ignored.
-    if (key_event.GetType() == WebKeyboardEvent::kRawKeyDown)
+    if (key_event.GetType() == WebKeyboardEvent::Type::kRawKeyDown)
       suppress_events_until_keydown_ = true;
     return;
   }
@@ -1475,11 +1476,11 @@ void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
     // If the preceding RawKeyDown event was handled by the browser, then we
     // need to suppress all events generated by it until the next RawKeyDown or
     // KeyDown event.
-    if (key_event.GetType() == WebKeyboardEvent::kKeyUp ||
-        key_event.GetType() == WebKeyboardEvent::kChar)
+    if (key_event.GetType() == WebKeyboardEvent::Type::kKeyUp ||
+        key_event.GetType() == WebKeyboardEvent::Type::kChar)
       return;
-    DCHECK(key_event.GetType() == WebKeyboardEvent::kRawKeyDown ||
-           key_event.GetType() == WebKeyboardEvent::kKeyDown);
+    DCHECK(key_event.GetType() == WebKeyboardEvent::Type::kRawKeyDown ||
+           key_event.GetType() == WebKeyboardEvent::Type::kKeyDown);
     suppress_events_until_keydown_ = false;
   }
 
@@ -1491,7 +1492,7 @@ void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
     // PreHandleKeyboardEvent() handles the event, but |this| may already be
     // destroyed at that time. So set |suppress_events_until_keydown_| true
     // here, then revert it afterwards when necessary.
-    if (key_event.GetType() == WebKeyboardEvent::kRawKeyDown)
+    if (key_event.GetType() == WebKeyboardEvent::Type::kRawKeyDown)
       suppress_events_until_keydown_ = true;
 
     // Tab switching/closing accelerators aren't sent to the renderer to avoid
@@ -1512,7 +1513,7 @@ void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
         break;
     }
 
-    if (key_event.GetType() == WebKeyboardEvent::kRawKeyDown)
+    if (key_event.GetType() == WebKeyboardEvent::Type::kRawKeyDown)
       suppress_events_until_keydown_ = false;
   }
 
@@ -2436,7 +2437,7 @@ void RenderWidgetHostImpl::OnAutoscrollFling(const gfx::Vector2dF& velocity) {
   if (!sent_autoscroll_scroll_begin_ && velocity != gfx::Vector2dF()) {
     // Send a GSB event with valid delta hints.
     WebGestureEvent scroll_begin = SyntheticWebGestureEventBuilder::Build(
-        WebInputEvent::kGestureScrollBegin,
+        WebInputEvent::Type::kGestureScrollBegin,
         blink::WebGestureDevice::kSyntheticAutoscroll);
     scroll_begin.SetPositionInWidget(autoscroll_start_position_);
     scroll_begin.data.scroll_begin.delta_x_hint = velocity.x();
@@ -2448,7 +2449,7 @@ void RenderWidgetHostImpl::OnAutoscrollFling(const gfx::Vector2dF& velocity) {
   }
 
   WebGestureEvent event = SyntheticWebGestureEventBuilder::Build(
-      WebInputEvent::kGestureFlingStart,
+      WebInputEvent::Type::kGestureFlingStart,
       blink::WebGestureDevice::kSyntheticAutoscroll);
   event.SetPositionInWidget(autoscroll_start_position_);
   event.data.fling_start.velocity_x = velocity.x();
@@ -2469,7 +2470,7 @@ void RenderWidgetHostImpl::OnAutoscrollEnd() {
 
   sent_autoscroll_scroll_begin_ = false;
   WebGestureEvent cancel_event = SyntheticWebGestureEventBuilder::Build(
-      WebInputEvent::kGestureFlingCancel,
+      WebInputEvent::Type::kGestureFlingCancel,
       blink::WebGestureDevice::kSyntheticAutoscroll);
   cancel_event.data.fling_cancel.prevent_boosting = true;
   cancel_event.SetPositionInWidget(autoscroll_start_position_);
@@ -2649,7 +2650,8 @@ RenderWidgetHostImpl::GetKeyboardLayoutMap() {
 
 bool RenderWidgetHostImpl::KeyPressListenersHandleEvent(
     const NativeWebKeyboardEvent& event) {
-  if (event.skip_in_browser || event.GetType() != WebKeyboardEvent::kRawKeyDown)
+  if (event.skip_in_browser ||
+      event.GetType() != WebKeyboardEvent::Type::kRawKeyDown)
     return false;
 
   for (size_t i = 0; i < key_press_event_callbacks_.size(); i++) {
@@ -2675,16 +2677,17 @@ blink::mojom::InputEventResultState RenderWidgetHostImpl::FilterInputEvent(
   // Don't ignore touch cancel events, since they may be sent while input
   // events are being ignored in order to keep the renderer from getting
   // confused about how many touches are active.
-  if (IsIgnoringInputEvents() && event.GetType() != WebInputEvent::kTouchCancel)
+  if (IsIgnoringInputEvents() &&
+      event.GetType() != WebInputEvent::Type::kTouchCancel)
     return blink::mojom::InputEventResultState::kNoConsumerExists;
 
   if (!process_->IsInitializedAndNotDead())
     return blink::mojom::InputEventResultState::kUnknown;
 
   if (delegate_) {
-    if (event.GetType() == WebInputEvent::kMouseDown ||
-        event.GetType() == WebInputEvent::kTouchStart ||
-        event.GetType() == WebInputEvent::kGestureTap) {
+    if (event.GetType() == WebInputEvent::Type::kMouseDown ||
+        event.GetType() == WebInputEvent::Type::kTouchStart ||
+        event.GetType() == WebInputEvent::Type::kGestureTap) {
       delegate_->FocusOwningWebContents(this);
     }
     delegate_->DidReceiveInputEvent(this, event.GetType());
@@ -2751,11 +2754,11 @@ void RenderWidgetHostImpl::AddPendingUserActivation(
     const WebInputEvent& event) {
   if ((base::FeatureList::IsEnabled(
            features::kBrowserVerifiedUserActivationMouse) &&
-       event.GetType() == WebInputEvent::kMouseDown) ||
+       event.GetType() == WebInputEvent::Type::kMouseDown) ||
       (base::FeatureList::IsEnabled(
            features::kBrowserVerifiedUserActivationKeyboard) &&
-       (event.GetType() == WebInputEvent::kKeyDown ||
-        event.GetType() == WebInputEvent::kRawKeyDown))) {
+       (event.GetType() == WebInputEvent::Type::kKeyDown ||
+        event.GetType() == WebInputEvent::Type::kRawKeyDown))) {
     pending_user_activation_timer_.Start(
         FROM_HERE, kActivationNotificationExpireTime,
         base::BindOnce(&RenderWidgetHostImpl::ClearPendingUserActivation,

content/browser/renderer_host/render_widget_host_input_event_router.cc

@@ -464,7 +464,7 @@ RenderWidgetTargetResult RenderWidgetHostInputEventRouter::FindMouseEventTarget(
   // Ignore mouse_capture_target_ if there are no mouse buttons currently down
   // because this is only for the purpose of dragging.
   if (!target && mouse_capture_target_ &&
-      (event.GetType() == blink::WebInputEvent::kMouseUp ||
+      (event.GetType() == blink::WebInputEvent::Type::kMouseUp ||
        IsMouseButtonDown(event))) {
     target = mouse_capture_target_;
     // Hit testing is skipped for MouseUp with mouse capture which is enabled by
@@ -475,7 +475,7 @@ RenderWidgetTargetResult RenderWidgetHostInputEventRouter::FindMouseEventTarget(
     // transforms from browser process and renderer process. We need to fix it
     // so that we don't need to cache the transform from MouseDown.
     // https://crbug.com/934434.
-    if (event.GetType() == blink::WebInputEvent::kMouseUp &&
+    if (event.GetType() == blink::WebInputEvent::Type::kMouseUp &&
         target == last_mouse_down_target_ &&
         mouse_down_pre_transformed_coordinate_ == event.PositionInWidget()) {
       transformed_point = mouse_down_post_transformed_coordinate_;
@@ -488,7 +488,7 @@ RenderWidgetTargetResult RenderWidgetHostInputEventRouter::FindMouseEventTarget(
     auto result =
         FindViewAtLocation(root_view, event.PositionInWidget(),
                            viz::EventSource::MOUSE, &transformed_point);
-    if (event.GetType() == blink::WebInputEvent::kMouseDown) {
+    if (event.GetType() == blink::WebInputEvent::Type::kMouseDown) {
       mouse_down_pre_transformed_coordinate_ = event.PositionInWidget();
     }
     if (result.should_query_view)
@@ -615,7 +615,7 @@ void RenderWidgetHostInputEventRouter::DispatchMouseEvent(
   // browser window.
   // Also, this is strictly necessary for touch emulation.
   if (mouse_capture_target_ &&
-      (mouse_event.GetType() == blink::WebInputEvent::kMouseUp ||
+      (mouse_event.GetType() == blink::WebInputEvent::Type::kMouseUp ||
        !IsMouseButtonDown(mouse_event))) {
     mouse_capture_target_ = nullptr;
 
@@ -645,7 +645,7 @@ void RenderWidgetHostInputEventRouter::DispatchMouseEvent(
   // When touch emulation is active, mouse events have to act like touch
   // events, which requires that there be implicit capture between MouseDown
   // and MouseUp.
-  if (mouse_event.GetType() == blink::WebInputEvent::kMouseDown &&
+  if (mouse_event.GetType() == blink::WebInputEvent::Type::kMouseDown &&
       touch_emulator_ && touch_emulator_->enabled()) {
     mouse_capture_target_ = target;
   }
@@ -658,8 +658,8 @@ void RenderWidgetHostInputEventRouter::DispatchMouseEvent(
   // coordinates, which are transformed independently for each view that will
   // receive an event. Also, since the view under the mouse has changed,
   // notify the CursorManager that it might need to change the cursor.
-  if ((event.GetType() == blink::WebInputEvent::kMouseLeave ||
-       event.GetType() == blink::WebInputEvent::kMouseMove) &&
+  if ((event.GetType() == blink::WebInputEvent::Type::kMouseLeave ||
+       event.GetType() == blink::WebInputEvent::Type::kMouseMove) &&
       target != last_mouse_move_target_ && !root_view->IsMouseLocked()) {
     SendMouseEnterOrLeaveEvents(mouse_event, target, root_view);
     if (root_view->GetCursorManager())
@@ -769,16 +769,16 @@ unsigned CountChangedTouchPoints(const blink::WebTouchEvent& event) {
   unsigned changed_count = 0;
 
   blink::WebTouchPoint::State required_state =
-      blink::WebTouchPoint::kStateUndefined;
+      blink::WebTouchPoint::State::kStateUndefined;
   switch (event.GetType()) {
-    case blink::WebInputEvent::kTouchStart:
-      required_state = blink::WebTouchPoint::kStatePressed;
+    case blink::WebInputEvent::Type::kTouchStart:
+      required_state = blink::WebTouchPoint::State::kStatePressed;
       break;
-    case blink::WebInputEvent::kTouchEnd:
-      required_state = blink::WebTouchPoint::kStateReleased;
+    case blink::WebInputEvent::Type::kTouchEnd:
+      required_state = blink::WebTouchPoint::State::kStateReleased;
       break;
-    case blink::WebInputEvent::kTouchCancel:
-      required_state = blink::WebTouchPoint::kStateCancelled;
+    case blink::WebInputEvent::Type::kTouchCancel:
+      required_state = blink::WebTouchPoint::State::kStateCancelled;
       break;
     default:
       // We'll only ever call this method for TouchStart, TouchEnd
@@ -790,7 +790,7 @@ unsigned CountChangedTouchPoints(const blink::WebTouchEvent& event) {
       ++changed_count;
   }
 
-  DCHECK(event.GetType() == blink::WebInputEvent::kTouchCancel ||
+  DCHECK(event.GetType() == blink::WebInputEvent::Type::kTouchCancel ||
          changed_count == 1);
   return changed_count;
 }
@@ -811,7 +811,8 @@ RenderWidgetTargetResult RenderWidgetHostInputEventRouter::FindTouchEventTarget(
     const blink::WebTouchEvent& event) {
   // Tests may call this without an initial TouchStart, so check event type
   // explicitly here.
-  if (active_touches_ || event.GetType() != blink::WebInputEvent::kTouchStart)
+  if (active_touches_ ||
+      event.GetType() != blink::WebInputEvent::Type::kTouchStart)
     return {nullptr, false, base::nullopt, true};
 
   active_touches_ += CountChangedTouchPoints(event);
@@ -830,7 +831,8 @@ void RenderWidgetHostInputEventRouter::DispatchTouchEvent(
     const base::Optional<gfx::PointF>& target_location,
     bool is_emulated_touchevent) {
   DCHECK(blink::WebInputEvent::IsTouchEventType(touch_event.GetType()) &&
-         touch_event.GetType() != blink::WebInputEvent::kTouchScrollStarted);
+         touch_event.GetType() !=
+             blink::WebInputEvent::Type::kTouchScrollStarted);
 
   bool is_sequence_start = !touch_target_ && target;
   if (is_sequence_start) {
@@ -840,15 +842,15 @@ void RenderWidgetHostInputEventRouter::DispatchTouchEvent(
            touchscreen_gesture_target_map_.end());
     touchscreen_gesture_target_map_[touch_event.unique_touch_event_id] =
         touch_target_;
-  } else if (touch_event.GetType() == blink::WebInputEvent::kTouchStart) {
+  } else if (touch_event.GetType() == blink::WebInputEvent::Type::kTouchStart) {
     active_touches_ += CountChangedTouchPoints(touch_event);
   }
 
   // Test active_touches_ before decrementing, since its value can be
   // reset to 0 in OnRenderWidgetHostViewBaseDestroyed, and this can
   // happen between the TouchStart and a subsequent TouchMove/End/Cancel.
-  if ((touch_event.GetType() == blink::WebInputEvent::kTouchEnd ||
-       touch_event.GetType() == blink::WebInputEvent::kTouchCancel) &&
+  if ((touch_event.GetType() == blink::WebInputEvent::Type::kTouchEnd ||
+       touch_event.GetType() == blink::WebInputEvent::Type::kTouchCancel) &&
       active_touches_) {
     active_touches_ -= CountChangedTouchPoints(touch_event);
   }
@@ -1011,7 +1013,7 @@ void RenderWidgetHostInputEventRouter::SendMouseEnterOrLeaveEvents(
   // Send MouseLeaves.
   for (auto* view : exited_views) {
     blink::WebMouseEvent mouse_leave(event);
-    mouse_leave.SetType(blink::WebInputEvent::kMouseLeave);
+    mouse_leave.SetType(blink::WebInputEvent::Type::kMouseLeave);
     mouse_leave.SetModifiers(mouse_leave.GetModifiers() | extra_modifiers);
     // There is a chance of a race if the last target has recently created a
     // new compositor surface. The SurfaceID for that might not have
@@ -1030,7 +1032,7 @@ void RenderWidgetHostInputEventRouter::SendMouseEnterOrLeaveEvents(
   if (common_ancestor && (include_target_view || common_ancestor != target)) {
     blink::WebMouseEvent mouse_move(event);
     mouse_move.SetModifiers(mouse_move.GetModifiers() | extra_modifiers);
-    mouse_move.SetType(blink::WebInputEvent::kMouseMove);
+    mouse_move.SetType(blink::WebInputEvent::Type::kMouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
             event.PositionInWidget(), common_ancestor, &transformed_point)) {
       transformed_point = gfx::PointF();
@@ -1046,7 +1048,7 @@ void RenderWidgetHostInputEventRouter::SendMouseEnterOrLeaveEvents(
       continue;
     blink::WebMouseEvent mouse_enter(event);
     mouse_enter.SetModifiers(mouse_enter.GetModifiers() | extra_modifiers);
-    mouse_enter.SetType(blink::WebInputEvent::kMouseMove);
+    mouse_enter.SetType(blink::WebInputEvent::Type::kMouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
             event.PositionInWidget(), view, &transformed_point)) {
       transformed_point = gfx::PointF();
@@ -1114,14 +1116,14 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
     RenderWidgetHostViewChildFrame* resending_view,
     const blink::WebGestureEvent& event) {
   DCHECK(target_view);
-  DCHECK(event.GetType() == blink::WebInputEvent::kGestureScrollBegin ||
-         event.GetType() == blink::WebInputEvent::kGestureScrollUpdate ||
-         event.GetType() == blink::WebInputEvent::kGestureScrollEnd);
+  DCHECK(event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin ||
+         event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
+         event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd);
 
   ui::LatencyInfo latency_info =
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event);
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
     forced_last_fling_start_target_to_stop_flinging_for_test_ = false;
     // If target_view has unrelated gesture events in progress, do
     // not proceed. This could cause confusion between independent
@@ -1156,7 +1158,8 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
     bubbling_gesture_scroll_source_device_ = event.SourceDevice();
     DCHECK(IsAncestorView(bubbling_gesture_scroll_origin_,
                           bubbling_gesture_scroll_target_));
-  } else {  // !(event.GetType() == blink::WebInputEvent::kGestureScrollBegin)
+  } else {  // !(event.GetType() ==
+            // blink::WebInputEvent::Type::kGestureScrollBegin)
     if (!bubbling_gesture_scroll_target_) {
       // Drop any acked events that come in after bubbling has ended.
       // TODO(mcnee): If we inform |bubbling_gesture_scroll_origin_| and the
@@ -1167,7 +1170,7 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
 
     // Don't bubble the GSE events that are generated and sent to intermediate
     // bubbling targets.
-    if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd &&
+    if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd &&
         resending_view != bubbling_gesture_scroll_origin_) {
       return true;
     }
@@ -1190,7 +1193,7 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
       event.SourceDevice() == blink::WebGestureDevice::kTouchscreen &&
       !bubbling_gesture_scroll_target_->IsRenderWidgetHostViewChildFrame();
   if (touchscreen_bubble_to_root) {
-    if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+    if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
       touchscreen_pinch_state_.DidStartBubblingToRoot();
 
       // If a pinch's scroll sequence is sent to an OOPIF and the pinch
@@ -1200,7 +1203,8 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
       if (touchscreen_pinch_state_.IsInPinch()) {
         return true;
       }
-    } else if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd) {
+    } else if (event.GetType() ==
+               blink::WebInputEvent::Type::kGestureScrollEnd) {
       touchscreen_pinch_state_.DidStopBubblingToRoot();
     }
   }
@@ -1209,7 +1213,7 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
       GestureEventInTarget(event, bubbling_gesture_scroll_target_),
       latency_info);
 
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd) {
     bubbling_gesture_scroll_origin_ = nullptr;
     bubbling_gesture_scroll_target_ = nullptr;
     bubbling_gesture_scroll_source_device_ =
@@ -1221,10 +1225,10 @@ bool RenderWidgetHostInputEventRouter::BubbleScrollEvent(
 void RenderWidgetHostInputEventRouter::SendGestureScrollBegin(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
-  DCHECK_EQ(blink::WebInputEvent::kGesturePinchBegin, event.GetType());
+  DCHECK_EQ(blink::WebInputEvent::Type::kGesturePinchBegin, event.GetType());
   DCHECK_EQ(blink::WebGestureDevice::kTouchscreen, event.SourceDevice());
   blink::WebGestureEvent scroll_begin(event);
-  scroll_begin.SetType(blink::WebInputEvent::kGestureScrollBegin);
+  scroll_begin.SetType(blink::WebInputEvent::Type::kGestureScrollBegin);
   scroll_begin.data.scroll_begin.delta_x_hint = 0;
   scroll_begin.data.scroll_begin.delta_y_hint = 0;
   scroll_begin.data.scroll_begin.delta_hint_units =
@@ -1240,16 +1244,16 @@ void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
   blink::WebGestureEvent scroll_end(event);
-  scroll_end.SetType(blink::WebInputEvent::kGestureScrollEnd);
+  scroll_end.SetType(blink::WebInputEvent::Type::kGestureScrollEnd);
   scroll_end.SetTimeStamp(base::TimeTicks::Now());
   switch (event.GetType()) {
-    case blink::WebInputEvent::kGestureScrollBegin:
+    case blink::WebInputEvent::Type::kGestureScrollBegin:
       scroll_end.data.scroll_end.inertial_phase =
           event.data.scroll_begin.inertial_phase;
       scroll_end.data.scroll_end.delta_units =
           event.data.scroll_begin.delta_hint_units;
       break;
-    case blink::WebInputEvent::kGesturePinchEnd:
+    case blink::WebInputEvent::Type::kGesturePinchEnd:
       DCHECK_EQ(blink::WebGestureDevice::kTouchscreen, event.SourceDevice());
       scroll_end.data.scroll_end.inertial_phase =
           blink::WebGestureEvent::InertialPhaseState::kUnknownMomentum;
@@ -1267,9 +1271,10 @@ void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
 void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
     RenderWidgetHostViewBase* view,
     blink::WebGestureDevice source_device) {
-  blink::WebGestureEvent scroll_end(blink::WebInputEvent::kGestureScrollEnd,
-                                    blink::WebInputEvent::kNoModifiers,
-                                    base::TimeTicks::Now(), source_device);
+  blink::WebGestureEvent scroll_end(
+      blink::WebInputEvent::Type::kGestureScrollEnd,
+      blink::WebInputEvent::kNoModifiers, base::TimeTicks::Now(),
+      source_device);
   scroll_end.data.scroll_end.inertial_phase =
       blink::WebGestureEvent::InertialPhaseState::kUnknownMomentum;
   scroll_end.data.scroll_end.delta_units =
@@ -1449,7 +1454,8 @@ void RenderWidgetHostInputEventRouter::DispatchTouchscreenGestureEvent(
     const blink::WebGestureEvent& gesture_event,
     const ui::LatencyInfo& latency,
     const base::Optional<gfx::PointF>& target_location) {
-  if (gesture_event.GetType() == blink::WebInputEvent::kGesturePinchBegin) {
+  if (gesture_event.GetType() ==
+      blink::WebInputEvent::Type::kGesturePinchBegin) {
     if (root_view == touchscreen_gesture_target_) {
       // If the root view is the current gesture target, there is no need to
       // wrap the pinch events ourselves.
@@ -1481,7 +1487,8 @@ void RenderWidgetHostInputEventRouter::DispatchTouchscreenGestureEvent(
   if (touchscreen_pinch_state_.IsInPinch()) {
     root_view->ProcessGestureEvent(gesture_event, latency);
 
-    if (gesture_event.GetType() == blink::WebInputEvent::kGesturePinchEnd) {
+    if (gesture_event.GetType() ==
+        blink::WebInputEvent::Type::kGesturePinchEnd) {
       const bool send_scroll_end =
           touchscreen_pinch_state_.NeedsWrappingScrollSequence();
       touchscreen_pinch_state_.DidStopPinch();
@@ -1497,7 +1504,8 @@ void RenderWidgetHostInputEventRouter::DispatchTouchscreenGestureEvent(
     return;
   }
 
-  if (gesture_event.GetType() == blink::WebInputEvent::kGestureFlingCancel &&
+  if (gesture_event.GetType() ==
+          blink::WebInputEvent::Type::kGestureFlingCancel &&
       last_fling_start_target_) {
     last_fling_start_target_->ProcessGestureEvent(gesture_event, latency);
     return;
@@ -1511,7 +1519,7 @@ void RenderWidgetHostInputEventRouter::DispatchTouchscreenGestureEvent(
   // We use GestureTapDown to detect the start of a gesture sequence since
   // there is no WebGestureEvent equivalent for ET_GESTURE_BEGIN.
   const bool is_gesture_start =
-      gesture_event.GetType() == blink::WebInputEvent::kGestureTapDown;
+      gesture_event.GetType() == blink::WebInputEvent::Type::kGestureTapDown;
 
   base::Optional<gfx::PointF> fallback_target_location;
 
@@ -1596,18 +1604,21 @@ void RenderWidgetHostInputEventRouter::DispatchTouchscreenGestureEvent(
   }
   touchscreen_gesture_target_->ProcessGestureEvent(event, latency);
 
-  if (gesture_event.GetType() == blink::WebInputEvent::kGestureFlingStart)
+  if (gesture_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart)
     last_fling_start_target_ = touchscreen_gesture_target_;
 
   // If we have one of the following events, then the user has lifted their
   // last finger.
   const bool is_gesture_end =
-      gesture_event.GetType() == blink::WebInputEvent::kGestureTap ||
-      gesture_event.GetType() == blink::WebInputEvent::kGestureLongTap ||
-      gesture_event.GetType() == blink::WebInputEvent::kGestureDoubleTap ||
-      gesture_event.GetType() == blink::WebInputEvent::kGestureTwoFingerTap ||
-      gesture_event.GetType() == blink::WebInputEvent::kGestureScrollEnd ||
-      gesture_event.GetType() == blink::WebInputEvent::kGestureFlingStart;
+      gesture_event.GetType() == blink::WebInputEvent::Type::kGestureTap ||
+      gesture_event.GetType() == blink::WebInputEvent::Type::kGestureLongTap ||
+      gesture_event.GetType() ==
+          blink::WebInputEvent::Type::kGestureDoubleTap ||
+      gesture_event.GetType() ==
+          blink::WebInputEvent::Type::kGestureTwoFingerTap ||
+      gesture_event.GetType() ==
+          blink::WebInputEvent::Type::kGestureScrollEnd ||
+      gesture_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart;
 
   if (is_gesture_end)
     SetTouchscreenGestureTarget(nullptr);
@@ -1625,9 +1636,9 @@ RenderWidgetTargetResult
 RenderWidgetHostInputEventRouter::FindTouchpadGestureEventTarget(
     RenderWidgetHostViewBase* root_view,
     const blink::WebGestureEvent& event) const {
-  if (event.GetType() != blink::WebInputEvent::kGesturePinchBegin &&
-      event.GetType() != blink::WebInputEvent::kGestureFlingCancel &&
-      event.GetType() != blink::WebInputEvent::kGestureDoubleTap) {
+  if (event.GetType() != blink::WebInputEvent::Type::kGesturePinchBegin &&
+      event.GetType() != blink::WebInputEvent::Type::kGestureFlingCancel &&
+      event.GetType() != blink::WebInputEvent::Type::kGestureDoubleTap) {
     return {nullptr, false, base::nullopt, true};
   }
 
@@ -1653,7 +1664,7 @@ void RenderWidgetHostInputEventRouter::DispatchTouchpadGestureEvent(
   // Touchpad gesture flings should be treated as mouse wheels for the purpose
   // of routing.
   if (touchpad_gesture_event.GetType() ==
-      blink::WebInputEvent::kGestureFlingStart) {
+      blink::WebInputEvent::Type::kGestureFlingStart) {
     if (wheel_target_) {
       blink::WebGestureEvent gesture_fling = touchpad_gesture_event;
       gfx::PointF point_in_target =
@@ -1671,7 +1682,7 @@ void RenderWidgetHostInputEventRouter::DispatchTouchpadGestureEvent(
   }
 
   if (touchpad_gesture_event.GetType() ==
-      blink::WebInputEvent::kGestureFlingCancel) {
+      blink::WebInputEvent::Type::kGestureFlingCancel) {
     if (last_fling_start_target_) {
       last_fling_start_target_->ProcessGestureEvent(touchpad_gesture_event,
                                                     latency);
@@ -1712,9 +1723,9 @@ void RenderWidgetHostInputEventRouter::DispatchTouchpadGestureEvent(
   touchpad_gesture_target_->ProcessGestureEvent(gesture_event, latency);
 
   if (touchpad_gesture_event.GetType() ==
-          blink::WebInputEvent::kGesturePinchEnd ||
+          blink::WebInputEvent::Type::kGesturePinchEnd ||
       touchpad_gesture_event.GetType() ==
-          blink::WebInputEvent::kGestureDoubleTap) {
+          blink::WebInputEvent::Type::kGestureDoubleTap) {
     touchpad_gesture_target_ = nullptr;
   }
 }
@@ -1777,7 +1788,7 @@ RenderWidgetHostInputEventRouter::FindTargetSynchronously(
     return FindMouseEventTarget(
         root_view, static_cast<const blink::WebMouseEvent&>(event));
   }
-  if (event.GetType() == blink::WebInputEvent::kMouseWheel) {
+  if (event.GetType() == blink::WebInputEvent::Type::kMouseWheel) {
     return FindMouseWheelEventTarget(
         root_view, static_cast<const blink::WebMouseWheelEvent&>(event));
   }
@@ -1821,7 +1832,7 @@ void RenderWidgetHostInputEventRouter::DispatchEventToTarget(
   if (target && target->ScreenRectIsUnstableFor(*event))
     event->SetTargetFrameMovedRecently();
   if (blink::WebInputEvent::IsMouseEventType(event->GetType())) {
-    if (target && event->GetType() == blink::WebInputEvent::kMouseDown) {
+    if (target && event->GetType() == blink::WebInputEvent::Type::kMouseDown) {
       mouse_down_post_transformed_coordinate_.SetPoint(target_location->x(),
                                                        target_location->y());
       last_mouse_down_target_ = target;
@@ -1831,7 +1842,7 @@ void RenderWidgetHostInputEventRouter::DispatchEventToTarget(
                        target_location);
     return;
   }
-  if (event->GetType() == blink::WebInputEvent::kMouseWheel) {
+  if (event->GetType() == blink::WebInputEvent::Type::kMouseWheel) {
     DispatchMouseWheelEvent(root_view, target,
                             *static_cast<blink::WebMouseWheelEvent*>(event),
                             latency, target_location);
@@ -1903,7 +1914,7 @@ void RenderWidgetHostInputEventRouter::ForwardEmulatedTouchEvent(
   last_emulated_event_root_view_ =
       last_mouse_move_root_view_ ? last_mouse_move_root_view_ : target;
 
-  if (event.GetType() == blink::WebInputEvent::kTouchStart)
+  if (event.GetType() == blink::WebInputEvent::Type::kTouchStart)
     active_touches_ += CountChangedTouchPoints(event);
   gfx::PointF transformed_point = target->TransformRootPointToViewCoordSpace(
       event.touches[0].PositionInWidget());

content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc

@@ -93,11 +93,11 @@ class TestRenderWidgetHostViewChildFrame
   blink::WebInputEvent::Type last_gesture_seen() { return last_gesture_seen_; }
   uint32_t last_id_for_touch_ack() { return unique_id_for_last_touch_ack_; }
 
-  void Reset() { last_gesture_seen_ = blink::WebInputEvent::kUndefined; }
+  void Reset() { last_gesture_seen_ = blink::WebInputEvent::Type::kUndefined; }
 
  private:
   blink::WebInputEvent::Type last_gesture_seen_ =
-      blink::WebInputEvent::kUndefined;
+      blink::WebInputEvent::Type::kUndefined;
   uint32_t unique_id_for_last_touch_ack_ = 0;
 };
 
@@ -171,11 +171,11 @@ class MockRootRenderWidgetHostView : public TestRenderWidgetHostView {
         .SetDisplayHitTestQuery(std::move(hit_test_map));
   }
 
-  void Reset() { last_gesture_seen_ = blink::WebInputEvent::kUndefined; }
+  void Reset() { last_gesture_seen_ = blink::WebInputEvent::Type::kUndefined; }
 
  private:
   blink::WebInputEvent::Type last_gesture_seen_ =
-      blink::WebInputEvent::kUndefined;
+      blink::WebInputEvent::Type::kUndefined;
   uint32_t unique_id_for_last_touch_ack_ = 0;
 };
 
@@ -313,7 +313,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   view_root_->SetHittestResult(child.view.get(), false);
 
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -324,7 +325,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   EXPECT_EQ(child.view.get(), touch_target());
 
   blink::WebGestureEvent gesture_event(
-      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kGestureTapDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
@@ -332,27 +334,27 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
   EXPECT_EQ(child.view.get(), touchscreen_gesture_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureTapDown,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureTapDown,
             child.view->last_gesture_seen());
-  EXPECT_NE(blink::WebInputEvent::kGestureTapDown,
+  EXPECT_NE(blink::WebInputEvent::Type::kGestureTapDown,
             view_root_->last_gesture_seen());
 
-  touch_event.SetType(blink::WebInputEvent::kTouchMove);
+  touch_event.SetType(blink::WebInputEvent::Type::kTouchMove);
   touch_event.touches[0].state = blink::WebTouchPoint::kStateMoved;
   touch_event.unique_touch_event_id += 1;
   rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
                             ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureTapCancel);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureTapCancel);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollBegin);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollBegin);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollUpdate);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
@@ -381,25 +383,25 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
 
   EXPECT_EQ(child.view.get(), touch_target());
   EXPECT_EQ(child.view.get(), touchscreen_gesture_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
             child.view->last_gesture_seen());
-  EXPECT_NE(blink::WebInputEvent::kGestureScrollUpdate,
+  EXPECT_NE(blink::WebInputEvent::Type::kGestureScrollUpdate,
             view_root_->last_gesture_seen());
 
-  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
+  touch_event.SetType(blink::WebInputEvent::Type::kTouchEnd);
   touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
   touch_event.unique_touch_event_id += 1;
   rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
                             ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollEnd);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollEnd);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
             child.view->last_gesture_seen());
-  EXPECT_NE(blink::WebInputEvent::kGestureScrollEnd,
+  EXPECT_NE(blink::WebInputEvent::Type::kGestureScrollEnd,
             view_root_->last_gesture_seen());
 }
 
@@ -418,7 +420,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
 
   // Send a TouchStart/End sequence.
   blink::WebTouchEvent touch_start_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_start_event.touches_length = 1;
   touch_start_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -428,7 +431,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
                             ui::LatencyInfo(ui::SourceEventType::TOUCH));
 
   blink::WebTouchEvent touch_end_event(
-      blink::WebInputEvent::kTouchEnd, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchEnd, blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_end_event.touches_length = 1;
   touch_end_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
@@ -453,7 +456,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
 TEST_F(RenderWidgetHostInputEventRouterTest, EnsureDroppedTouchEventsAreAcked) {
   // Send a touch move without a touch start.
   blink::WebTouchEvent touch_move_event(
-      blink::WebInputEvent::kTouchMove, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchMove,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_move_event.touches_length = 1;
   touch_move_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -465,7 +469,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest, EnsureDroppedTouchEventsAreAcked) {
 
   // Send a touch cancel without a touch start.
   blink::WebTouchEvent touch_cancel_event(
-      blink::WebInputEvent::kTouchCancel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchCancel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_cancel_event.touches_length = 1;
   touch_cancel_event.touches[0].state = blink::WebTouchPoint::kStateCancelled;
@@ -487,7 +492,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceTouchEvents) {
   // Send TouchStart, TouchMove, TouchMove, TouchMove, TouchEnd and make sure
   // the targeter doesn't attempt to coalesce.
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -500,7 +506,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceTouchEvents) {
   EXPECT_EQ(0u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  touch_event.SetType(blink::WebInputEvent::kTouchMove);
+  touch_event.SetType(blink::WebInputEvent::Type::kTouchMove);
   touch_event.touches[0].state = blink::WebTouchPoint::kStateMoved;
   touch_event.unique_touch_event_id += 1;
   rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
@@ -514,7 +520,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceTouchEvents) {
   EXPECT_EQ(2u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
+  touch_event.SetType(blink::WebInputEvent::Type::kTouchEnd);
   touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
   touch_event.unique_touch_event_id += 1;
   rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
@@ -536,7 +542,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceGestureEvents) {
   // GestureScrollUpdate (x2), GestureScrollEnd and make sure
   // the targeter doesn't attempt to coalesce.
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -550,7 +557,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceGestureEvents) {
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
   blink::WebGestureEvent gesture_event(
-      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kGestureTapDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
@@ -559,7 +567,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceGestureEvents) {
   EXPECT_EQ(1u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  touch_event.SetType(blink::WebInputEvent::kTouchEnd);
+  touch_event.SetType(blink::WebInputEvent::Type::kTouchEnd);
   touch_event.touches[0].state = blink::WebTouchPoint::kStateReleased;
   touch_event.unique_touch_event_id += 1;
   rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
@@ -567,25 +575,25 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotCoalesceGestureEvents) {
   EXPECT_EQ(2u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollBegin);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollBegin);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
   EXPECT_EQ(3u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollUpdate);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
   EXPECT_EQ(4u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollUpdate);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollUpdate);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
   EXPECT_EQ(5u, targeter->num_requests_in_queue_for_testing());
   EXPECT_TRUE(targeter->is_request_in_flight_for_testing());
 
-  gesture_event.SetType(blink::WebInputEvent::kGestureScrollEnd);
+  gesture_event.SetType(blink::WebInputEvent::Type::kGestureScrollEnd);
   rwhier()->RouteGestureEvent(view_root_.get(), &gesture_event,
                               ui::LatencyInfo(ui::SourceEventType::TOUCH));
   EXPECT_EQ(6u, targeter->num_requests_in_queue_for_testing());
@@ -608,13 +616,13 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
                                             scroll_begin));
     EXPECT_EQ(child.view.get(), bubbling_gesture_scroll_origin());
     EXPECT_EQ(view_root_.get(), bubbling_gesture_scroll_target());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
               view_root_->last_gesture_seen());
 
     rwhier()->WillDetachChildView(child.view.get());
     EXPECT_EQ(nullptr, bubbling_gesture_scroll_origin());
     EXPECT_EQ(nullptr, bubbling_gesture_scroll_target());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
               view_root_->last_gesture_seen());
   }
 
@@ -626,21 +634,21 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
                                             scroll_begin));
     EXPECT_EQ(inner.view.get(), bubbling_gesture_scroll_origin());
     EXPECT_EQ(outer.view.get(), bubbling_gesture_scroll_target());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
               outer.view->last_gesture_seen());
     ASSERT_TRUE(rwhier()->BubbleScrollEvent(view_root_.get(), outer.view.get(),
                                             scroll_begin));
     EXPECT_EQ(inner.view.get(), bubbling_gesture_scroll_origin());
     EXPECT_EQ(view_root_.get(), bubbling_gesture_scroll_target());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
               outer.view->last_gesture_seen());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
               view_root_->last_gesture_seen());
 
     rwhier()->WillDetachChildView(outer.view.get());
     EXPECT_EQ(nullptr, bubbling_gesture_scroll_origin());
     EXPECT_EQ(nullptr, bubbling_gesture_scroll_target());
-    EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+    EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
               view_root_->last_gesture_seen());
   }
 }
@@ -661,13 +669,13 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
                                           scroll_begin));
   EXPECT_EQ(outer.view.get(), bubbling_gesture_scroll_origin());
   EXPECT_EQ(view_root_.get(), bubbling_gesture_scroll_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             view_root_->last_gesture_seen());
 
   rwhier()->WillDetachChildView(inner.view.get());
   EXPECT_EQ(outer.view.get(), bubbling_gesture_scroll_origin());
   EXPECT_EQ(view_root_.get(), bubbling_gesture_scroll_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             view_root_->last_gesture_seen());
 }
 
@@ -687,21 +695,21 @@ void RenderWidgetHostInputEventRouterTest::TestSendNewGestureWhileBubbling(
     EXPECT_EQ(bubbling_origin, bubbling_gesture_scroll_origin());
     EXPECT_EQ(parent, bubbling_gesture_scroll_target());
     if (cur_target != bubbling_origin) {
-      EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+      EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
                 cur_target->last_gesture_seen());
     }
 
     if (parent->IsRenderWidgetHostViewChildFrame()) {
       TestRenderWidgetHostViewChildFrame* next_child =
           static_cast<TestRenderWidgetHostViewChildFrame*>(parent);
-      EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+      EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
                 next_child->last_gesture_seen());
       cur_target = next_child;
       parent = next_child->GetParentView();
     } else {
       MockRootRenderWidgetHostView* root =
           static_cast<MockRootRenderWidgetHostView*>(parent);
-      EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+      EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
                 root->last_gesture_seen());
       parent = nullptr;
     }
@@ -712,7 +720,8 @@ void RenderWidgetHostInputEventRouterTest::TestSendNewGestureWhileBubbling(
   view_root_->SetHittestResult(gesture_target, false);
 
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -723,7 +732,8 @@ void RenderWidgetHostInputEventRouterTest::TestSendNewGestureWhileBubbling(
   EXPECT_EQ(gesture_target, touch_target());
 
   blink::WebGestureEvent gesture_event(
-      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kGestureTapDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
@@ -798,7 +808,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest, DoNotBubbleMultipleSequences) {
                                           scroll_begin));
   EXPECT_EQ(inner1.view.get(), bubbling_gesture_scroll_origin());
   EXPECT_EQ(outer1.view.get(), bubbling_gesture_scroll_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             outer1.view->last_gesture_seen());
 
   EXPECT_FALSE(rwhier()->BubbleScrollEvent(outer2.view.get(), inner2.view.get(),
@@ -822,7 +832,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   view_root_->SetHittestResult(view_root_.get(), false);
 
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -833,7 +844,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   EXPECT_EQ(view_root_.get(), touch_target());
 
   blink::WebGestureEvent gesture_event(
-      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kGestureTapDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
@@ -867,7 +879,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   view_root_->SetHittestResult(view_root_.get(), false);
 
   blink::WebTouchEvent touch_event(
-      blink::WebInputEvent::kTouchStart, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kTouchStart,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   touch_event.touches_length = 1;
   touch_event.touches[0].state = blink::WebTouchPoint::kStatePressed;
@@ -878,7 +891,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
   EXPECT_EQ(view_root_.get(), touch_target());
 
   blink::WebGestureEvent gesture_event(
-      blink::WebInputEvent::kGestureTapDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kGestureTapDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
   gesture_event.unique_touch_event_id = touch_event.unique_touch_event_id;
@@ -897,7 +911,7 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
                                           scroll_begin));
   EXPECT_EQ(inner.view.get(), bubbling_gesture_scroll_origin());
   EXPECT_EQ(outer.view.get(), bubbling_gesture_scroll_target());
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             outer.view->last_gesture_seen());
 
   // We cannot bubble any further, as that would interfere with the gesture in
@@ -924,7 +938,8 @@ TEST_F(RenderWidgetHostInputEventRouterTest,
 
   // Simulate middle click mouse event.
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.button = blink::WebPointerProperties::Button::kMiddle;
 

content/browser/renderer_host/render_widget_host_unittest.cc

@@ -123,7 +123,7 @@ class TestView : public TestRenderWidgetHostView {
       : TestRenderWidgetHostView(rwh),
         unhandled_wheel_event_count_(0),
         acked_event_count_(0),
-        gesture_event_type_(-1),
+        gesture_event_type_(WebInputEvent::Type::kUndefined),
         use_fake_compositor_viewport_pixel_size_(false),
         ack_result_(blink::mojom::InputEventResultState::kUnknown) {
     local_surface_id_allocator_.GenerateId();
@@ -153,7 +153,7 @@ class TestView : public TestRenderWidgetHostView {
   const WebTouchEvent& acked_event() const { return acked_event_; }
   int acked_event_count() const { return acked_event_count_; }
   void ClearAckedEvent() {
-    acked_event_.SetType(blink::WebInputEvent::kUndefined);
+    acked_event_.SetType(blink::WebInputEvent::Type::kUndefined);
     acked_event_count_ = 0;
   }
 
@@ -221,7 +221,7 @@ class TestView : public TestRenderWidgetHostView {
   int unhandled_wheel_event_count_;
   WebTouchEvent acked_event_;
   int acked_event_count_;
-  int gesture_event_type_;
+  WebInputEvent::Type gesture_event_type_;
   gfx::Rect bounds_;
   bool use_fake_compositor_viewport_pixel_size_;
   gfx::Size mock_compositor_viewport_pixel_size_;
@@ -310,9 +310,9 @@ class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
       : prehandle_keyboard_event_(false),
         prehandle_keyboard_event_is_shortcut_(false),
         prehandle_keyboard_event_called_(false),
-        prehandle_keyboard_event_type_(WebInputEvent::kUndefined),
+        prehandle_keyboard_event_type_(WebInputEvent::Type::kUndefined),
         unhandled_keyboard_event_called_(false),
-        unhandled_keyboard_event_type_(WebInputEvent::kUndefined),
+        unhandled_keyboard_event_type_(WebInputEvent::Type::kUndefined),
         handle_wheel_event_(false),
         handle_wheel_event_called_(false),
         unresponsive_timer_fired_(false),
@@ -657,7 +657,7 @@ class RenderWidgetHostTest : public testing::Test {
   }
 
   void SimulateMouseMove(int x, int y, int modifiers) {
-    SimulateMouseEvent(WebInputEvent::kMouseMove, x, y, modifiers, false);
+    SimulateMouseEvent(WebInputEvent::Type::kMouseMove, x, y, modifiers, false);
   }
 
   void SimulateMouseEvent(
@@ -1097,7 +1097,7 @@ TEST_F(RenderWidgetHostTest, HideShowMessages) {
 
 TEST_F(RenderWidgetHostTest, IgnoreKeyEventsHandledByRenderer) {
   // Simulate a keyboard event.
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
 
   // Make sure we sent the input event to the renderer.
   MockWidgetInputHandler::MessageVector dispatched_events =
@@ -1113,7 +1113,7 @@ TEST_F(RenderWidgetHostTest, IgnoreKeyEventsHandledByRenderer) {
 
 TEST_F(RenderWidgetHostTest, SendEditCommandsBeforeKeyEvent) {
   // Simulate a keyboard event.
-  SimulateKeyboardEventWithCommands(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEventWithCommands(WebInputEvent::Type::kRawKeyDown);
 
   // Make sure we sent commands and key event to the renderer.
   MockWidgetInputHandler::MessageVector dispatched_events =
@@ -1133,10 +1133,10 @@ TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
   delegate_->set_prehandle_keyboard_event(true);
 
   // Simulate a keyboard event.
-  SimulateKeyboardEventWithCommands(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEventWithCommands(WebInputEvent::Type::kRawKeyDown);
 
   EXPECT_TRUE(delegate_->prehandle_keyboard_event_called());
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             delegate_->prehandle_keyboard_event_type());
 
   // Make sure the commands and key event are not sent to the renderer.
@@ -1148,7 +1148,7 @@ TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
   delegate_->set_prehandle_keyboard_event(false);
 
   // Forward the Char event.
-  SimulateKeyboardEvent(WebInputEvent::kChar);
+  SimulateKeyboardEvent(WebInputEvent::Type::kChar);
 
   // Make sure the Char event is suppressed.
   dispatched_events =
@@ -1156,7 +1156,7 @@ TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
   EXPECT_EQ(0u, dispatched_events.size());
 
   // Forward the KeyUp event.
-  SimulateKeyboardEvent(WebInputEvent::kKeyUp);
+  SimulateKeyboardEvent(WebInputEvent::Type::kKeyUp);
 
   // Make sure the KeyUp event is suppressed.
   dispatched_events =
@@ -1164,12 +1164,12 @@ TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
   EXPECT_EQ(0u, dispatched_events.size());
 
   // Simulate a new RawKeyDown event.
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
@@ -1177,7 +1177,7 @@ TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
       blink::mojom::InputEventResultState::kNotConsumed);
 
   EXPECT_TRUE(delegate_->unhandled_keyboard_event_called());
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             delegate_->unhandled_keyboard_event_type());
 }
 
@@ -1187,10 +1187,10 @@ TEST_F(RenderWidgetHostTest, RawKeyDownShortcutEvent) {
   delegate_->set_prehandle_keyboard_event_is_shortcut(true);
 
   // Simulate a keyboard event.
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
 
   EXPECT_TRUE(delegate_->prehandle_keyboard_event_called());
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             delegate_->prehandle_keyboard_event_type());
 
   // Make sure the RawKeyDown event is sent to the renderer.
@@ -1198,20 +1198,20 @@ TEST_F(RenderWidgetHostTest, RawKeyDownShortcutEvent) {
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
   dispatched_events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kNotConsumed);
-  EXPECT_EQ(WebInputEvent::kRawKeyDown,
+  EXPECT_EQ(WebInputEvent::Type::kRawKeyDown,
             delegate_->unhandled_keyboard_event_type());
 
   // The browser won't pre-handle a Char event.
   delegate_->set_prehandle_keyboard_event_is_shortcut(false);
 
   // Forward the Char event.
-  SimulateKeyboardEvent(WebInputEvent::kChar);
+  SimulateKeyboardEvent(WebInputEvent::Type::kChar);
 
   // The Char event is not suppressed; the renderer will ignore it
   // if the preceding RawKeyDown shortcut goes unhandled.
@@ -1219,29 +1219,31 @@ TEST_F(RenderWidgetHostTest, RawKeyDownShortcutEvent) {
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kChar,
+  EXPECT_EQ(WebInputEvent::Type::kChar,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
   dispatched_events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kNotConsumed);
-  EXPECT_EQ(WebInputEvent::kChar, delegate_->unhandled_keyboard_event_type());
+  EXPECT_EQ(WebInputEvent::Type::kChar,
+            delegate_->unhandled_keyboard_event_type());
 
   // Forward the KeyUp event.
-  SimulateKeyboardEvent(WebInputEvent::kKeyUp);
+  SimulateKeyboardEvent(WebInputEvent::Type::kKeyUp);
 
   // Make sure only KeyUp was sent to the renderer.
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kKeyUp,
+  EXPECT_EQ(WebInputEvent::Type::kKeyUp,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
   dispatched_events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kNotConsumed);
-  EXPECT_EQ(WebInputEvent::kKeyUp, delegate_->unhandled_keyboard_event_type());
+  EXPECT_EQ(WebInputEvent::Type::kKeyUp,
+            delegate_->unhandled_keyboard_event_type());
 }
 
 TEST_F(RenderWidgetHostTest, UnhandledWheelEvent) {
@@ -1251,7 +1253,7 @@ TEST_F(RenderWidgetHostTest, UnhandledWheelEvent) {
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kMouseWheel,
+  EXPECT_EQ(WebInputEvent::Type::kMouseWheel,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
@@ -1273,7 +1275,7 @@ TEST_F(RenderWidgetHostTest, HandleWheelEvent) {
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kMouseWheel,
+  EXPECT_EQ(WebInputEvent::Type::kMouseWheel,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
@@ -1288,7 +1290,7 @@ TEST_F(RenderWidgetHostTest, HandleWheelEvent) {
 }
 
 TEST_F(RenderWidgetHostTest, EventsCausingFocus) {
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
   EXPECT_EQ(1, delegate_->GetFocusOwningWebContentsCallCount());
 
   PressTouchPoint(0, 1);
@@ -1299,31 +1301,32 @@ TEST_F(RenderWidgetHostTest, EventsCausingFocus) {
   SendTouchEvent();
   EXPECT_EQ(2, delegate_->GetFocusOwningWebContentsCallCount());
 
-  SimulateGestureEvent(WebInputEvent::kGestureTapDown,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureTapDown,
                        blink::WebGestureDevice::kTouchscreen);
   EXPECT_EQ(2, delegate_->GetFocusOwningWebContentsCallCount());
 
-  SimulateGestureEvent(WebInputEvent::kGestureTap,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureTap,
                        blink::WebGestureDevice::kTouchscreen);
   EXPECT_EQ(3, delegate_->GetFocusOwningWebContentsCallCount());
 }
 
 TEST_F(RenderWidgetHostTest, UnhandledGestureEvent) {
-  SimulateGestureEvent(WebInputEvent::kGestureTwoFingerTap,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureTwoFingerTap,
                        blink::WebGestureDevice::kTouchscreen);
 
   MockWidgetInputHandler::MessageVector dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   ASSERT_EQ(1u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kGestureTwoFingerTap,
+  EXPECT_EQ(WebInputEvent::Type::kGestureTwoFingerTap,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
   // Send the simulated response from the renderer back.
   dispatched_events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kNotConsumed);
 
-  EXPECT_EQ(WebInputEvent::kGestureTwoFingerTap, view_->gesture_event_type());
+  EXPECT_EQ(WebInputEvent::Type::kGestureTwoFingerTap,
+            view_->gesture_event_type());
   EXPECT_EQ(blink::mojom::InputEventResultState::kNotConsumed,
             view_->ack_result());
 }
@@ -1368,7 +1371,7 @@ TEST_F(RenderWidgetHostTest, StopAndStartInputEventAckTimeout) {
 // Test that the hang monitor timer is effectively disabled when the widget is
 // hidden.
 TEST_F(RenderWidgetHostTest, InputEventAckTimeoutDisabledForInputWhenHidden) {
-  SimulateMouseEvent(WebInputEvent::kMouseMove, 10, 10, 0, false);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseMove, 10, 10, 0, false);
 
   // Hiding the widget should deactivate the timeout.
   host_->WasHidden();
@@ -1380,7 +1383,7 @@ TEST_F(RenderWidgetHostTest, InputEventAckTimeoutDisabledForInputWhenHidden) {
   EXPECT_FALSE(delegate_->unresponsive_timer_fired());
 
   // The timeout should never reactivate while hidden.
-  SimulateMouseEvent(WebInputEvent::kMouseMove, 10, 10, 0, false);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseMove, 10, 10, 0, false);
   task_environment_.FastForwardBy(
       base::TimeDelta::FromMilliseconds(kHungRendererDelayMs + 10));
   EXPECT_FALSE(delegate_->unresponsive_timer_fired());
@@ -1398,10 +1401,10 @@ TEST_F(RenderWidgetHostTest, InputEventAckTimeoutDisabledForInputWhenHidden) {
 // This test will catch a regression of crbug.com/111185.
 TEST_F(RenderWidgetHostTest, MultipleInputEvents) {
   // Send two events but only one ack.
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   task_environment_.FastForwardBy(
       base::TimeDelta::FromMilliseconds(kHungRendererDelayMs / 2));
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
 
   MockWidgetInputHandler::MessageVector dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
@@ -1423,16 +1426,16 @@ TEST_F(RenderWidgetHostTest, IgnoreInputEvent) {
 
   delegate_->SetIgnoreInputEvents(true);
 
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   EXPECT_FALSE(host_->mock_input_router()->sent_keyboard_event_);
 
-  SimulateMouseEvent(WebInputEvent::kMouseMove);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseMove);
   EXPECT_FALSE(host_->mock_input_router()->sent_mouse_event_);
 
   SimulateWheelEvent(0, 100, 0, true);
   EXPECT_FALSE(host_->mock_input_router()->sent_wheel_event_);
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchpad);
   EXPECT_FALSE(host_->mock_input_router()->sent_gesture_event_);
 
@@ -1446,7 +1449,7 @@ TEST_F(RenderWidgetHostTest, KeyboardListenerIgnoresEvent) {
   host_->AddKeyPressEventCallback(base::BindRepeating(
       &RenderWidgetHostTest::KeyPressEventCallback, base::Unretained(this)));
   handle_key_press_event_ = false;
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
 
   EXPECT_TRUE(host_->mock_input_router()->sent_keyboard_event_);
 }
@@ -1459,23 +1462,23 @@ TEST_F(RenderWidgetHostTest, KeyboardListenerSuppressFollowingEvents) {
 
   // The callback handles the first event
   handle_key_press_event_ = true;
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
 
   EXPECT_FALSE(host_->mock_input_router()->sent_keyboard_event_);
 
   // Following Char events should be suppressed
   handle_key_press_event_ = false;
-  SimulateKeyboardEvent(WebInputEvent::kChar);
+  SimulateKeyboardEvent(WebInputEvent::Type::kChar);
   EXPECT_FALSE(host_->mock_input_router()->sent_keyboard_event_);
-  SimulateKeyboardEvent(WebInputEvent::kChar);
+  SimulateKeyboardEvent(WebInputEvent::Type::kChar);
   EXPECT_FALSE(host_->mock_input_router()->sent_keyboard_event_);
 
   // Sending RawKeyDown event should stop suppression
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   EXPECT_TRUE(host_->mock_input_router()->sent_keyboard_event_);
 
   host_->mock_input_router()->sent_keyboard_event_ = false;
-  SimulateKeyboardEvent(WebInputEvent::kChar);
+  SimulateKeyboardEvent(WebInputEvent::Type::kChar);
   EXPECT_TRUE(host_->mock_input_router()->sent_keyboard_event_);
 }
 
@@ -1486,12 +1489,12 @@ TEST_F(RenderWidgetHostTest, MouseEventCallbackCanHandleEvent) {
       &RenderWidgetHostTest::MouseEventCallback, base::Unretained(this)));
 
   handle_mouse_event_ = true;
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
 
   EXPECT_FALSE(host_->mock_input_router()->sent_mouse_event_);
 
   handle_mouse_event_ = false;
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
 
   EXPECT_TRUE(host_->mock_input_router()->sent_mouse_event_);
 }
@@ -1525,10 +1528,10 @@ void CheckLatencyInfoComponentInGestureScrollUpdate(
   ASSERT_EQ(2u, dispatched_events.size());
   ASSERT_TRUE(dispatched_events[0]->ToEvent());
   ASSERT_TRUE(dispatched_events[1]->ToEvent());
-  EXPECT_EQ(WebInputEvent::kTouchScrollStarted,
+  EXPECT_EQ(WebInputEvent::Type::kTouchScrollStarted,
             dispatched_events[0]->ToEvent()->Event()->web_event->GetType());
 
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate,
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
             dispatched_events[1]->ToEvent()->Event()->web_event->GetType());
   EXPECT_TRUE(
       dispatched_events[1]->ToEvent()->Event()->latency_info.FindLatency(
@@ -1549,7 +1552,7 @@ TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
   MockWidgetInputHandler::MessageVector dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kMouseWheel);
+                                     WebInputEvent::Type::kMouseWheel);
 
   // Tests RWHI::ForwardWheelEventWithLatencyInfo().
   SimulateWheelEventWithLatencyInfo(-5, 0, 0, true, ui::LatencyInfo(),
@@ -1557,22 +1560,22 @@ TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kMouseWheel);
+                                     WebInputEvent::Type::kMouseWheel);
 
   // Tests RWHI::ForwardMouseEvent().
-  SimulateMouseEvent(WebInputEvent::kMouseMove);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseMove);
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kMouseMove);
+                                     WebInputEvent::Type::kMouseMove);
 
   // Tests RWHI::ForwardMouseEventWithLatencyInfo().
-  SimulateMouseEventWithLatencyInfo(WebInputEvent::kMouseMove,
+  SimulateMouseEventWithLatencyInfo(WebInputEvent::Type::kMouseMove,
                                     ui::LatencyInfo());
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kMouseMove);
+                                     WebInputEvent::Type::kMouseMove);
 
   // Tests RWHI::ForwardGestureEvent().
   PressTouchPoint(0, 1);
@@ -1581,17 +1584,17 @@ TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kTouchStart);
+                                     WebInputEvent::Type::kTouchStart);
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kGestureScrollBegin);
+                                     WebInputEvent::Type::kGestureScrollBegin);
 
   // Tests RWHI::ForwardGestureEventWithLatencyInfo().
-  SimulateGestureEventWithLatencyInfo(WebInputEvent::kGestureScrollUpdate,
+  SimulateGestureEventWithLatencyInfo(WebInputEvent::Type::kGestureScrollUpdate,
                                       blink::WebGestureDevice::kTouchscreen,
                                       ui::LatencyInfo());
   dispatched_events =
@@ -1609,12 +1612,12 @@ TEST_F(RenderWidgetHostTest, InputEventRWHLatencyComponent) {
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
   CheckLatencyInfoComponentInMessage(dispatched_events,
-                                     WebInputEvent::kTouchStart);
+                                     WebInputEvent::Type::kTouchStart);
 }
 
 TEST_F(RenderWidgetHostTest, RendererExitedResetsInputRouter) {
   EXPECT_EQ(0u, host_->in_flight_event_count());
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   EXPECT_EQ(1u, host_->in_flight_event_count());
 
   EXPECT_FALSE(host_->input_router()->HasPendingEvents());
@@ -1643,7 +1646,7 @@ TEST_F(RenderWidgetHostTest, RendererExitedResetsInputRouter) {
 
 TEST_F(RenderWidgetHostTest, DestroyingRenderWidgetResetsInputRouter) {
   EXPECT_EQ(0u, host_->in_flight_event_count());
-  SimulateKeyboardEvent(WebInputEvent::kRawKeyDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kRawKeyDown);
   EXPECT_EQ(1u, host_->in_flight_event_count());
 
   EXPECT_FALSE(host_->input_router()->HasPendingEvents());
@@ -1855,7 +1858,7 @@ TEST_F(RenderWidgetHostTest, EventDispatchPostDetach) {
   host_->DetachDelegate();
 
   // Tests RWHI::ForwardGestureEventWithLatencyInfo().
-  SimulateGestureEventWithLatencyInfo(WebInputEvent::kGestureScrollUpdate,
+  SimulateGestureEventWithLatencyInfo(WebInputEvent::Type::kGestureScrollUpdate,
                                       blink::WebGestureDevice::kTouchscreen,
                                       ui::LatencyInfo());
 
@@ -2071,25 +2074,25 @@ TEST_F(RenderWidgetHostTest, PendingUserActivationTimeout) {
       {});
 
   // One event allows one activation notification.
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
   EXPECT_TRUE(host_->RemovePendingUserActivationIfAvailable());
   EXPECT_FALSE(host_->RemovePendingUserActivationIfAvailable());
 
   // Mouse move and up does not increase pending user activation counter.
-  SimulateMouseEvent(WebInputEvent::kMouseMove);
-  SimulateMouseEvent(WebInputEvent::kMouseUp);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseMove);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseUp);
   EXPECT_FALSE(host_->RemovePendingUserActivationIfAvailable());
 
   // 2 events allow 2 activation notifications.
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
-  SimulateKeyboardEvent(WebInputEvent::kKeyDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
+  SimulateKeyboardEvent(WebInputEvent::Type::kKeyDown);
   EXPECT_TRUE(host_->RemovePendingUserActivationIfAvailable());
   EXPECT_TRUE(host_->RemovePendingUserActivationIfAvailable());
   EXPECT_FALSE(host_->RemovePendingUserActivationIfAvailable());
 
   // Timer reset the pending activation.
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
-  SimulateMouseEvent(WebInputEvent::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
+  SimulateMouseEvent(WebInputEvent::Type::kMouseDown);
   task_environment_.FastForwardBy(
       RenderWidgetHostImpl::kActivationNotificationExpireTime);
   EXPECT_FALSE(host_->RemovePendingUserActivationIfAvailable());
@@ -2108,7 +2111,7 @@ TEST_F(RenderWidgetHostTest, NoFlingEventsWhenLastScrollEventConsumed) {
 
   // A GestureFlingStart event following a consumed scroll event should not be
   // dispatched.
-  SimulateGestureEvent(blink::WebInputEvent::kGestureFlingStart,
+  SimulateGestureEvent(blink::WebInputEvent::Type::kGestureFlingStart,
                        blink::WebGestureDevice::kTouchpad);
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();
@@ -2137,7 +2140,7 @@ TEST_F(RenderWidgetHostTest, FlingEventsWhenSomeScrollEventsConsumed) {
       blink::mojom::InputEventResultState::kNotConsumed);
 
   // A GestureFlingStart event following the scroll events should be dispatched.
-  SimulateGestureEvent(blink::WebInputEvent::kGestureFlingStart,
+  SimulateGestureEvent(blink::WebInputEvent::Type::kGestureFlingStart,
                        blink::WebGestureDevice::kTouchpad);
   dispatched_events =
       host_->mock_widget_input_handler_.GetAndResetDispatchedMessages();

content/browser/renderer_host/render_widget_host_view_android.cc

@@ -859,7 +859,7 @@ bool RenderWidgetHostViewAndroid::OnTouchEvent(
   blink::WebTouchEvent web_event = ui::CreateWebTouchEventFromMotionEvent(
       event, result.moved_beyond_slop_region /* may_cause_scrolling */,
       false /* hovering */);
-  if (web_event.GetType() == blink::WebInputEvent::kUndefined)
+  if (web_event.GetType() == blink::WebInputEvent::Type::kUndefined)
     return false;
 
   ui::LatencyInfo latency_info(ui::SourceEventType::TOUCH);
@@ -1602,7 +1602,7 @@ RenderWidgetHostViewAndroid::FilterInputEvent(
       // overscrolling mode is not |OVERSCROLL_NONE|. The early fling
       // termination generates a GSE which completes the overscroll action.
       if (gesture_event.GetType() ==
-              blink::WebInputEvent::kGestureScrollUpdate &&
+              blink::WebInputEvent::Type::kGestureScrollUpdate &&
           gesture_event.data.scroll_update.inertial_phase ==
               blink::WebGestureEvent::InertialPhaseState::kMomentum) {
         host_->StopFling();
@@ -1620,8 +1620,8 @@ RenderWidgetHostViewAndroid::FilterInputEvent(
   if (!host())
     return blink::mojom::InputEventResultState::kNotConsumed;
 
-  if (input_event.GetType() == blink::WebInputEvent::kGestureTapDown ||
-      input_event.GetType() == blink::WebInputEvent::kTouchStart) {
+  if (input_event.GetType() == blink::WebInputEvent::Type::kGestureTapDown ||
+      input_event.GetType() == blink::WebInputEvent::Type::kTouchStart) {
     GpuProcessHost::CallOnIO(GPU_PROCESS_KIND_SANDBOXED,
                              false /* force_create */,
                              base::BindOnce(&WakeUpGpu));
@@ -1679,8 +1679,8 @@ void RenderWidgetHostViewAndroid::SendKeyEvent(
     text_suggestion_host_->OnKeyEvent();
 
   ui::LatencyInfo latency_info;
-  if (event.GetType() == blink::WebInputEvent::kRawKeyDown ||
-      event.GetType() == blink::WebInputEvent::kChar) {
+  if (event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
+      event.GetType() == blink::WebInputEvent::Type::kChar) {
     latency_info.set_source_event_type(ui::SourceEventType::KEY_PRESS);
   }
   latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT);
@@ -1693,16 +1693,16 @@ void RenderWidgetHostViewAndroid::SendMouseEvent(
   blink::WebInputEvent::Type webMouseEventType =
       ui::ToWebMouseEventType(motion_event.GetAction());
 
-  if (webMouseEventType == blink::WebInputEvent::kUndefined)
+  if (webMouseEventType == blink::WebInputEvent::Type::kUndefined)
     return;
 
-  if (webMouseEventType == blink::WebInputEvent::kMouseDown)
+  if (webMouseEventType == blink::WebInputEvent::Type::kMouseDown)
     UpdateMouseState(action_button, motion_event.GetX(0), motion_event.GetY(0));
 
   int click_count = 0;
 
-  if (webMouseEventType == blink::WebInputEvent::kMouseDown ||
-      webMouseEventType == blink::WebInputEvent::kMouseUp)
+  if (webMouseEventType == blink::WebInputEvent::Type::kMouseDown ||
+      webMouseEventType == blink::WebInputEvent::Type::kMouseUp)
     click_count = (action_button == ui::MotionEventAndroid::BUTTON_PRIMARY)
                       ? left_click_count_
                       : 1;
@@ -1772,7 +1772,7 @@ void RenderWidgetHostViewAndroid::SendGestureEvent(
     overscroll_controller_->Enable();
 
   if (!host() || !host()->delegate() ||
-      event.GetType() == blink::WebInputEvent::kUndefined) {
+      event.GetType() == blink::WebInputEvent::Type::kUndefined) {
     return;
   }
 
@@ -1781,17 +1781,17 @@ void RenderWidgetHostViewAndroid::SendGestureEvent(
   if (touch_selection_controller_ &&
       event.SourceDevice() == blink::WebGestureDevice::kTouchscreen) {
     switch (event.GetType()) {
-      case blink::WebInputEvent::kGestureLongPress:
+      case blink::WebInputEvent::Type::kGestureLongPress:
         touch_selection_controller_->HandleLongPressEvent(
             event.TimeStamp(), event.PositionInWidget());
         break;
 
-      case blink::WebInputEvent::kGestureTap:
+      case blink::WebInputEvent::Type::kGestureTap:
         touch_selection_controller_->HandleTapEvent(event.PositionInWidget(),
                                                     event.data.tap.tap_count);
         break;
 
-      case blink::WebInputEvent::kGestureScrollBegin:
+      case blink::WebInputEvent::Type::kGestureScrollBegin:
         touch_selection_controller_->OnScrollBeginEvent();
         break;
 
@@ -1803,19 +1803,21 @@ void RenderWidgetHostViewAndroid::SendGestureEvent(
   ui::LatencyInfo latency_info =
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event);
   if (event.SourceDevice() == blink::WebGestureDevice::kTouchscreen) {
-    if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+    if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
       // If there is a current scroll going on and a new scroll that isn't
       // wheel based, send a synthetic wheel event with kPhaseEnded to cancel
       // the current scroll.
       mouse_wheel_phase_handler_.DispatchPendingWheelEndEvent();
-    } else if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd) {
+    } else if (event.GetType() ==
+               blink::WebInputEvent::Type::kGestureScrollEnd) {
       // Make sure that the next wheel event will have phase = |kPhaseBegan|.
       // This is for maintaining the correct phase info when some of the wheel
       // events get ignored while a touchscreen scroll is going on.
       mouse_wheel_phase_handler_.IgnorePendingWheelEndEvent();
     }
 
-  } else if (event.GetType() == blink::WebInputEvent::kGestureFlingStart &&
+  } else if (event.GetType() ==
+                 blink::WebInputEvent::Type::kGestureFlingStart &&
              event.SourceDevice() == blink::WebGestureDevice::kTouchpad) {
     // Ignore the pending wheel end event to avoid sending a wheel event with
     // kPhaseEnded before a GFS.
@@ -2027,7 +2029,7 @@ void RenderWidgetHostViewAndroid::OnGestureEvent(
   // stop providing shift meta values to synthetic MotionEvents. This prevents
   // unintended shift+click interpretation of all accessibility clicks.
   // See crbug.com/443247.
-  if (web_gesture.GetType() == blink::WebInputEvent::kGestureTap &&
+  if (web_gesture.GetType() == blink::WebInputEvent::Type::kGestureTap &&
       web_gesture.GetModifiers() == blink::WebInputEvent::kShiftKey) {
     web_gesture.SetModifiers(blink::WebInputEvent::kNoModifiers);
   }
@@ -2166,7 +2168,7 @@ void RenderWidgetHostViewAndroid::OnStylusSelectTap(base::TimeTicks time,
   // Treat the stylus tap as a long press, activating either a word selection or
   // context menu depending on the targetted content.
   blink::WebGestureEvent long_press = WebGestureEventBuilder::Build(
-      blink::WebInputEvent::kGestureLongPress, time, x, y);
+      blink::WebInputEvent::Type::kGestureLongPress, time, x, y);
   SendGestureEvent(long_press);
 }
 

content/browser/renderer_host/render_widget_host_view_aura.cc

@@ -976,11 +976,11 @@ void RenderWidgetHostViewAura::GestureEventAck(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   const blink::WebInputEvent::Type event_type = event.GetType();
-  if (event_type == blink::WebGestureEvent::kGestureScrollBegin ||
-      event_type == blink::WebGestureEvent::kGestureScrollEnd) {
+  if (event_type == blink::WebGestureEvent::Type::kGestureScrollBegin ||
+      event_type == blink::WebGestureEvent::Type::kGestureScrollEnd) {
     if (host()->delegate()) {
       host()->delegate()->SetTopControlsGestureScrollInProgress(
-          event_type == blink::WebGestureEvent::kGestureScrollBegin);
+          event_type == blink::WebGestureEvent::Type::kGestureScrollBegin);
     }
   }
 
@@ -994,7 +994,7 @@ void RenderWidgetHostViewAura::GestureEventAck(
     // action would complete at the end of the active fling progress which
     // causes noticeable delay in cases that the fling velocity is large.
     // https://crbug.com/797855
-    if (event_type == blink::WebInputEvent::kGestureScrollUpdate &&
+    if (event_type == blink::WebInputEvent::Type::kGestureScrollUpdate &&
         event.data.scroll_update.inertial_phase ==
             blink::WebGestureEvent::InertialPhaseState::kMomentum &&
         overscroll_controller_->overscroll_mode() != OVERSCROLL_NONE) {
@@ -1021,7 +1021,8 @@ void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
 
   // The TouchScrollStarted event is generated & consumed downstream from the
   // TouchEventQueue. So we don't expect an ACK up here.
-  DCHECK(touch.event.GetType() != blink::WebInputEvent::kTouchScrollStarted);
+  DCHECK(touch.event.GetType() !=
+         blink::WebInputEvent::Type::kTouchScrollStarted);
 
   ui::EventResult result =
       (ack_result == blink::mojom::InputEventResultState::kConsumed)
@@ -1030,16 +1031,16 @@ void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
 
   blink::WebTouchPoint::State required_state;
   switch (touch.event.GetType()) {
-    case blink::WebInputEvent::kTouchStart:
+    case blink::WebInputEvent::Type::kTouchStart:
       required_state = blink::WebTouchPoint::kStatePressed;
       break;
-    case blink::WebInputEvent::kTouchEnd:
+    case blink::WebInputEvent::Type::kTouchEnd:
       required_state = blink::WebTouchPoint::kStateReleased;
       break;
-    case blink::WebInputEvent::kTouchMove:
+    case blink::WebInputEvent::Type::kTouchMove:
       required_state = blink::WebTouchPoint::kStateMoved;
       break;
-    case blink::WebInputEvent::kTouchCancel:
+    case blink::WebInputEvent::Type::kTouchCancel:
       required_state = blink::WebTouchPoint::kStateCancelled;
       break;
     default:
@@ -1079,7 +1080,7 @@ RenderWidgetHostViewAura::CreateSyntheticGestureTarget() {
 blink::mojom::InputEventResultState RenderWidgetHostViewAura::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
   bool consumed = false;
-  if (input_event.GetType() == WebInputEvent::kGestureFlingStart) {
+  if (input_event.GetType() == WebInputEvent::Type::kGestureFlingStart) {
     const WebGestureEvent& gesture_event =
         static_cast<const WebGestureEvent&>(input_event);
     // Zero-velocity touchpad flings are an Aura-specific signal that the
@@ -1099,7 +1100,7 @@ blink::mojom::InputEventResultState RenderWidgetHostViewAura::FilterInputEvent(
     return blink::mojom::InputEventResultState::kNotConsumed;
 
   if (consumed &&
-      input_event.GetType() == blink::WebInputEvent::kGestureFlingStart) {
+      input_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
     // Here we indicate that there was no consumer for this event, as
     // otherwise the fling animation system will try to run an animation
     // and will also expect a notification when the fling ends. Since

content/browser/renderer_host/render_widget_host_view_aura_unittest.cc

@@ -656,7 +656,7 @@ class RenderWidgetHostViewAuraOverscrollTest
           messages[i]->ToEvent();
       if (event &&
           event->Event()->web_event->GetType() ==
-              WebInputEvent::kGestureScrollUpdate &&
+              WebInputEvent::Type::kGestureScrollUpdate &&
           event->HasCallback()) {
         event->CallCallback(ack_result);
         return;
@@ -673,7 +673,7 @@ class RenderWidgetHostViewAuraOverscrollTest
           messages[i]->ToEvent();
       // GSB events are blocking, send the ack.
       if (event && event->Event()->web_event->GetType() ==
-                       WebInputEvent::kGestureScrollBegin) {
+                       WebInputEvent::Type::kGestureScrollBegin) {
         event->CallCallback(ack_result);
         return;
       }
@@ -745,7 +745,7 @@ class RenderWidgetHostViewAuraOverscrollTest
   }
 
   void SimulateMouseMove(int x, int y, int modifiers) {
-    SimulateMouseEvent(WebInputEvent::kMouseMove, x, y, modifiers, false);
+    SimulateMouseEvent(WebInputEvent::Type::kMouseMove, x, y, modifiers, false);
   }
 
   void SimulateMouseEvent(WebInputEvent::Type type,
@@ -937,13 +937,13 @@ class RenderWidgetHostViewAuraOverscrollTest
       // The first sent must be the wheel event and the second one must be
       // GestureScrollUpdate since the ack for the wheel event is non-blocking.
       EXPECT_TRUE(events[0]->ToEvent());
-      EXPECT_EQ(WebInputEvent::kMouseWheel,
+      EXPECT_EQ(WebInputEvent::Type::kMouseWheel,
                 events[0]->ToEvent()->Event()->web_event->GetType());
       gesture_scroll_update_index = 1;
     }
     EXPECT_EQ(gesture_scroll_update_index + 1, events.size());
     EXPECT_TRUE(events[gesture_scroll_update_index]->ToEvent());
-    EXPECT_EQ(WebInputEvent::kGestureScrollUpdate,
+    EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
               events[gesture_scroll_update_index]
                   ->ToEvent()
                   ->Event()
@@ -1702,14 +1702,15 @@ TEST_F(RenderWidgetHostViewAuraTest, TimerBasedWheelEventPhaseInfo) {
   events = GetAndResetDispatchedMessages();
   const WebGestureEvent* gesture_event = static_cast<const WebGestureEvent*>(
       events[0]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollBegin, gesture_event->GetType());
   EXPECT_TRUE(gesture_event->data.scroll_begin.synthetic);
   events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kConsumed);
 
   gesture_event = static_cast<const WebGestureEvent*>(
       events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
+            gesture_event->GetType());
   EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
   EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y);
   events[1]->ToEvent()->CallCallback(
@@ -1727,9 +1728,10 @@ TEST_F(RenderWidgetHostViewAuraTest, TimerBasedWheelEventPhaseInfo) {
   base::TimeTicks wheel_event_timestamp = wheel_event->TimeStamp();
   EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, wheel_event->phase);
 
-    gesture_event = static_cast<const WebGestureEvent*>(
-        events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  gesture_event = static_cast<const WebGestureEvent*>(
+      events[1]->ToEvent()->Event()->web_event.get());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
+            gesture_event->GetType());
   EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
   EXPECT_EQ(2U, gesture_event->data.scroll_update.delta_y);
   events[0]->ToEvent()->CallCallback(
@@ -1753,7 +1755,7 @@ TEST_F(RenderWidgetHostViewAuraTest, TimerBasedWheelEventPhaseInfo) {
 
   gesture_event = static_cast<const WebGestureEvent*>(
       events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollEnd, gesture_event->GetType());
   EXPECT_TRUE(gesture_event->data.scroll_end.synthetic);
 }
 
@@ -2030,13 +2032,14 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchpadFlingStartResetsWheelPhaseState) {
   EXPECT_EQ("GestureScrollBegin GestureScrollUpdate", GetMessageNames(events));
   const WebGestureEvent* gesture_event = static_cast<const WebGestureEvent*>(
       events[0]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollBegin, gesture_event->GetType());
   events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kConsumed);
 
   gesture_event = static_cast<const WebGestureEvent*>(
       events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
+            gesture_event->GetType());
   EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
   EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y);
   events[1]->ToEvent()->CallCallback(
@@ -2063,7 +2066,8 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchpadFlingStartResetsWheelPhaseState) {
       events[1]->ToEvent()->Event()->web_event.get());
   events[1]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kConsumed);
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
+            gesture_event->GetType());
   EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x);
   EXPECT_EQ(15U, gesture_event->data.scroll_update.delta_y);
 
@@ -2201,12 +2205,13 @@ TEST_F(RenderWidgetHostViewAuraTest,
   EXPECT_EQ("GestureScrollBegin GestureScrollUpdate", GetMessageNames(events));
   const WebGestureEvent* gesture_event = static_cast<const WebGestureEvent*>(
       events[0]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollBegin, gesture_event->GetType());
   events[0]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kConsumed);
   gesture_event = static_cast<const WebGestureEvent*>(
       events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollUpdate,
+            gesture_event->GetType());
   events[1]->ToEvent()->CallCallback(
       blink::mojom::InputEventResultState::kConsumed);
 
@@ -2298,12 +2303,12 @@ TEST_F(RenderWidgetHostViewAuraTest,
 
   gesture_event = static_cast<const WebGestureEvent*>(
       events[1]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollEnd, gesture_event->GetType());
   EXPECT_EQ(blink::WebGestureDevice::kTouchpad, gesture_event->SourceDevice());
 
   gesture_event = static_cast<const WebGestureEvent*>(
       events[2]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureScrollBegin, gesture_event->GetType());
   EXPECT_EQ(blink::WebGestureDevice::kTouchscreen,
             gesture_event->SourceDevice());
 }
@@ -2320,7 +2325,7 @@ TEST_F(RenderWidgetHostViewAuraTest,
   base::Optional<WebGestureEvent> last_gesture =
       widget_host_->GetAndResetLastForwardedGestureEvent();
   ASSERT_TRUE(last_gesture);
-  EXPECT_EQ(WebInputEvent::kGestureFlingCancel, last_gesture->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureFlingCancel, last_gesture->GetType());
 
   // Consume the wheel to prevent gesture scrolls from interfering with the
   // rest of the test.
@@ -3814,7 +3819,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   SimulateGestureFlingStartEvent(0.f, 0.f, blink::WebGestureDevice::kTouchpad);
   events = GetAndResetDispatchedMessages();
   for (const auto& event : events) {
-    EXPECT_NE(WebInputEvent::kGestureFlingStart,
+    EXPECT_NE(WebInputEvent::Type::kGestureFlingStart,
               event->ToEvent()->Event()->web_event->GetType());
   }
 
@@ -3822,7 +3827,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   // sends a nonblocking wheel end event. The GSE generated from wheel end event
   // resets scroll state.
   EXPECT_EQ(
-      WebInputEvent::kGestureScrollEnd,
+      WebInputEvent::Type::kGestureScrollEnd,
       events[events.size() - 1]->ToEvent()->Event()->web_event->GetType());
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
@@ -3852,7 +3857,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
     // Start and end a gesture in the same direction without processing the
     // gesture events in the renderer. This should initiate and complete an
     // overscroll.
-    SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+    SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                          blink::WebGestureDevice::kTouchscreen);
     SimulateGestureScrollUpdateEvent(300, -5, 0);
     MockWidgetInputHandler::MessageVector events =
@@ -3866,7 +3871,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
     EXPECT_EQ(OverscrollSource::TOUCHSCREEN, overscroll_source());
     EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
 
-    SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+    SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                          blink::WebGestureDevice::kTouchscreen);
     events = GetAndResetDispatchedMessages();
     EXPECT_EQ("GestureScrollEnd", GetMessageNames(events));
@@ -3882,7 +3887,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
     // initiate an overscroll, the overscroll mode should get reset after the
     // first GSU event generated by the fling controller.
     overscroll_delegate()->Reset();
-    SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+    SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                          blink::WebGestureDevice::kTouchscreen);
     SimulateGestureScrollUpdateEvent(-300, -5, 0);
     MockWidgetInputHandler::MessageVector events =
@@ -3922,7 +3927,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, GestureScrollOverscrolls) {
   SetUpOverscrollEnvironment();
 
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -3965,7 +3970,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, GestureScrollOverscrolls) {
   // Now send a scroll end. This should cancel the overscroll gesture, and send
   // the event to the renderer. The gesture-event filter should receive this
   // event.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ("GestureScrollEnd", GetMessageNames(events));
@@ -3983,7 +3988,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollDeltaCap) {
   PressAndSetTouchActionAuto();
   // Set overscroll cap and start scrolling.
   overscroll_delegate()->set_delta_cap(50);
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4034,7 +4039,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollDeltaCap) {
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
   // End overscrolling.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ("GestureScrollEnd", GetMessageNames(events));
@@ -4050,7 +4055,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, GestureScrollConsumed) {
   SetUpOverscrollEnvironment();
 
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SimulateGestureScrollUpdateEvent(10, 0, 0);
   MockWidgetInputHandler::MessageVector events =
@@ -4087,7 +4092,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
 
   PressAndSetTouchActionAuto();
   // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4102,7 +4107,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
 
   // Quickly end and restart the scroll gesture. These two events should get
   // discarded.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector second_scroll_update_events =
       GetAndResetDispatchedMessages();
@@ -4110,7 +4115,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   ReleaseAndResetDispatchedMessages();
 
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   second_scroll_update_events = GetAndResetDispatchedMessages();
   EXPECT_EQ(0U, second_scroll_update_events.size());
@@ -4170,7 +4175,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
 
   PressAndSetTouchActionAuto();
   // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4184,7 +4189,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   EXPECT_EQ("TouchScrollStarted GestureScrollUpdate", GetMessageNames(events));
 
   // Send an end event. This should get in the debounce queue.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   EXPECT_EQ(0U, GetAndResetDispatchedMessages().size());
   ReleaseAndResetDispatchedMessages();
@@ -4238,7 +4243,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   EXPECT_EQ(OverscrollSource::NONE, overscroll_source());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ("GestureScrollBegin", GetMessageNames(events));
@@ -4325,7 +4330,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   EXPECT_EQ("TouchEnd", GetMessageNames(events));
   SendNotConsumedAcks(events);
 
-  SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
   base::RunLoop().RunUntilIdle();
@@ -4347,7 +4352,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
 
   PressAndSetTouchActionAuto();
   // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4378,7 +4383,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
   // Send end event.
-  SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ(0U, events.size());
@@ -4394,7 +4399,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
 
   PressAndSetTouchActionAuto();
   // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   SendScrollBeginAckIfNeeded(events,
@@ -4422,7 +4427,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
   // Send end event.
-  SimulateGestureEvent(blink::WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(blink::WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ(0U, events.size());
@@ -4446,7 +4451,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollDirectionChange) {
 
   PressAndSetTouchActionAuto();
   // Start scrolling. Receive ACK as it being processed.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4490,7 +4495,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   SetUpOverscrollEnvironment();
 
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   MockWidgetInputHandler::MessageVector events =
       GetAndResetDispatchedMessages();
@@ -4505,7 +4510,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   // Send GSU to trigger overscroll.
   SimulateGestureScrollUpdateEvent(300, -5, 0);
   // Send GSE immediately before ACKing GSU.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
 
   // Now ACK the GSU. Should see a completed overscroll.
@@ -4525,7 +4530,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   SetUpOverscrollEnvironment();
 
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SimulateGestureScrollUpdateEvent(30, -5, 0);
   MockWidgetInputHandler::MessageVector events =
@@ -4544,7 +4549,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   SimulateGestureScrollUpdateEvent(30, -5, 0);
 
   // Send GSE immediately before ACKing GSU.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
 
   events = GetAndResetDispatchedMessages();
@@ -4676,7 +4681,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollMouseMoveCompletion) {
 
   // Now try with gestures.
   PressAndSetTouchActionAuto();
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SendScrollBeginAckIfNeeded(blink::mojom::InputEventResultState::kConsumed);
   SimulateGestureScrollUpdateEvent(300, -5, 0);
@@ -4699,7 +4704,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollMouseMoveCompletion) {
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
   SendNotConsumedAcks(events);
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
@@ -4754,7 +4759,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   SimulateGestureFlingStartEvent(0.f, 0.f, blink::WebGestureDevice::kTouchpad);
   events = GetAndResetDispatchedMessages();
   for (const auto& event : events) {
-    EXPECT_NE(WebInputEvent::kGestureFlingStart,
+    EXPECT_NE(WebInputEvent::Type::kGestureFlingStart,
               event->ToEvent()->Event()->web_event->GetType());
   }
 
@@ -4762,7 +4767,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   // sends a nonblocking wheel end event. The GSE generated from wheel end event
   // resets scroll state.
   EXPECT_EQ(
-      WebInputEvent::kGestureScrollEnd,
+      WebInputEvent::Type::kGestureScrollEnd,
       events[events.size() - 1]->ToEvent()->Event()->web_event->GetType());
   EXPECT_TRUE(ScrollStateIsUnknown());
 
@@ -4801,7 +4806,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   events = GetAndResetDispatchedMessages();
 
   for (const auto& event : events) {
-    EXPECT_NE(WebInputEvent::kGestureFlingStart,
+    EXPECT_NE(WebInputEvent::Type::kGestureFlingStart,
               event->ToEvent()->Event()->web_event->GetType());
   }
 
@@ -4809,7 +4814,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest,
   // sends a nonblocking wheel end event. The GSE generated from wheel end event
   // resets scroll state.
   EXPECT_EQ(
-      WebInputEvent::kGestureScrollEnd,
+      WebInputEvent::Type::kGestureScrollEnd,
       events[events.size() - 1]->ToEvent()->Event()->web_event->GetType());
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
@@ -4828,7 +4833,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) {
   PressAndSetTouchActionAuto();
   // Start an overscroll with gesture scroll. In the middle of the scroll, blur
   // the host.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SimulateGestureScrollUpdateEvent(300, -5, 0);
   MockWidgetInputHandler::MessageVector events =
@@ -4851,7 +4856,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) {
   EXPECT_EQ(0.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ("SetFocus GestureScrollEnd", GetMessageNames(events));
@@ -4860,7 +4865,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) {
   PressAndSetTouchActionAuto();
   // Start a scroll gesture again. This should correctly start the overscroll
   // after the threshold.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SimulateGestureScrollUpdateEvent(300, -5, 0);
   events = GetAndResetDispatchedMessages();
@@ -4875,7 +4880,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) {
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->completed_mode());
 
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   events = GetAndResetDispatchedMessages();
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
@@ -5138,7 +5143,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, ScrollDeltasResetOnEnd) {
   SendNotConsumedAcks(events);
 
   // Scroll gesture.
-  SimulateGestureEvent(WebInputEvent::kGestureScrollBegin,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollBegin,
                        blink::WebGestureDevice::kTouchscreen);
   SimulateGestureScrollUpdateEvent(-30, -5, 0);
   events = GetAndResetDispatchedMessages();
@@ -5150,7 +5155,7 @@ TEST_F(RenderWidgetHostViewAuraOverscrollTest, ScrollDeltasResetOnEnd) {
   EXPECT_EQ(OverscrollSource::NONE, overscroll_source());
   EXPECT_EQ(-30.f, overscroll_delta_x());
   EXPECT_EQ(-5.f, overscroll_delta_y());
-  SimulateGestureEvent(WebInputEvent::kGestureScrollEnd,
+  SimulateGestureEvent(WebInputEvent::Type::kGestureScrollEnd,
                        blink::WebGestureDevice::kTouchscreen);
   EXPECT_EQ(0.f, overscroll_delta_x());
   EXPECT_EQ(0.f, overscroll_delta_y());
@@ -5400,7 +5405,7 @@ TEST_F(RenderWidgetHostViewAuraTest, GestureTapFromStylusHasPointerType) {
             GetMessageNames(events));
   const WebGestureEvent* gesture_event = static_cast<const WebGestureEvent*>(
       events[2]->ToEvent()->Event()->web_event.get());
-  EXPECT_EQ(WebInputEvent::kGestureTap, gesture_event->GetType());
+  EXPECT_EQ(WebInputEvent::Type::kGestureTap, gesture_event->GetType());
   EXPECT_EQ(blink::WebPointerProperties::PointerType::kPen,
             gesture_event->primary_pointer_type);
 }

content/browser/renderer_host/render_widget_host_view_base.cc

@@ -99,12 +99,12 @@ void RenderWidgetHostViewBase::StopFlingingIfNecessary(
     blink::mojom::InputEventResultState ack_result) {
   // Reset view_stopped_flinging_for_test_ at the beginning of the scroll
   // sequence.
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin)
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin)
     view_stopped_flinging_for_test_ = false;
 
   bool processed = blink::mojom::InputEventResultState::kConsumed == ack_result;
   if (!processed &&
-      event.GetType() == blink::WebInputEvent::kGestureScrollUpdate &&
+      event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate &&
       event.data.scroll_update.inertial_phase ==
           blink::WebGestureEvent::InertialPhaseState::kMomentum &&
       event.SourceDevice() != blink::WebGestureDevice::kSyntheticAutoscroll) {
@@ -380,13 +380,13 @@ void RenderWidgetHostViewBase::ForwardTouchpadZoomEventIfNecessary(
     return;
 
   switch (event.GetType()) {
-    case blink::WebInputEvent::kGesturePinchBegin:
+    case blink::WebInputEvent::Type::kGesturePinchBegin:
       // Don't send the begin event until we get the first unconsumed update, so
       // that we elide pinch gesture steams consisting of only a begin and end.
       pending_touchpad_pinch_begin_ = event;
       pending_touchpad_pinch_begin_->SetNeedsWheelEvent(false);
       break;
-    case blink::WebInputEvent::kGesturePinchUpdate:
+    case blink::WebInputEvent::Type::kGesturePinchUpdate:
       if (ack_result != blink::mojom::InputEventResultState::kConsumed &&
           !event.data.pinch_update.zoom_disabled) {
         if (pending_touchpad_pinch_begin_) {
@@ -400,7 +400,7 @@ void RenderWidgetHostViewBase::ForwardTouchpadZoomEventIfNecessary(
         host()->ForwardGestureEvent(pinch_event);
       }
       break;
-    case blink::WebInputEvent::kGesturePinchEnd:
+    case blink::WebInputEvent::Type::kGesturePinchEnd:
       if (pending_touchpad_pinch_begin_) {
         pending_touchpad_pinch_begin_.reset();
       } else {
@@ -409,7 +409,7 @@ void RenderWidgetHostViewBase::ForwardTouchpadZoomEventIfNecessary(
         host()->ForwardGestureEvent(pinch_end_event);
       }
       break;
-    case blink::WebInputEvent::kGestureDoubleTap:
+    case blink::WebInputEvent::Type::kGestureDoubleTap:
       if (ack_result != blink::mojom::InputEventResultState::kConsumed) {
         blink::WebGestureEvent double_tap(event);
         double_tap.SetNeedsWheelEvent(false);

content/browser/renderer_host/render_widget_host_view_child_frame.cc

@@ -475,7 +475,7 @@ void RenderWidgetHostViewChildFrame::GestureEventAck(
   // its ack is not consumed. For the rest of the scroll events
   // (GestureScrollUpdate, GestureScrollEnd) are bubbled if the
   // GestureScrollBegin was bubbled.
-  if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
+  if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
     DCHECK(!is_scroll_sequence_bubbling_);
     is_scroll_sequence_bubbling_ =
         ack_result == blink::mojom::InputEventResultState::kNotConsumed ||
@@ -485,11 +485,11 @@ void RenderWidgetHostViewChildFrame::GestureEventAck(
   }
 
   if (is_scroll_sequence_bubbling_ &&
-      (event.GetType() == blink::WebInputEvent::kGestureScrollBegin ||
-       event.GetType() == blink::WebInputEvent::kGestureScrollUpdate ||
-       event.GetType() == blink::WebInputEvent::kGestureScrollEnd)) {
+      (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin ||
+       event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
+       event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd)) {
     const bool can_continue = frame_connector_->BubbleScrollEvent(event);
-    if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd ||
+    if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd ||
         !can_continue) {
       is_scroll_sequence_bubbling_ = false;
     }
@@ -638,7 +638,7 @@ bool RenderWidgetHostViewChildFrame::ScreenRectIsUnstableFor(
 
 void RenderWidgetHostViewChildFrame::PreProcessTouchEvent(
     const blink::WebTouchEvent& event) {
-  if (event.GetType() == blink::WebInputEvent::kTouchStart &&
+  if (event.GetType() == blink::WebInputEvent::Type::kTouchStart &&
       frame_connector_ && !frame_connector_->HasFocus()) {
     frame_connector_->FocusRootView();
   }
@@ -843,7 +843,7 @@ RenderWidgetHostViewChildFrame::FilterInputEvent(
     NOTREACHED();
   }
 
-  if (input_event.GetType() == blink::WebInputEvent::kGestureFlingStart) {
+  if (input_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
     const blink::WebGestureEvent& gesture_event =
         static_cast<const blink::WebGestureEvent&>(input_event);
     // Zero-velocity touchpad flings are an Aura-specific signal that the
@@ -864,7 +864,8 @@ RenderWidgetHostViewChildFrame::FilterInputEvent(
   }
 
   if (is_scroll_sequence_bubbling_ &&
-      (input_event.GetType() == blink::WebInputEvent::kGestureScrollUpdate) &&
+      (input_event.GetType() ==
+       blink::WebInputEvent::Type::kGestureScrollUpdate) &&
       frame_connector_) {
     // If we're bubbling, then to preserve latching behaviour, the child should
     // not consume this event. If the child has added its viewport to the scroll

content/browser/renderer_host/render_widget_host_view_child_frame_unittest.cc

@@ -85,7 +85,7 @@ class MockFrameConnectorDelegate : public FrameConnectorDelegate {
 
   blink::WebInputEvent::Type GetAndResetLastBubbledEventType() {
     blink::WebInputEvent::Type last = last_bubbled_event_type_;
-    last_bubbled_event_type_ = blink::WebInputEvent::kUndefined;
+    last_bubbled_event_type_ = blink::WebInputEvent::Type::kUndefined;
     return last;
   }
 
@@ -95,7 +95,7 @@ class MockFrameConnectorDelegate : public FrameConnectorDelegate {
 
  private:
   blink::WebInputEvent::Type last_bubbled_event_type_ =
-      blink::WebInputEvent::kUndefined;
+      blink::WebInputEvent::Type::kUndefined;
   bool can_bubble_ = true;
 };
 
@@ -314,20 +314,20 @@ TEST_F(RenderWidgetHostViewChildFrameTest, UncomsumedGestureScrollBubbled) {
       SyntheticWebGestureEventBuilder::BuildScrollUpdate(
           0.f, 10.f, 0, blink::WebGestureDevice::kTouchscreen);
   blink::WebGestureEvent scroll_end = SyntheticWebGestureEventBuilder::Build(
-      blink::WebInputEvent::kGestureScrollEnd,
+      blink::WebInputEvent::Type::kGestureScrollEnd,
       blink::WebGestureDevice::kTouchscreen);
 
   view_->GestureEventAck(
       scroll_begin, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(
       scroll_update, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(scroll_end,
                          blink::mojom::InputEventResultState::kIgnored);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 }
 
@@ -341,28 +341,28 @@ TEST_F(RenderWidgetHostViewChildFrameTest, ConsumedGestureScrollNotBubbled) {
       SyntheticWebGestureEventBuilder::BuildScrollUpdate(
           0.f, 10.f, 0, blink::WebGestureDevice::kTouchscreen);
   blink::WebGestureEvent scroll_end = SyntheticWebGestureEventBuilder::Build(
-      blink::WebInputEvent::kGestureScrollEnd,
+      blink::WebInputEvent::Type::kGestureScrollEnd,
       blink::WebGestureDevice::kTouchscreen);
 
   view_->GestureEventAck(scroll_begin,
                          blink::mojom::InputEventResultState::kConsumed);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(scroll_update,
                          blink::mojom::InputEventResultState::kConsumed);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 
   // Scrolling in a child my reach its extent and no longer be consumed, however
   // scrolling is latched to the child so we do not bubble the update.
   view_->GestureEventAck(
       scroll_update, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 
   view_->GestureEventAck(scroll_end,
                          blink::mojom::InputEventResultState::kIgnored);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 }
 
@@ -377,25 +377,25 @@ TEST_F(RenderWidgetHostViewChildFrameTest,
       SyntheticWebGestureEventBuilder::BuildScrollUpdate(
           0.f, 10.f, 0, blink::WebGestureDevice::kTouchscreen);
   blink::WebGestureEvent scroll_end = SyntheticWebGestureEventBuilder::Build(
-      blink::WebInputEvent::kGestureScrollEnd,
+      blink::WebInputEvent::Type::kGestureScrollEnd,
       blink::WebGestureDevice::kTouchscreen);
 
   test_frame_connector_->SetCanBubble(false);
 
   view_->GestureEventAck(
       scroll_begin, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 
   // The GSB was rejected, so the child view must not attempt to bubble the
   // remaining events of the scroll sequence.
   view_->GestureEventAck(
       scroll_update, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(scroll_end,
                          blink::mojom::InputEventResultState::kIgnored);
-  EXPECT_EQ(blink::WebInputEvent::kUndefined,
+  EXPECT_EQ(blink::WebInputEvent::Type::kUndefined,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 
   test_frame_connector_->SetCanBubble(true);
@@ -403,15 +403,15 @@ TEST_F(RenderWidgetHostViewChildFrameTest,
   // When we have a new scroll gesture, the view may try bubbling again.
   view_->GestureEventAck(
       scroll_begin, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollBegin,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollBegin,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(
       scroll_update, blink::mojom::InputEventResultState::kNoConsumerExists);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollUpdate,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollUpdate,
             test_frame_connector_->GetAndResetLastBubbledEventType());
   view_->GestureEventAck(scroll_end,
                          blink::mojom::InputEventResultState::kIgnored);
-  EXPECT_EQ(blink::WebInputEvent::kGestureScrollEnd,
+  EXPECT_EQ(blink::WebInputEvent::Type::kGestureScrollEnd,
             test_frame_connector_->GetAndResetLastBubbledEventType());
 }
 

content/browser/renderer_host/render_widget_host_view_event_handler.cc

@@ -84,8 +84,8 @@ bool ShouldGenerateAppCommand(const ui::MouseEvent* event) {
 // touchcancel.
 void MarkUnchangedTouchPointsAsStationary(blink::WebTouchEvent* event,
                                           int changed_touch_id) {
-  if (event->GetType() == blink::WebInputEvent::kTouchMove ||
-      event->GetType() == blink::WebInputEvent::kTouchCancel) {
+  if (event->GetType() == blink::WebInputEvent::Type::kTouchMove ||
+      event->GetType() == blink::WebInputEvent::Type::kTouchCancel) {
     for (size_t i = 0; i < event->touches_length; ++i) {
       if (event->touches[i].id != changed_touch_id)
         event->touches[i].state = blink::WebTouchPoint::kStateStationary;
@@ -579,7 +579,7 @@ void RenderWidgetHostViewEventHandler::OnGestureEvent(ui::GestureEvent* event) {
     // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
     // event to stop any in-progress flings.
     blink::WebGestureEvent fling_cancel = gesture;
-    fling_cancel.SetType(blink::WebInputEvent::kGestureFlingCancel);
+    fling_cancel.SetType(blink::WebInputEvent::Type::kGestureFlingCancel);
     fling_cancel.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
     if (ShouldRouteEvents()) {
       host_->delegate()->GetInputEventRouter()->RouteGestureEvent(
@@ -590,7 +590,7 @@ void RenderWidgetHostViewEventHandler::OnGestureEvent(ui::GestureEvent* event) {
     }
   }
 
-  if (gesture.GetType() != blink::WebInputEvent::kUndefined) {
+  if (gesture.GetType() != blink::WebInputEvent::Type::kUndefined) {
     if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       // If there is a current scroll going on and a new scroll that isn't
       // wheel based send a synthetic wheel event with kPhaseEnded to cancel
@@ -896,7 +896,7 @@ void RenderWidgetHostViewEventHandler::MoveCursorToCenter(
 
 bool RenderWidgetHostViewEventHandler::MatchesSynthesizedMovePosition(
     const blink::WebMouseEvent& event) {
-  if (event.GetType() == blink::WebInputEvent::kMouseMove &&
+  if (event.GetType() == blink::WebInputEvent::Type::kMouseMove &&
       synthetic_move_position_.has_value()) {
     if (IsFractionalScaleFactor(host_view_->current_device_scale_factor())) {
       // For fractional scale factors, the conversion from pixels to dip and

content/browser/renderer_host/render_widget_host_view_mac.mm

@@ -1154,9 +1154,9 @@ void RenderWidgetHostViewMac::GestureEventAck(
 
   bool consumed = ack_result == blink::mojom::InputEventResultState::kConsumed;
   switch (event.GetType()) {
-    case WebInputEvent::kGestureScrollBegin:
-    case WebInputEvent::kGestureScrollUpdate:
-    case WebInputEvent::kGestureScrollEnd:
+    case WebInputEvent::Type::kGestureScrollBegin:
+    case WebInputEvent::Type::kGestureScrollUpdate:
+    case WebInputEvent::Type::kGestureScrollEnd:
       [GetInProcessNSView() processedGestureScrollEvent:event
                                                consumed:consumed];
       return;
@@ -1564,7 +1564,7 @@ void RenderWidgetHostViewMac::ForwardMouseEvent(
   if (host())
     host()->ForwardMouseEvent(web_event);
 
-  if (web_event.GetType() == WebInputEvent::kMouseLeave)
+  if (web_event.GetType() == WebInputEvent::Type::kMouseLeave)
     ns_view_->SetTooltipText(base::string16());
 }
 
@@ -1610,7 +1610,7 @@ void RenderWidgetHostViewMac::GestureUpdate(
     // finish scrolling.
     mouse_wheel_phase_handler_.DispatchPendingWheelEndEvent();
     WebGestureEvent begin_event(*gesture_begin_event_);
-    begin_event.SetType(WebInputEvent::kGesturePinchBegin);
+    begin_event.SetType(WebInputEvent::Type::kGesturePinchBegin);
     begin_event.SetSourceDevice(blink::WebGestureDevice::kTouchpad);
     begin_event.SetNeedsWheelEvent(true);
     SendTouchpadZoomEvent(&begin_event);
@@ -1938,7 +1938,8 @@ void RenderWidgetHostViewMac::RouteOrProcessTouchEvent(
 void RenderWidgetHostViewMac::RouteOrProcessWheelEvent(
     std::unique_ptr<InputEvent> input_event) {
   if (!input_event || !input_event->web_event ||
-      input_event->web_event->GetType() != blink::WebInputEvent::kMouseWheel) {
+      input_event->web_event->GetType() !=
+          blink::WebInputEvent::Type::kMouseWheel) {
     DLOG(ERROR) << "Absent or non-MouseWheel event.";
     return;
   }
@@ -1963,7 +1964,8 @@ void RenderWidgetHostViewMac::ForwardMouseEvent(
 void RenderWidgetHostViewMac::ForwardWheelEvent(
     std::unique_ptr<InputEvent> input_event) {
   if (!input_event || !input_event->web_event ||
-      input_event->web_event->GetType() != blink::WebInputEvent::kMouseWheel) {
+      input_event->web_event->GetType() !=
+          blink::WebInputEvent::Type::kMouseWheel) {
     DLOG(ERROR) << "Absent or non-MouseWheel event.";
     return;
   }
@@ -1984,7 +1986,7 @@ void RenderWidgetHostViewMac::GestureBegin(
   blink::WebGestureEvent gesture_event =
       *static_cast<const blink::WebGestureEvent*>(input_event->web_event.get());
   // Strip the gesture type, because it is not known.
-  gesture_event.SetType(blink::WebInputEvent::kUndefined);
+  gesture_event.SetType(blink::WebInputEvent::Type::kUndefined);
   GestureBegin(gesture_event, is_synthetically_injected);
 }
 

content/browser/renderer_host/render_widget_host_view_mac_unittest.mm

@@ -119,7 +119,7 @@ using testing::_;
 - (void)rendererHandledGestureScrollEvent:(const blink::WebGestureEvent&)event
                                  consumed:(BOOL)consumed {
   if (!consumed &&
-      event.GetType() == blink::WebInputEvent::kGestureScrollUpdate)
+      event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate)
     _unhandledWheelEventReceived = true;
 }
 

content/browser/renderer_host/render_widget_targeter.cc

@@ -24,7 +24,7 @@ namespace {
 
 gfx::PointF ComputeEventLocation(const blink::WebInputEvent& event) {
   if (blink::WebInputEvent::IsMouseEventType(event.GetType()) ||
-      event.GetType() == blink::WebInputEvent::kMouseWheel) {
+      event.GetType() == blink::WebInputEvent::Type::kMouseWheel) {
     return static_cast<const blink::WebMouseEvent&>(event).PositionInWidget();
   }
   if (blink::WebInputEvent::IsTouchEventType(event.GetType())) {
@@ -183,7 +183,7 @@ void RenderWidgetTargeter::FindTargetAndDispatch(
     const blink::WebInputEvent& event,
     const ui::LatencyInfo& latency) {
   DCHECK(blink::WebInputEvent::IsMouseEventType(event.GetType()) ||
-         event.GetType() == blink::WebInputEvent::kMouseWheel ||
+         event.GetType() == blink::WebInputEvent::Type::kMouseWheel ||
          blink::WebInputEvent::IsTouchEventType(event.GetType()) ||
          (blink::WebInputEvent::IsGestureEventType(event.GetType()) &&
           (static_cast<const blink::WebGestureEvent&>(event).SourceDevice() ==

content/browser/renderer_host/ui_events_helper.cc

@@ -19,16 +19,16 @@ namespace {
 ui::EventType WebTouchPointStateToEventType(
     blink::WebTouchPoint::State state) {
   switch (state) {
-    case blink::WebTouchPoint::kStateReleased:
+    case blink::WebTouchPoint::State::kStateReleased:
       return ui::ET_TOUCH_RELEASED;
 
-    case blink::WebTouchPoint::kStatePressed:
+    case blink::WebTouchPoint::State::kStatePressed:
       return ui::ET_TOUCH_PRESSED;
 
-    case blink::WebTouchPoint::kStateMoved:
+    case blink::WebTouchPoint::State::kStateMoved:
       return ui::ET_TOUCH_MOVED;
 
-    case blink::WebTouchPoint::kStateCancelled:
+    case blink::WebTouchPoint::State::kStateCancelled:
       return ui::ET_TOUCH_CANCELLED;
 
     default:
@@ -47,16 +47,16 @@ bool MakeUITouchEventsFromWebTouchEvents(
   const blink::WebTouchEvent& touch = touch_with_latency.event;
   ui::EventType type = ui::ET_UNKNOWN;
   switch (touch.GetType()) {
-    case blink::WebInputEvent::kTouchStart:
+    case blink::WebInputEvent::Type::kTouchStart:
       type = ui::ET_TOUCH_PRESSED;
       break;
-    case blink::WebInputEvent::kTouchEnd:
+    case blink::WebInputEvent::Type::kTouchEnd:
       type = ui::ET_TOUCH_RELEASED;
       break;
-    case blink::WebInputEvent::kTouchMove:
+    case blink::WebInputEvent::Type::kTouchMove:
       type = ui::ET_TOUCH_MOVED;
       break;
-    case blink::WebInputEvent::kTouchCancel:
+    case blink::WebInputEvent::Type::kTouchCancel:
       type = ui::ET_TOUCH_CANCELLED;
       break;
     default:

content/browser/site_per_process_browsertest.cc

@@ -227,7 +227,8 @@ void NavigateNamedFrame(const ToRenderFrameHost& caller_frame,
 // hit-testing.
 void SimulateMouseClick(RenderWidgetHost* rwh, int x, int y) {
   blink::WebMouseEvent mouse_event(
-      blink::WebInputEvent::kMouseDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   mouse_event.button = blink::WebPointerProperties::Button::kLeft;
   mouse_event.SetPositionInWidget(x, y);
@@ -570,7 +571,7 @@ void LayoutNonRecursiveForTestingViewportIntersection(
 
 void GenerateTapDownGesture(RenderWidgetHost* rwh) {
   blink::WebGestureEvent gesture_tap_down(
-      blink::WebGestureEvent::kGestureTapDown,
+      blink::WebGestureEvent::Type::kGestureTapDown,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -1507,7 +1508,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ViewBoundsInNestedFrameTest) {
   // Scroll the parent frame downward to verify that the child rect gets updated
   // correctly.
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
 
   scroll_event.SetPositionInWidget(
@@ -1549,7 +1551,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 
   // The fling start won't bubble since its corresponding GSB hasn't bubbled.
   InputEventAckWaiter gesture_fling_start_ack_observer(
-      child_rwh, blink::WebInputEvent::kGestureFlingStart);
+      child_rwh, blink::WebInputEvent::Type::kGestureFlingStart);
 
   WaitForHitTestData(child_iframe_node->current_frame_host());
 
@@ -1559,7 +1561,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 
   // Send a GSB, GSU, GFS sequence and verify that the GFS bubbles.
   blink::WebGestureEvent gesture_scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -1571,7 +1573,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   child_rwh->ForwardGestureEvent(gesture_scroll_begin);
 
   blink::WebGestureEvent gesture_scroll_update(
-      blink::WebGestureEvent::kGestureScrollUpdate,
+      blink::WebGestureEvent::Type::kGestureScrollUpdate,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -1584,7 +1586,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   child_rwh->ForwardGestureEvent(gesture_scroll_update);
 
   blink::WebGestureEvent gesture_fling_start(
-      blink::WebGestureEvent::kGestureFlingStart,
+      blink::WebGestureEvent::Type::kGestureFlingStart,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -1631,7 +1633,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollBubblingFromOOPIFTest) {
 
   InputEventAckWaiter ack_observer(
       parent_iframe_node->current_frame_host()->GetRenderWidgetHost(),
-      blink::WebInputEvent::kGestureScrollEnd);
+      blink::WebInputEvent::Type::kGestureScrollEnd);
 
   // Navigate the nested frame to a page large enough to have scrollbars.
   FrameTreeNode* nested_iframe_node = parent_iframe_node->child_at(0);
@@ -1670,7 +1672,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollBubblingFromOOPIFTest) {
 
   // Scroll the parent frame downward.
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   scroll_event.SetPositionInWidget(1, 1);
   // Use precise pixels to keep these events off the animated scroll pathways,
@@ -1764,7 +1767,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollBubblingFromOOPIFTest) {
   // Scroll down the nested iframe via gesture. This requires 3 separate input
   // events.
   blink::WebGestureEvent gesture_event(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchpad);
@@ -1774,7 +1777,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollBubblingFromOOPIFTest) {
   rwhv_nested->GetRenderWidgetHost()->ForwardGestureEvent(gesture_event);
 
   gesture_event =
-      blink::WebGestureEvent(blink::WebGestureEvent::kGestureScrollUpdate,
+      blink::WebGestureEvent(blink::WebGestureEvent::Type::kGestureScrollUpdate,
                              blink::WebInputEvent::kNoModifiers,
                              blink::WebInputEvent::GetStaticTimeStampForTests(),
                              blink::WebGestureDevice::kTouchpad);
@@ -1786,7 +1789,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollBubblingFromOOPIFTest) {
   rwhv_nested->GetRenderWidgetHost()->ForwardGestureEvent(gesture_event);
 
   gesture_event =
-      blink::WebGestureEvent(blink::WebGestureEvent::kGestureScrollEnd,
+      blink::WebGestureEvent(blink::WebGestureEvent::Type::kGestureScrollEnd,
                              blink::WebInputEvent::kNoModifiers,
                              blink::WebInputEvent::GetStaticTimeStampForTests(),
                              blink::WebGestureDevice::kTouchpad);
@@ -1873,7 +1876,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   EXPECT_DOUBLE_EQ(0.0, initial_y);
 
   NativeWebKeyboardEvent key_event(
-      blink::WebKeyboardEvent::kRawKeyDown, blink::WebInputEvent::kNoModifiers,
+      blink::WebKeyboardEvent::Type::kRawKeyDown,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   key_event.windows_key_code = ui::VKEY_DOWN;
   key_event.native_key_code =
@@ -1883,7 +1887,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 
   rwhv_child->GetRenderWidgetHost()->ForwardKeyboardEvent(key_event);
 
-  key_event.SetType(blink::WebKeyboardEvent::kKeyUp);
+  key_event.SetType(blink::WebKeyboardEvent::Type::kKeyUp);
   rwhv_child->GetRenderWidgetHost()->ForwardKeyboardEvent(key_event);
 
   double scrolled_y = 0.0;
@@ -1917,7 +1921,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   GenerateTapDownGesture(child_rwh);
   // Send a GSB to start scrolling sequence.
   blink::WebGestureEvent gesture_scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   gesture_scroll_begin.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
@@ -1930,10 +1934,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Send a GFS and wait for the ack of the first GSU generated from progressing
   // the fling on the browser.
   InputEventAckWaiter gesture_scroll_update_ack_observer(
-      child_rwh, blink::WebInputEvent::kGestureScrollUpdate);
+      child_rwh, blink::WebInputEvent::Type::kGestureScrollUpdate);
   gesture_scroll_update_ack_observer.Reset();
   blink::WebGestureEvent gesture_fling_start(
-      blink::WebGestureEvent::kGestureFlingStart,
+      blink::WebGestureEvent::Type::kGestureFlingStart,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   gesture_fling_start.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
@@ -1961,9 +1965,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, TouchpadGestureFlingStart) {
 
   // Send a wheel event with phaseBegan to start scrolling sequence.
   InputEventAckWaiter gesture_scroll_begin_ack_observer(
-      child_rwh, blink::WebInputEvent::kGestureScrollBegin);
+      child_rwh, blink::WebInputEvent::Type::kGestureScrollBegin);
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   scroll_event.delta_units = ui::ScrollGranularity::kScrollByPrecisePixel;
   scroll_event.delta_x = 0.0f;
@@ -1975,10 +1980,10 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, TouchpadGestureFlingStart) {
   // Send a GFS and wait for the ack of the first GSU generated from progressing
   // the fling on the browser.
   InputEventAckWaiter gesture_scroll_update_ack_observer(
-      child_rwh, blink::WebInputEvent::kGestureScrollUpdate);
+      child_rwh, blink::WebInputEvent::Type::kGestureScrollUpdate);
   gesture_scroll_update_ack_observer.Reset();
   blink::WebGestureEvent gesture_fling_start(
-      blink::WebGestureEvent::kGestureFlingStart,
+      blink::WebGestureEvent::Type::kGestureFlingStart,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   gesture_fling_start.SetSourceDevice(blink::WebGestureDevice::kTouchpad);
@@ -1996,12 +2001,13 @@ class ScrollObserver : public RenderWidgetHost::InputEventObserver {
   ~ScrollObserver() override {}
 
   void OnInputEvent(const blink::WebInputEvent& event) override {
-    if (event.GetType() == blink::WebInputEvent::kGestureScrollUpdate) {
+    if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate) {
       blink::WebGestureEvent received_update =
           *static_cast<const blink::WebGestureEvent*>(&event);
       remaining_delta_x_ -= received_update.data.scroll_update.delta_x;
       remaining_delta_y_ -= received_update.data.scroll_update.delta_y;
-    } else if (event.GetType() == blink::WebInputEvent::kGestureScrollEnd) {
+    } else if (event.GetType() ==
+               blink::WebInputEvent::Type::kGestureScrollEnd) {
       if (message_loop_runner_->loop_running())
         message_loop_runner_->Quit();
       DCHECK_EQ(0, remaining_delta_x_);
@@ -2077,7 +2083,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 
   InputEventAckWaiter ack_observer(
       root->current_frame_host()->GetRenderWidgetHost(),
-      blink::WebInputEvent::kGestureScrollBegin);
+      blink::WebInputEvent::Type::kGestureScrollBegin);
 
   std::unique_ptr<ScrollObserver> scroll_observer;
 
@@ -2091,7 +2097,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Now scroll the nested frame upward, this must bubble all the way up to the
   // root.
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   gfx::Rect bounds = rwhv_nested->GetViewBounds();
   float scale_factor =
@@ -2150,7 +2157,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Now scroll the nested frame downward, this must bubble to the root since
   // the iframe source body is not scrollable.
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   gfx::Rect bounds = child_view->GetViewBounds();
   float scale_factor =
@@ -2223,7 +2231,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollLocalSubframeInOOPIF) {
       base::BindRepeating([](blink::mojom::InputEventResultSource,
                              blink::mojom::InputEventResultState state,
                              const blink::WebInputEvent& event) {
-        return event.GetType() == blink::WebGestureEvent::kGestureScrollBegin &&
+        return event.GetType() ==
+                   blink::WebGestureEvent::Type::kGestureScrollBegin &&
                state == blink::mojom::InputEventResultState::kConsumed;
       }));
 
@@ -2234,7 +2243,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, ScrollLocalSubframeInOOPIF) {
 
   // Now scroll the inner frame downward.
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   scroll_event.SetPositionInWidget(90, 110);
   scroll_event.delta_units = ui::ScrollGranularity::kScrollByPrecisePixel;
@@ -8171,7 +8181,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Wait for and then drop the ViewHostMsg_ShowWidget messages, so that both
   // widgets are left in pending-but-not-shown state.
   NativeWebKeyboardEvent event(
-      blink::WebKeyboardEvent::kChar, blink::WebInputEvent::kNoModifiers,
+      blink::WebKeyboardEvent::Type::kChar, blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   event.text[0] = ' ';
 
@@ -10959,7 +10969,7 @@ IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAndroidSiteIsolationTest,
   auto* host =
       static_cast<RenderWidgetHostImpl*>(root_rwhv()->GetRenderWidgetHost());
   InputEventAckWaiter gesture_pinch_end_waiter(
-      host, blink::WebInputEvent::kGesturePinchEnd);
+      host, blink::WebInputEvent::Type::kGesturePinchEnd);
   host->QueueSyntheticGesture(
       std::move(synthetic_pinch_gesture),
       base::BindOnce(&TouchSelectionControllerClientAndroidSiteIsolationTest::
@@ -11068,11 +11078,11 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   child_host->AddInputEventObserver(&child_touch_event_observer);
 
   InputEventAckWaiter root_ack_waiter(root_host,
-                                      blink::WebInputEvent::kTouchEnd);
+                                      blink::WebInputEvent::Type::kTouchEnd);
   InputEventAckWaiter child_ack_waiter(child_host,
-                                       blink::WebInputEvent::kTouchEnd);
+                                       blink::WebInputEvent::Type::kTouchEnd);
   InputEventAckWaiter child_gesture_tap_ack_waiter(
-      child_host, blink::WebInputEvent::kGestureTap);
+      child_host, blink::WebInputEvent::Type::kGestureTap);
 
   // Create GestureTap for child.
   gfx::PointF child_tap_point;
@@ -11218,7 +11228,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 #endif
 
   // Send pinch gesture and verify we receive the ack.
-  InputEventAckWaiter ack_waiter(host, blink::WebInputEvent::kGesturePinchEnd);
+  InputEventAckWaiter ack_waiter(host,
+                                 blink::WebInputEvent::Type::kGesturePinchEnd);
   host->QueueSyntheticGesture(
       std::move(synthetic_pinch_gesture),
       base::BindOnce([](SyntheticGesture::Result result) {
@@ -12650,7 +12661,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // listener manager records that its in a scroll.
   {
     blink::WebGestureEvent gesture_scroll_begin(
-        blink::WebGestureEvent::kGestureScrollBegin,
+        blink::WebGestureEvent::Type::kGestureScrollBegin,
         blink::WebInputEvent::kNoModifiers,
         blink::WebInputEvent::GetStaticTimeStampForTests(),
         blink::WebGestureDevice::kTouchscreen);
@@ -12662,7 +12673,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
     gesture_scroll_begin.data.scroll_begin.delta_y_hint = -5.f;
 
     blink::WebMouseEvent mouse_move(
-        blink::WebInputEvent::kMouseMove, blink::WebInputEvent::kNoModifiers,
+        blink::WebInputEvent::Type::kMouseMove,
+        blink::WebInputEvent::kNoModifiers,
         blink::WebInputEvent::GetStaticTimeStampForTests());
 
     // We wait for the dummy mouse move event since the GestureScrollEnd ACK is
@@ -12671,8 +12683,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
     // Thus we send a second event and when it's ACK'd we know the first has
     // already been processed (we do the same thing above but with a
     // ScrollUpdate).
-    InputEventAckWaiter mouse_move_waiter(child_rwh,
-                                          blink::WebInputEvent::kMouseMove);
+    InputEventAckWaiter mouse_move_waiter(
+        child_rwh, blink::WebInputEvent::Type::kMouseMove);
 
     child_rwh->ForwardGestureEvent(gesture_scroll_begin);
     child_rwh->ForwardMouseEvent(mouse_move);
@@ -12685,18 +12697,19 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Finish the scroll, ensure the gesture manager sees the scroll end.
   {
     blink::WebGestureEvent gesture_scroll_end(
-        blink::WebGestureEvent::kGestureScrollEnd,
+        blink::WebGestureEvent::Type::kGestureScrollEnd,
         blink::WebInputEvent::kNoModifiers,
         blink::WebInputEvent::GetStaticTimeStampForTests(),
         blink::WebGestureDevice::kTouchscreen);
 
     // See comment above for why this is sent.
     blink::WebMouseEvent mouse_move(
-        blink::WebInputEvent::kMouseMove, blink::WebInputEvent::kNoModifiers,
+        blink::WebInputEvent::Type::kMouseMove,
+        blink::WebInputEvent::kNoModifiers,
         blink::WebInputEvent::GetStaticTimeStampForTests());
 
-    InputEventAckWaiter mouse_move_waiter(child_rwh,
-                                          blink::WebInputEvent::kMouseMove);
+    InputEventAckWaiter mouse_move_waiter(
+        child_rwh, blink::WebInputEvent::Type::kMouseMove);
 
     child_rwh->ForwardGestureEvent(gesture_scroll_end);
     child_rwh->ForwardMouseEvent(mouse_move);
@@ -12958,9 +12971,9 @@ class SitePerProcessBrowserTouchActionTest : public SitePerProcessBrowserTest {
         base::BindRepeating([](blink::mojom::InputEventResultSource source,
                                blink::mojom::InputEventResultState state,
                                const blink::WebInputEvent& event) {
-          return event.GetType() == blink::WebGestureEvent::kTouchStart ||
-                 event.GetType() == blink::WebGestureEvent::kTouchMove ||
-                 event.GetType() == blink::WebGestureEvent::kTouchEnd;
+          return event.GetType() == blink::WebGestureEvent::Type::kTouchStart ||
+                 event.GetType() == blink::WebGestureEvent::Type::kTouchMove ||
+                 event.GetType() == blink::WebGestureEvent::Type::kTouchEnd;
         }));
 
     InputRouterImpl* input_router = static_cast<InputRouterImpl*>(
@@ -14409,7 +14422,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   // Queue the event and wait for it to be acked.
   InputEventAckWaiter ack_waiter(
       child_b->current_frame_host()->GetRenderWidgetHost(),
-      blink::WebInputEvent::kGestureDoubleTap);
+      blink::WebInputEvent::Type::kGestureDoubleTap);
   auto* host = static_cast<RenderWidgetHostImpl*>(
       root->current_frame_host()->GetRenderWidgetHost());
   host->QueueSyntheticGesture(
@@ -15043,8 +15056,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
 
   // Send pinch gesture and verify we receive the ack.
   {
-    InputEventAckWaiter ack_waiter(host,
-                                   blink::WebInputEvent::kGesturePinchEnd);
+    InputEventAckWaiter ack_waiter(
+        host, blink::WebInputEvent::Type::kGesturePinchEnd);
     host->QueueSyntheticGesture(
         std::move(synthetic_pinch_gesture),
         base::BindOnce([](SyntheticGesture::Result result) {
@@ -15109,8 +15122,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
   {
     auto* child_host = static_cast<RenderWidgetHostImpl*>(
         child->current_frame_host()->GetRenderWidgetHost());
-    InputEventAckWaiter ack_waiter(child_host,
-                                   blink::WebInputEvent::kGestureScrollEnd);
+    InputEventAckWaiter ack_waiter(
+        child_host, blink::WebInputEvent::Type::kGestureScrollEnd);
     host->QueueSyntheticGesture(
         std::move(synthetic_scroll_gesture),
         base::BindOnce([](SyntheticGesture::Result result) {

content/browser/site_per_process_mac_browsertest.mm

@@ -157,7 +157,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessMacBrowserTest,
       child_rwh, base::BindRepeating([](blink::mojom::InputEventResultSource,
                                         blink::mojom::InputEventResultState,
                                         const blink::WebInputEvent& event) {
-        return event.GetType() == blink::WebInputEvent::kGestureScrollBegin &&
+        return event.GetType() ==
+                   blink::WebInputEvent::Type::kGestureScrollBegin &&
                !static_cast<const blink::WebGestureEvent&>(event)
                     .data.scroll_begin.synthetic;
       }));
@@ -165,7 +166,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessMacBrowserTest,
       child_rwh, base::BindRepeating([](blink::mojom::InputEventResultSource,
                                         blink::mojom::InputEventResultState,
                                         const blink::WebInputEvent& event) {
-        return event.GetType() == blink::WebInputEvent::kGestureScrollEnd &&
+        return event.GetType() ==
+                   blink::WebInputEvent::Type::kGestureScrollEnd &&
                !static_cast<const blink::WebGestureEvent&>(event)
                     .data.scroll_end.synthetic;
       }));
@@ -174,7 +176,8 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessMacBrowserTest,
       static_cast<RenderWidgetHostViewBase*>(child_rwh->GetView());
 
   blink::WebMouseWheelEvent scroll_event(
-      blink::WebInputEvent::kMouseWheel, blink::WebInputEvent::kNoModifiers,
+      blink::WebInputEvent::Type::kMouseWheel,
+      blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests());
   scroll_event.SetPositionInWidget(1, 1);
   scroll_event.delta_units = ui::ScrollGranularity::kScrollByPrecisePixel;
@@ -270,7 +273,7 @@ void SendMacTouchpadPinchSequenceWithExpectedTarget(
   // isn't sent until the first PinchUpdate.
 
   InputEventAckWaiter waiter(expected_target->GetRenderWidgetHost(),
-                             blink::WebInputEvent::kGesturePinchBegin);
+                             blink::WebInputEvent::Type::kGesturePinchBegin);
   NSEvent* pinchUpdateEvent =
       MockGestureEvent(NSEventTypeMagnify, 0.25, gesture_point.x(),
                        gesture_point.y(), NSEventPhaseChanged);

content/browser/web_contents/web_contents_impl.cc

@@ -250,10 +250,10 @@ RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
 bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
   // Ideally, this list would be based more off of
   // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
-  return type == blink::WebInputEvent::kMouseDown ||
-         type == blink::WebInputEvent::kGestureScrollBegin ||
-         type == blink::WebInputEvent::kTouchStart ||
-         type == blink::WebInputEvent::kRawKeyDown;
+  return type == blink::WebInputEvent::Type::kMouseDown ||
+         type == blink::WebInputEvent::Type::kGestureScrollBegin ||
+         type == blink::WebInputEvent::Type::kTouchStart ||
+         type == blink::WebInputEvent::Type::kRawKeyDown;
 }
 
 // Ensures that OnDialogClosed is only called once.
@@ -6487,7 +6487,7 @@ void WebContentsImpl::DidReceiveInputEvent(
   if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
     return;
 
-  if (type != blink::WebInputEvent::kGestureScrollBegin)
+  if (type != blink::WebInputEvent::Type::kGestureScrollBegin)
     last_interactive_input_event_time_ = ui::EventTimeForNow();
 
   for (auto& observer : observers_)

content/browser/web_contents/web_contents_impl_browsertest.cc

@@ -3332,7 +3332,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, MouseButtonsNavigate) {
     TestNavigationObserver back_observer(web_contents);
     web_contents->GetRenderWidgetHostWithPageFocus()->ForwardMouseEvent(
         blink::WebMouseEvent(
-            blink::WebInputEvent::kMouseUp, gfx::PointF(51, 50),
+            blink::WebInputEvent::Type::kMouseUp, gfx::PointF(51, 50),
             gfx::PointF(51, 50), blink::WebPointerProperties::Button::kBack, 0,
             blink::WebInputEvent::kNoModifiers, base::TimeTicks::Now()));
     back_observer.Wait();
@@ -3343,7 +3343,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, MouseButtonsNavigate) {
     TestNavigationObserver forward_observer(web_contents);
     web_contents->GetRenderWidgetHostWithPageFocus()->ForwardMouseEvent(
         blink::WebMouseEvent(
-            blink::WebInputEvent::kMouseUp, gfx::PointF(51, 50),
+            blink::WebInputEvent::Type::kMouseUp, gfx::PointF(51, 50),
             gfx::PointF(51, 50), blink::WebPointerProperties::Button::kForward,
             0, blink::WebInputEvent::kNoModifiers, base::TimeTicks::Now()));
     forward_observer.Wait();
@@ -3374,8 +3374,8 @@ IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, MouseButtonsDontNavigate) {
   RenderWidgetHostImpl* render_widget_host =
       web_contents->GetRenderWidgetHostWithPageFocus();
   render_widget_host->ForwardMouseEvent(blink::WebMouseEvent(
-      blink::WebInputEvent::kMouseUp, gfx::PointF(51, 50), gfx::PointF(51, 50),
-      blink::WebPointerProperties::Button::kBack, 0,
+      blink::WebInputEvent::Type::kMouseUp, gfx::PointF(51, 50),
+      gfx::PointF(51, 50), blink::WebPointerProperties::Button::kBack, 0,
       blink::WebInputEvent::kNoModifiers, base::TimeTicks::Now()));
   RunUntilInputProcessed(render_widget_host);
 
@@ -3406,8 +3406,8 @@ IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, MouseButtonsDontNavigate) {
 
   render_widget_host = web_contents->GetRenderWidgetHostWithPageFocus();
   render_widget_host->ForwardMouseEvent(blink::WebMouseEvent(
-      blink::WebInputEvent::kMouseUp, gfx::PointF(51, 50), gfx::PointF(51, 50),
-      blink::WebPointerProperties::Button::kForward, 0,
+      blink::WebInputEvent::Type::kMouseUp, gfx::PointF(51, 50),
+      gfx::PointF(51, 50), blink::WebPointerProperties::Button::kForward, 0,
       blink::WebInputEvent::kNoModifiers, base::TimeTicks::Now()));
   RunUntilInputProcessed(render_widget_host);
   // Wait an action timeout and assert the URL is correct.

content/browser/web_contents/web_contents_view_aura_browsertest.cc

@@ -347,7 +347,7 @@ class SpuriousMouseMoveEventObserver
   }
 
   void OnInputEvent(const blink::WebInputEvent& event) override {
-    EXPECT_NE(blink::WebInputEvent::kMouseMove, event.GetType())
+    EXPECT_NE(blink::WebInputEvent::Type::kMouseMove, event.GetType())
         << "Unexpected mouse move event.";
   }
 
@@ -392,7 +392,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
   SpuriousMouseMoveEventObserver mouse_observer(GetRenderWidgetHost());
 
   blink::WebGestureEvent gesture_scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -403,7 +403,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
   GetRenderWidgetHost()->ForwardGestureEvent(gesture_scroll_begin);
 
   blink::WebGestureEvent gesture_scroll_update(
-      blink::WebGestureEvent::kGestureScrollUpdate,
+      blink::WebGestureEvent::Type::kGestureScrollUpdate,
       blink::WebInputEvent::kNoModifiers,
       blink::WebInputEvent::GetStaticTimeStampForTests(),
       blink::WebGestureDevice::kTouchscreen);
@@ -877,7 +877,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
         base::BindRepeating([](blink::mojom::InputEventResultSource,
                                blink::mojom::InputEventResultState state,
                                const blink::WebInputEvent& event) {
-          return event.GetType() == blink::WebGestureEvent::kTouchStart &&
+          return event.GetType() == blink::WebGestureEvent::Type::kTouchStart &&
                  state == blink::mojom::InputEventResultState::kNotConsumed;
         }));
     // Send touch press.
@@ -895,7 +895,7 @@ IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
         base::BindRepeating([](blink::mojom::InputEventResultSource,
                                blink::mojom::InputEventResultState state,
                                const blink::WebInputEvent& event) {
-          return event.GetType() == blink::WebGestureEvent::kTouchMove &&
+          return event.GetType() == blink::WebGestureEvent::Type::kTouchMove &&
                  state == blink::mojom::InputEventResultState::kNotConsumed;
         }));
     GetRenderWidgetHost()->ForwardTouchEventWithLatencyInfo(touch,
@@ -933,9 +933,9 @@ IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
                                                             ui::LatencyInfo());
     WaitAFrame();
 
-    blink::WebGestureEvent scroll_end(blink::WebInputEvent::kGestureScrollEnd,
-                                      blink::WebInputEvent::kNoModifiers,
-                                      ui::EventTimeForNow());
+    blink::WebGestureEvent scroll_end(
+        blink::WebInputEvent::Type::kGestureScrollEnd,
+        blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     GetRenderWidgetHost()->ForwardGestureEventWithLatencyInfo(
         scroll_end, ui::LatencyInfo());
     WaitAFrame();

content/browser/webui/web_ui_browsertest.cc

@@ -288,11 +288,14 @@ IN_PROC_BROWSER_TEST_F(WebUIRequiringGestureBrowserTest,
                        MessageRequiringGestureIgnoresNonInteractiveEvents) {
   // Mouse enter / mouse move / mouse leave should not be considered input
   // events that interact with the page.
-  content::SimulateMouseEvent(web_contents(), blink::WebInputEvent::kMouseEnter,
+  content::SimulateMouseEvent(web_contents(),
+                              blink::WebInputEvent::Type::kMouseEnter,
                               gfx::Point(50, 50));
-  content::SimulateMouseEvent(web_contents(), blink::WebInputEvent::kMouseMove,
+  content::SimulateMouseEvent(web_contents(),
+                              blink::WebInputEvent::Type::kMouseMove,
                               gfx::Point(50, 50));
-  content::SimulateMouseEvent(web_contents(), blink::WebInputEvent::kMouseLeave,
+  content::SimulateMouseEvent(web_contents(),
+                              blink::WebInputEvent::Type::kMouseLeave,
                               gfx::Point(50, 50));
   // Nor should mouse wheel.
   content::SimulateMouseWheelEvent(web_contents(), gfx::Point(50, 50),

content/public/test/browser_test_utils.cc

@@ -268,8 +268,8 @@ void BuildSimpleWebKeyEvent(blink::WebInputEvent::Type type,
   event->is_system_key = false;
   event->skip_in_browser = true;
 
-  if (type == blink::WebInputEvent::kChar ||
-      type == blink::WebInputEvent::kRawKeyDown) {
+  if (type == blink::WebInputEvent::Type::kChar ||
+      type == blink::WebInputEvent::Type::kRawKeyDown) {
     // |key| is the only parameter that contains information about the case of
     // the character. Use it to be able to generate lower case input.
     if (key.IsCharacter()) {
@@ -309,25 +309,25 @@ int SimulateModifierKeysDown(WebContents* web_contents,
   // For our simulation we can use either the left keys or the right keys.
   if (control) {
     modifiers |= blink::WebInputEvent::kControlKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kRawKeyDown,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kRawKeyDown,
                       ui::DomKey::CONTROL, ui::DomCode::CONTROL_LEFT,
                       ui::VKEY_CONTROL, modifiers);
   }
   if (shift) {
     modifiers |= blink::WebInputEvent::kShiftKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kRawKeyDown,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kRawKeyDown,
                       ui::DomKey::SHIFT, ui::DomCode::SHIFT_LEFT,
                       ui::VKEY_SHIFT, modifiers);
   }
   if (alt) {
     modifiers |= blink::WebInputEvent::kAltKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kRawKeyDown,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kRawKeyDown,
                       ui::DomKey::ALT, ui::DomCode::ALT_LEFT, ui::VKEY_MENU,
                       modifiers);
   }
   if (command) {
     modifiers |= blink::WebInputEvent::kMetaKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kRawKeyDown,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kRawKeyDown,
                       ui::DomKey::META, ui::DomCode::META_LEFT,
                       ui::VKEY_COMMAND, modifiers);
   }
@@ -343,28 +343,28 @@ int SimulateModifierKeysUp(WebContents* web_contents,
   // The order of these key releases shouldn't matter for our simulation.
   if (control) {
     modifiers &= ~blink::WebInputEvent::kControlKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kKeyUp,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kKeyUp,
                       ui::DomKey::CONTROL, ui::DomCode::CONTROL_LEFT,
                       ui::VKEY_CONTROL, modifiers);
   }
 
   if (shift) {
     modifiers &= ~blink::WebInputEvent::kShiftKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kKeyUp,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kKeyUp,
                       ui::DomKey::SHIFT, ui::DomCode::SHIFT_LEFT,
                       ui::VKEY_SHIFT, modifiers);
   }
 
   if (alt) {
     modifiers &= ~blink::WebInputEvent::kAltKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kKeyUp,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kKeyUp,
                       ui::DomKey::ALT, ui::DomCode::ALT_LEFT, ui::VKEY_MENU,
                       modifiers);
   }
 
   if (command) {
     modifiers &= ~blink::WebInputEvent::kMetaKey;
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kKeyUp,
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kKeyUp,
                       ui::DomKey::META, ui::DomCode::META_LEFT,
                       ui::VKEY_COMMAND, modifiers);
   }
@@ -377,13 +377,13 @@ void SimulateKeyEvent(WebContents* web_contents,
                       ui::KeyboardCode key_code,
                       bool send_char,
                       int modifiers) {
-  InjectRawKeyEvent(web_contents, blink::WebInputEvent::kRawKeyDown, key, code,
-                    key_code, modifiers);
+  InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kRawKeyDown, key,
+                    code, key_code, modifiers);
   if (send_char) {
-    InjectRawKeyEvent(web_contents, blink::WebInputEvent::kChar, key, code,
-                      key_code, modifiers);
+    InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kChar, key,
+                      code, key_code, modifiers);
   }
-  InjectRawKeyEvent(web_contents, blink::WebInputEvent::kKeyUp, key, code,
+  InjectRawKeyEvent(web_contents, blink::WebInputEvent::Type::kKeyUp, key, code,
                     key_code, modifiers);
 }
 
@@ -855,8 +855,8 @@ void SimulateMouseClickAt(WebContents* web_contents,
                           int modifiers,
                           blink::WebMouseEvent::Button button,
                           const gfx::Point& point) {
-  blink::WebMouseEvent mouse_event(blink::WebInputEvent::kMouseDown, modifiers,
-                                   ui::EventTimeForNow());
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::Type::kMouseDown,
+                                   modifiers, ui::EventTimeForNow());
   mouse_event.button = button;
   mouse_event.SetPositionInWidget(point.x(), point.y());
   // Mac needs positionInScreen for events to plugins.
@@ -866,7 +866,7 @@ void SimulateMouseClickAt(WebContents* web_contents,
   mouse_event.click_count = 1;
   web_contents->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
-  mouse_event.SetType(blink::WebInputEvent::kMouseUp);
+  mouse_event.SetType(blink::WebInputEvent::Type::kMouseUp);
   web_contents->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
 }
@@ -880,8 +880,8 @@ void SimulateRoutedMouseClickAt(WebContents* web_contents,
   content::RenderWidgetHostViewBase* rwhvb =
       static_cast<content::RenderWidgetHostViewBase*>(
           web_contents->GetRenderWidgetHostView());
-  blink::WebMouseEvent mouse_event(blink::WebInputEvent::kMouseDown, modifiers,
-                                   ui::EventTimeForNow());
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::Type::kMouseDown,
+                                   modifiers, ui::EventTimeForNow());
   mouse_event.button = button;
   mouse_event.SetPositionInWidget(point.x(), point.y());
   // Mac needs positionInScreen for events to plugins.
@@ -891,7 +891,7 @@ void SimulateRoutedMouseClickAt(WebContents* web_contents,
   mouse_event.click_count = 1;
   web_contents_impl->GetInputEventRouter()->RouteMouseEvent(rwhvb, &mouse_event,
                                                             ui::LatencyInfo());
-  mouse_event.SetType(blink::WebInputEvent::kMouseUp);
+  mouse_event.SetType(blink::WebInputEvent::Type::kMouseUp);
   web_contents_impl->GetInputEventRouter()->RouteMouseEvent(rwhvb, &mouse_event,
                                                             ui::LatencyInfo());
 }
@@ -901,8 +901,8 @@ void SendMouseDownToWidget(RenderWidgetHost* target,
                            blink::WebMouseEvent::Button button) {
   auto* view = static_cast<content::RenderWidgetHostImpl*>(target)->GetView();
 
-  blink::WebMouseEvent mouse_event(blink::WebInputEvent::kMouseDown, modifiers,
-                                   ui::EventTimeForNow());
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::Type::kMouseDown,
+                                   modifiers, ui::EventTimeForNow());
   mouse_event.button = button;
   int x = view->GetViewBounds().width() / 2;
   int y = view->GetViewBounds().height() / 2;
@@ -953,7 +953,7 @@ void SimulateMouseWheelEvent(WebContents* web_contents,
                              const gfx::Point& point,
                              const gfx::Vector2d& delta,
                              const blink::WebMouseWheelEvent::Phase phase) {
-  blink::WebMouseWheelEvent wheel_event(blink::WebInputEvent::kMouseWheel,
+  blink::WebMouseWheelEvent wheel_event(blink::WebInputEvent::Type::kMouseWheel,
                                         blink::WebInputEvent::kNoModifiers,
                                         ui::EventTimeForNow());
 
@@ -971,7 +971,7 @@ void SimulateMouseWheelCtrlZoomEvent(WebContents* web_contents,
                                      const gfx::Point& point,
                                      bool zoom_in,
                                      blink::WebMouseWheelEvent::Phase phase) {
-  blink::WebMouseWheelEvent wheel_event(blink::WebInputEvent::kMouseWheel,
+  blink::WebMouseWheelEvent wheel_event(blink::WebInputEvent::Type::kMouseWheel,
                                         blink::WebInputEvent::kControlKey,
                                         ui::EventTimeForNow());
 
@@ -1017,9 +1017,9 @@ void SimulateGesturePinchSequence(WebContents* web_contents,
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
 
-  blink::WebGestureEvent pinch_begin(blink::WebInputEvent::kGesturePinchBegin,
-                                     blink::WebInputEvent::kNoModifiers,
-                                     ui::EventTimeForNow(), source_device);
+  blink::WebGestureEvent pinch_begin(
+      blink::WebInputEvent::Type::kGesturePinchBegin,
+      blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(), source_device);
   pinch_begin.SetPositionInWidget(gfx::PointF(point));
   pinch_begin.SetPositionInScreen(gfx::PointF(point));
   pinch_begin.SetNeedsWheelEvent(source_device ==
@@ -1027,14 +1027,14 @@ void SimulateGesturePinchSequence(WebContents* web_contents,
   widget_host->ForwardGestureEvent(pinch_begin);
 
   blink::WebGestureEvent pinch_update(pinch_begin);
-  pinch_update.SetType(blink::WebInputEvent::kGesturePinchUpdate);
+  pinch_update.SetType(blink::WebInputEvent::Type::kGesturePinchUpdate);
   pinch_update.data.pinch_update.scale = scale;
   pinch_update.SetNeedsWheelEvent(source_device ==
                                   blink::WebGestureDevice::kTouchpad);
   widget_host->ForwardGestureEvent(pinch_update);
 
   blink::WebGestureEvent pinch_end(pinch_begin);
-  pinch_end.SetType(blink::WebInputEvent::kGesturePinchEnd);
+  pinch_end.SetType(blink::WebInputEvent::Type::kGesturePinchEnd);
   pinch_end.SetNeedsWheelEvent(source_device ==
                                blink::WebGestureDevice::kTouchpad);
   widget_host->ForwardGestureEvent(pinch_end);
@@ -1047,7 +1047,7 @@ void SimulateGestureScrollSequence(WebContents* web_contents,
       web_contents->GetRenderViewHost()->GetWidget());
 
   blink::WebGestureEvent scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
       blink::WebGestureDevice::kTouchpad);
   scroll_begin.SetPositionInWidget(gfx::PointF(point));
@@ -1056,7 +1056,7 @@ void SimulateGestureScrollSequence(WebContents* web_contents,
   widget_host->ForwardGestureEvent(scroll_begin);
 
   blink::WebGestureEvent scroll_update(
-      blink::WebGestureEvent::kGestureScrollUpdate,
+      blink::WebGestureEvent::Type::kGestureScrollUpdate,
       blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
       blink::WebGestureDevice::kTouchpad);
   scroll_update.SetPositionInWidget(gfx::PointF(point));
@@ -1066,10 +1066,10 @@ void SimulateGestureScrollSequence(WebContents* web_contents,
   scroll_update.data.scroll_update.velocity_y = 0;
   widget_host->ForwardGestureEvent(scroll_update);
 
-  blink::WebGestureEvent scroll_end(blink::WebGestureEvent::kGestureScrollEnd,
-                                    blink::WebInputEvent::kNoModifiers,
-                                    ui::EventTimeForNow(),
-                                    blink::WebGestureDevice::kTouchpad);
+  blink::WebGestureEvent scroll_end(
+      blink::WebGestureEvent::Type::kGestureScrollEnd,
+      blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
+      blink::WebGestureDevice::kTouchpad);
   scroll_end.SetPositionInWidget(gfx::PointF(point));
   widget_host->ForwardGestureEvent(scroll_end);
 }
@@ -1081,23 +1081,23 @@ void SimulateGestureFlingSequence(WebContents* web_contents,
       web_contents->GetRenderViewHost()->GetWidget());
 
   blink::WebGestureEvent scroll_begin(
-      blink::WebGestureEvent::kGestureScrollBegin,
+      blink::WebGestureEvent::Type::kGestureScrollBegin,
       blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
       blink::WebGestureDevice::kTouchpad);
   scroll_begin.SetPositionInWidget(gfx::PointF(point));
   widget_host->ForwardGestureEvent(scroll_begin);
 
-  blink::WebGestureEvent scroll_end(blink::WebGestureEvent::kGestureScrollEnd,
-                                    blink::WebInputEvent::kNoModifiers,
-                                    ui::EventTimeForNow(),
-                                    blink::WebGestureDevice::kTouchpad);
+  blink::WebGestureEvent scroll_end(
+      blink::WebGestureEvent::Type::kGestureScrollEnd,
+      blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
+      blink::WebGestureDevice::kTouchpad);
   scroll_end.SetPositionInWidget(gfx::PointF(point));
   widget_host->ForwardGestureEvent(scroll_end);
 
-  blink::WebGestureEvent fling_start(blink::WebGestureEvent::kGestureFlingStart,
-                                     blink::WebInputEvent::kNoModifiers,
-                                     ui::EventTimeForNow(),
-                                     blink::WebGestureDevice::kTouchpad);
+  blink::WebGestureEvent fling_start(
+      blink::WebGestureEvent::Type::kGestureFlingStart,
+      blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow(),
+      blink::WebGestureDevice::kTouchpad);
   fling_start.SetPositionInWidget(gfx::PointF(point));
   fling_start.data.fling_start.target_viewport = false;
   fling_start.data.fling_start.velocity_x = velocity.x();
@@ -1126,19 +1126,19 @@ void SimulateTouchGestureAt(WebContents* web_contents,
 
 void SimulateTapDownAt(WebContents* web_contents, const gfx::Point& point) {
   SimulateTouchGestureAt(web_contents, point,
-                         blink::WebGestureEvent::kGestureTapDown);
+                         blink::WebGestureEvent::Type::kGestureTapDown);
 }
 
 void SimulateTapAt(WebContents* web_contents, const gfx::Point& point) {
   SimulateTouchGestureAt(web_contents, point,
-                         blink::WebGestureEvent::kGestureTap);
+                         blink::WebGestureEvent::Type::kGestureTap);
 }
 
 void SimulateTapWithModifiersAt(WebContents* web_contents,
                                 unsigned modifiers,
                                 const gfx::Point& point) {
-  blink::WebGestureEvent tap(blink::WebGestureEvent::kGestureTap, modifiers,
-                             ui::EventTimeForNow(),
+  blink::WebGestureEvent tap(blink::WebGestureEvent::Type::kGestureTap,
+                             modifiers, ui::EventTimeForNow(),
                              blink::WebGestureDevice::kTouchpad);
   tap.SetPositionInWidget(gfx::PointF(point));
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(

content/public/test/render_view_test.cc

@@ -629,7 +629,7 @@ bool RenderViewTest::SimulateElementClick(const std::string& element_id) {
 }
 
 void RenderViewTest::SimulatePointClick(const gfx::Point& point) {
-  WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
+  WebMouseEvent mouse_event(WebInputEvent::Type::kMouseDown,
                             WebInputEvent::kNoModifiers, ui::EventTimeForNow());
   mouse_event.button = WebMouseEvent::Button::kLeft;
   mouse_event.SetPositionInWidget(point.x(), point.y());
@@ -638,7 +638,7 @@ void RenderViewTest::SimulatePointClick(const gfx::Point& point) {
   RenderWidget* widget = view->GetMainRenderFrame()->GetLocalRootRenderWidget();
   widget->HandleInputEvent(blink::WebCoalescedInputEvent(mouse_event),
                            ui::LatencyInfo(), HandledEventCallback());
-  mouse_event.SetType(WebInputEvent::kMouseUp);
+  mouse_event.SetType(WebInputEvent::Type::kMouseUp);
   widget->HandleInputEvent(blink::WebCoalescedInputEvent(mouse_event),
                            ui::LatencyInfo(), HandledEventCallback());
 }
@@ -653,7 +653,7 @@ bool RenderViewTest::SimulateElementRightClick(const std::string& element_id) {
 }
 
 void RenderViewTest::SimulatePointRightClick(const gfx::Point& point) {
-  WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
+  WebMouseEvent mouse_event(WebInputEvent::Type::kMouseDown,
                             WebInputEvent::kNoModifiers, ui::EventTimeForNow());
   mouse_event.button = WebMouseEvent::Button::kRight;
   mouse_event.SetPositionInWidget(point.x(), point.y());
@@ -662,14 +662,14 @@ void RenderViewTest::SimulatePointRightClick(const gfx::Point& point) {
   RenderWidget* widget = view->GetMainRenderFrame()->GetLocalRootRenderWidget();
   widget->HandleInputEvent(blink::WebCoalescedInputEvent(mouse_event),
                            ui::LatencyInfo(), HandledEventCallback());
-  mouse_event.SetType(WebInputEvent::kMouseUp);
+  mouse_event.SetType(WebInputEvent::Type::kMouseUp);
   widget->HandleInputEvent(blink::WebCoalescedInputEvent(mouse_event),
                            ui::LatencyInfo(), HandledEventCallback());
 }
 
 void RenderViewTest::SimulateRectTap(const gfx::Rect& rect) {
   WebGestureEvent gesture_event(
-      WebInputEvent::kGestureTap, WebInputEvent::kNoModifiers,
+      WebInputEvent::Type::kGestureTap, WebInputEvent::kNoModifiers,
       ui::EventTimeForNow(), blink::WebGestureDevice::kTouchscreen);
   gesture_event.SetPositionInWidget(gfx::PointF(rect.CenterPoint()));
   gesture_event.data.tap.tap_count = 1;
@@ -734,16 +734,16 @@ void RenderViewTest::SimulateUserTypingASCIICharacter(char ascii_character,
     modifiers = blink::WebKeyboardEvent::kShiftKey;
   }
 
-  blink::WebKeyboardEvent event(blink::WebKeyboardEvent::kRawKeyDown, modifiers,
-                                ui::EventTimeForNow());
+  blink::WebKeyboardEvent event(blink::WebKeyboardEvent::Type::kRawKeyDown,
+                                modifiers, ui::EventTimeForNow());
   event.text[0] = ascii_character;
   ASSERT_TRUE(GetWindowsKeyCode(ascii_character, &event.windows_key_code));
   SendWebKeyboardEvent(event);
 
-  event.SetType(blink::WebKeyboardEvent::kChar);
+  event.SetType(blink::WebKeyboardEvent::Type::kChar);
   SendWebKeyboardEvent(event);
 
-  event.SetType(blink::WebKeyboardEvent::kKeyUp);
+  event.SetType(blink::WebKeyboardEvent::Type::kKeyUp);
   SendWebKeyboardEvent(event);
 
   if (flush_message_loop) {

content/renderer/gpu_benchmarking_extension.cc

@@ -336,7 +336,7 @@ bool BeginSmoothScroll(GpuBenchmarkingContext* context,
     // Ensure the mouse is visible and move to start position, in case it will
     // trigger any hover or mousemove effects.
     context->web_view()->SetIsActive(true);
-    blink::WebMouseEvent mouseMove(blink::WebInputEvent::kMouseMove,
+    blink::WebMouseEvent mouseMove(blink::WebInputEvent::Type::kMouseMove,
                                    blink::WebInputEvent::kNoModifiers,
                                    ui::EventTimeForNow());
     mouseMove.SetPositionInWidget(start_x, start_y);

content/renderer/pepper/event_conversion.cc

@@ -95,40 +95,40 @@ static_assert(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISRIGHT) ==
 
 PP_InputEvent_Type ConvertEventTypes(const WebInputEvent& event) {
   switch (event.GetType()) {
-    case WebInputEvent::kMouseDown:
+    case WebInputEvent::Type::kMouseDown:
       return PP_INPUTEVENT_TYPE_MOUSEDOWN;
-    case WebInputEvent::kMouseUp:
+    case WebInputEvent::Type::kMouseUp:
       return PP_INPUTEVENT_TYPE_MOUSEUP;
-    case WebInputEvent::kMouseMove:
+    case WebInputEvent::Type::kMouseMove:
       return PP_INPUTEVENT_TYPE_MOUSEMOVE;
-    case WebInputEvent::kMouseEnter:
+    case WebInputEvent::Type::kMouseEnter:
       return PP_INPUTEVENT_TYPE_MOUSEENTER;
-    case WebInputEvent::kMouseLeave:
+    case WebInputEvent::Type::kMouseLeave:
       return PP_INPUTEVENT_TYPE_MOUSELEAVE;
-    case WebInputEvent::kContextMenu:
+    case WebInputEvent::Type::kContextMenu:
       return PP_INPUTEVENT_TYPE_CONTEXTMENU;
-    case WebInputEvent::kMouseWheel:
+    case WebInputEvent::Type::kMouseWheel:
       return PP_INPUTEVENT_TYPE_WHEEL;
-    case WebInputEvent::kRawKeyDown:
+    case WebInputEvent::Type::kRawKeyDown:
       // In the past blink has always returned kKeyDown passed into plugins
       // although PPAPI had a RAWKEYDOWN definition. However implementations are
       // broken now that blink passes kRawKeyDown so convert it to a keydown.
       return PP_INPUTEVENT_TYPE_KEYDOWN;
-    case WebInputEvent::kKeyDown:
+    case WebInputEvent::Type::kKeyDown:
       return PP_INPUTEVENT_TYPE_KEYDOWN;
-    case WebInputEvent::kKeyUp:
+    case WebInputEvent::Type::kKeyUp:
       return PP_INPUTEVENT_TYPE_KEYUP;
-    case WebInputEvent::kChar:
+    case WebInputEvent::Type::kChar:
       return PP_INPUTEVENT_TYPE_CHAR;
-    case WebInputEvent::kTouchStart:
+    case WebInputEvent::Type::kTouchStart:
       return PP_INPUTEVENT_TYPE_TOUCHSTART;
-    case WebInputEvent::kTouchMove:
+    case WebInputEvent::Type::kTouchMove:
       return PP_INPUTEVENT_TYPE_TOUCHMOVE;
-    case WebInputEvent::kTouchEnd:
+    case WebInputEvent::Type::kTouchEnd:
       return PP_INPUTEVENT_TYPE_TOUCHEND;
-    case WebInputEvent::kTouchCancel:
+    case WebInputEvent::Type::kTouchCancel:
       return PP_INPUTEVENT_TYPE_TOUCHCANCEL;
-    case WebInputEvent::kUndefined:
+    case WebInputEvent::Type::kUndefined:
     default:
       return PP_INPUTEVENT_TYPE_UNDEFINED;
   }
@@ -220,9 +220,9 @@ void AppendMouseEvent(const WebInputEvent& event,
   const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = ConvertEventModifiers(mouse_event.GetModifiers());
-  if (mouse_event.GetType() == WebInputEvent::kMouseDown ||
-      mouse_event.GetType() == WebInputEvent::kMouseMove ||
-      mouse_event.GetType() == WebInputEvent::kMouseUp) {
+  if (mouse_event.GetType() == WebInputEvent::Type::kMouseDown ||
+      mouse_event.GetType() == WebInputEvent::Type::kMouseMove ||
+      mouse_event.GetType() == WebInputEvent::Type::kMouseUp) {
     switch (mouse_event.button) {
       case WebMouseEvent::Button::kNoButton:
       case WebMouseEvent::Button::kLeft:
@@ -240,7 +240,7 @@ void AppendMouseEvent(const WebInputEvent& event,
   result.mouse_click_count = mouse_event.click_count;
 
   if (base::FeatureList::IsEnabled(features::kConsolidatedMovementXY)) {
-    if (mouse_event.GetType() == WebInputEvent::kMouseMove &&
+    if (mouse_event.GetType() == WebInputEvent::Type::kMouseMove &&
         *in_out_last_mouse_position) {
       result.mouse_movement.x = mouse_event.PositionInScreen().x() -
                                 (*in_out_last_mouse_position)->x();
@@ -292,13 +292,13 @@ void SetPPTouchPoints(const WebTouchPoint* touches,
   for (uint32_t i = 0; i < touches_length; i++) {
     const WebTouchPoint& touch_point = touches[i];
     if (included_types == ACTIVE &&
-        (touch_point.state == WebTouchPoint::kStateReleased ||
-         touch_point.state == WebTouchPoint::kStateCancelled)) {
+        (touch_point.state == WebTouchPoint::State::kStateReleased ||
+         touch_point.state == WebTouchPoint::State::kStateCancelled)) {
       continue;
     }
     if (included_types == CHANGED &&
-        (touch_point.state == WebTouchPoint::kStateUndefined ||
-         touch_point.state == WebTouchPoint::kStateStationary)) {
+        (touch_point.state == WebTouchPoint::State::kStateUndefined ||
+         touch_point.state == WebTouchPoint::State::kStateStationary)) {
       continue;
     }
     PP_TouchPoint pp_pt;
@@ -397,24 +397,24 @@ void SetWebTouchPointsIfNotYetSet(
 
 WebTouchEvent* BuildTouchEvent(const InputEventData& event) {
   WebTouchEvent* web_event = new WebTouchEvent();
-  WebTouchPoint::State state = WebTouchPoint::kStateUndefined;
-  WebInputEvent::Type type = WebInputEvent::kUndefined;
+  WebTouchPoint::State state = WebTouchPoint::State::kStateUndefined;
+  WebInputEvent::Type type = WebInputEvent::Type::kUndefined;
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_TOUCHSTART:
-      type = WebInputEvent::kTouchStart;
-      state = WebTouchPoint::kStatePressed;
+      type = WebInputEvent::Type::kTouchStart;
+      state = WebTouchPoint::State::kStatePressed;
       break;
     case PP_INPUTEVENT_TYPE_TOUCHMOVE:
-      type = WebInputEvent::kTouchMove;
-      state = WebTouchPoint::kStateMoved;
+      type = WebInputEvent::Type::kTouchMove;
+      state = WebTouchPoint::State::kStateMoved;
       break;
     case PP_INPUTEVENT_TYPE_TOUCHEND:
-      type = WebInputEvent::kTouchEnd;
-      state = WebTouchPoint::kStateReleased;
+      type = WebInputEvent::Type::kTouchEnd;
+      state = WebTouchPoint::State::kStateReleased;
       break;
     case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
-      type = WebInputEvent::kTouchCancel;
-      state = WebTouchPoint::kStateCancelled;
+      type = WebInputEvent::Type::kTouchCancel;
+      state = WebTouchPoint::State::kStateCancelled;
       break;
     default:
       NOTREACHED();
@@ -429,7 +429,8 @@ WebTouchEvent* BuildTouchEvent(const InputEventData& event) {
   // (stationary) touches.
   SetWebTouchPointsIfNotYetSet(event.changed_touches, state, web_event->touches,
                                &web_event->touches_length);
-  SetWebTouchPointsIfNotYetSet(event.touches, WebTouchPoint::kStateStationary,
+  SetWebTouchPointsIfNotYetSet(event.touches,
+                               WebTouchPoint::State::kStateStationary,
                                web_event->touches, &web_event->touches_length);
 
   return web_event;
@@ -439,13 +440,13 @@ WebKeyboardEvent* BuildKeyEvent(const InputEventData& event) {
   WebInputEvent::Type type = WebInputEvent::Type::kUndefined;
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
-      type = WebInputEvent::kRawKeyDown;
+      type = WebInputEvent::Type::kRawKeyDown;
       break;
     case PP_INPUTEVENT_TYPE_KEYDOWN:
-      type = WebInputEvent::kKeyDown;
+      type = WebInputEvent::Type::kKeyDown;
       break;
     case PP_INPUTEVENT_TYPE_KEYUP:
-      type = WebInputEvent::kKeyUp;
+      type = WebInputEvent::Type::kKeyUp;
       break;
     default:
       NOTREACHED();
@@ -460,7 +461,7 @@ WebKeyboardEvent* BuildKeyEvent(const InputEventData& event) {
 
 WebKeyboardEvent* BuildCharEvent(const InputEventData& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent(
-      WebInputEvent::kChar, event.event_modifiers,
+      WebInputEvent::Type::kChar, event.event_modifiers,
       base::TimeTicks() +
           base::TimeDelta::FromSecondsD(event.event_time_stamp));
 
@@ -477,25 +478,25 @@ WebKeyboardEvent* BuildCharEvent(const InputEventData& event) {
 }
 
 WebMouseEvent* BuildMouseEvent(const InputEventData& event) {
-  WebInputEvent::Type type = WebInputEvent::kUndefined;
+  WebInputEvent::Type type = WebInputEvent::Type::kUndefined;
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
-      type = WebInputEvent::kMouseDown;
+      type = WebInputEvent::Type::kMouseDown;
       break;
     case PP_INPUTEVENT_TYPE_MOUSEUP:
-      type = WebInputEvent::kMouseUp;
+      type = WebInputEvent::Type::kMouseUp;
       break;
     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
-      type = WebInputEvent::kMouseMove;
+      type = WebInputEvent::Type::kMouseMove;
       break;
     case PP_INPUTEVENT_TYPE_MOUSEENTER:
-      type = WebInputEvent::kMouseEnter;
+      type = WebInputEvent::Type::kMouseEnter;
       break;
     case PP_INPUTEVENT_TYPE_MOUSELEAVE:
-      type = WebInputEvent::kMouseLeave;
+      type = WebInputEvent::Type::kMouseLeave;
       break;
     case PP_INPUTEVENT_TYPE_CONTEXTMENU:
-      type = WebInputEvent::kContextMenu;
+      type = WebInputEvent::Type::kContextMenu;
       break;
     default:
       NOTREACHED();
@@ -506,7 +507,7 @@ WebMouseEvent* BuildMouseEvent(const InputEventData& event) {
           base::TimeDelta::FromSecondsD(event.event_time_stamp));
   mouse_event->pointer_type = blink::WebPointerProperties::PointerType::kMouse;
   mouse_event->button = static_cast<WebMouseEvent::Button>(event.mouse_button);
-  if (mouse_event->GetType() == WebInputEvent::kMouseMove) {
+  if (mouse_event->GetType() == WebInputEvent::Type::kMouseMove) {
     if (mouse_event->GetModifiers() & WebInputEvent::kLeftButtonDown)
       mouse_event->button = WebMouseEvent::Button::kLeft;
     else if (mouse_event->GetModifiers() & WebInputEvent::kMiddleButtonDown)
@@ -524,7 +525,7 @@ WebMouseEvent* BuildMouseEvent(const InputEventData& event) {
 
 WebMouseWheelEvent* BuildMouseWheelEvent(const InputEventData& event) {
   WebMouseWheelEvent* mouse_wheel_event = new WebMouseWheelEvent(
-      WebInputEvent::kMouseWheel, event.event_modifiers,
+      WebInputEvent::Type::kMouseWheel, event.event_modifiers,
       base::TimeTicks() +
           base::TimeDelta::FromSecondsD(event.event_time_stamp));
   mouse_wheel_event->delta_x = event.wheel_delta.x;
@@ -630,32 +631,32 @@ void CreateInputEventData(
   result->clear();
 
   switch (event.GetType()) {
-    case WebInputEvent::kMouseDown:
-    case WebInputEvent::kMouseUp:
-    case WebInputEvent::kMouseMove:
-    case WebInputEvent::kMouseEnter:
-    case WebInputEvent::kMouseLeave:
-    case WebInputEvent::kContextMenu:
+    case WebInputEvent::Type::kMouseDown:
+    case WebInputEvent::Type::kMouseUp:
+    case WebInputEvent::Type::kMouseMove:
+    case WebInputEvent::Type::kMouseEnter:
+    case WebInputEvent::Type::kMouseLeave:
+    case WebInputEvent::Type::kContextMenu:
       AppendMouseEvent(event, in_out_last_mouse_position, result);
       break;
-    case WebInputEvent::kMouseWheel:
+    case WebInputEvent::Type::kMouseWheel:
       AppendMouseWheelEvent(event, result);
       break;
-    case WebInputEvent::kRawKeyDown:
-    case WebInputEvent::kKeyDown:
-    case WebInputEvent::kKeyUp:
+    case WebInputEvent::Type::kRawKeyDown:
+    case WebInputEvent::Type::kKeyDown:
+    case WebInputEvent::Type::kKeyUp:
       AppendKeyEvent(event, result);
       break;
-    case WebInputEvent::kChar:
+    case WebInputEvent::Type::kChar:
       AppendCharEvent(event, result);
       break;
-    case WebInputEvent::kTouchStart:
-    case WebInputEvent::kTouchMove:
-    case WebInputEvent::kTouchEnd:
-    case WebInputEvent::kTouchCancel:
+    case WebInputEvent::Type::kTouchStart:
+    case WebInputEvent::Type::kTouchMove:
+    case WebInputEvent::Type::kTouchEnd:
+    case WebInputEvent::Type::kTouchCancel:
       AppendTouchEvent(event, result);
       break;
-    case WebInputEvent::kUndefined:
+    case WebInputEvent::Type::kUndefined:
     default:
       break;
   }
@@ -729,7 +730,8 @@ std::vector<std::unique_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
           static_cast<blink::WebTouchEvent*>(original_event.get());
       for (unsigned i = 0; i < touch_event->touches_length; ++i) {
         const blink::WebTouchPoint& touch_point = touch_event->touches[i];
-        if (touch_point.state != blink::WebTouchPoint::kStateStationary) {
+        if (touch_point.state !=
+            blink::WebTouchPoint::State::kStateStationary) {
           events.push_back(
               std::make_unique<WebPointerEvent>(*touch_event, touch_point));
         }
@@ -750,8 +752,8 @@ std::vector<std::unique_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
 #if defined(OS_WIN)
       WebKeyboardEvent* web_keyboard_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
-      if (web_keyboard_event->GetType() == WebInputEvent::kKeyDown)
-        web_keyboard_event->SetType(WebInputEvent::kRawKeyDown);
+      if (web_keyboard_event->GetType() == WebInputEvent::Type::kKeyDown)
+        web_keyboard_event->SetType(WebInputEvent::Type::kRawKeyDown);
 #endif
       events.push_back(std::move(original_event));
       break;
@@ -771,7 +773,7 @@ std::vector<std::unique_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
 
       // Synthesize key down and key up events in all cases.
       std::unique_ptr<WebKeyboardEvent> key_down_event(new WebKeyboardEvent(
-          WebInputEvent::kRawKeyDown,
+          WebInputEvent::Type::kRawKeyDown,
           needs_shift_modifier ? WebInputEvent::kShiftKey
                                : WebInputEvent::kNoModifiers,
           web_char_event->TimeStamp()));
@@ -791,11 +793,11 @@ std::vector<std::unique_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
       events.push_back(std::move(key_down_event));
 
       if (generate_char) {
-        web_char_event->SetType(WebInputEvent::kChar);
+        web_char_event->SetType(WebInputEvent::Type::kChar);
         events.push_back(std::move(original_event));
       }
 
-      key_up_event->SetType(WebInputEvent::kKeyUp);
+      key_up_event->SetType(WebInputEvent::Type::kKeyUp);
       events.push_back(std::move(key_up_event));
       break;
     }
@@ -808,26 +810,26 @@ std::vector<std::unique_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
 
 PP_InputEvent_Class ClassifyInputEvent(const WebInputEvent& event) {
   switch (event.GetType()) {
-    case WebInputEvent::kMouseDown:
-    case WebInputEvent::kMouseUp:
-    case WebInputEvent::kMouseMove:
-    case WebInputEvent::kMouseEnter:
-    case WebInputEvent::kMouseLeave:
-    case WebInputEvent::kContextMenu:
+    case WebInputEvent::Type::kMouseDown:
+    case WebInputEvent::Type::kMouseUp:
+    case WebInputEvent::Type::kMouseMove:
+    case WebInputEvent::Type::kMouseEnter:
+    case WebInputEvent::Type::kMouseLeave:
+    case WebInputEvent::Type::kContextMenu:
       return PP_INPUTEVENT_CLASS_MOUSE;
-    case WebInputEvent::kMouseWheel:
+    case WebInputEvent::Type::kMouseWheel:
       return PP_INPUTEVENT_CLASS_WHEEL;
-    case WebInputEvent::kRawKeyDown:
-    case WebInputEvent::kKeyDown:
-    case WebInputEvent::kKeyUp:
-    case WebInputEvent::kChar:
+    case WebInputEvent::Type::kRawKeyDown:
+    case WebInputEvent::Type::kKeyDown:
+    case WebInputEvent::Type::kKeyUp:
+    case WebInputEvent::Type::kChar:
       return PP_INPUTEVENT_CLASS_KEYBOARD;
-    case WebInputEvent::kTouchCancel:
-    case WebInputEvent::kTouchEnd:
-    case WebInputEvent::kTouchMove:
-    case WebInputEvent::kTouchStart:
+    case WebInputEvent::Type::kTouchCancel:
+    case WebInputEvent::Type::kTouchEnd:
+    case WebInputEvent::Type::kTouchMove:
+    case WebInputEvent::Type::kTouchStart:
       return PP_INPUTEVENT_CLASS_TOUCH;
-    case WebInputEvent::kTouchScrollStarted:
+    case WebInputEvent::Type::kTouchScrollStarted:
       return PP_InputEvent_Class(0);
     default:
       CHECK(WebInputEvent::IsGestureEventType(event.GetType()));

content/renderer/pepper/event_conversion_unittest.cc

@@ -155,7 +155,7 @@ TEST_F(EventConversionTest, TouchCancel) {
 TEST_F(EventConversionTest, MouseMove) {
   std::unique_ptr<gfx::PointF> last_mouse_position;
   blink::WebMouseEvent mouse_event = SyntheticWebMouseEventBuilder::Build(
-      blink::WebInputEvent::kMouseMove, 100, 200, 0);
+      blink::WebInputEvent::Type::kMouseMove, 100, 200, 0);
 
   std::vector<ppapi::InputEventData> pp_events;
   CreateInputEventData(mouse_event, &last_mouse_position, &pp_events);
@@ -172,7 +172,7 @@ TEST_F(EventConversionTest, MouseMove) {
   }
 
   mouse_event = SyntheticWebMouseEventBuilder::Build(
-      blink::WebInputEvent::kMouseMove, 123, 188, 0);
+      blink::WebInputEvent::Type::kMouseMove, 123, 188, 0);
   CreateInputEventData(mouse_event, &last_mouse_position, &pp_events);
   ASSERT_EQ(PP_INPUTEVENT_TYPE_MOUSEMOVE, pp_event.event_type);
   ASSERT_EQ(pp_event.mouse_position.x, mouse_event.PositionInWidget().x());

content/renderer/pepper/pepper_plugin_instance_impl.cc

@@ -328,8 +328,8 @@ std::unique_ptr<const char* []> StringVectorToArgArray(
 // for things like screen brightness and volume control.
 bool IsReservedSystemInputEvent(const blink::WebInputEvent& event) {
 #if defined(OS_CHROMEOS)
-  if (event.GetType() != WebInputEvent::kKeyDown &&
-      event.GetType() != WebInputEvent::kKeyUp)
+  if (event.GetType() != WebInputEvent::Type::kKeyDown &&
+      event.GetType() != WebInputEvent::Type::kKeyUp)
     return false;
   const blink::WebKeyboardEvent& key_event =
       static_cast<const blink::WebKeyboardEvent&>(event);
@@ -1109,7 +1109,7 @@ bool PepperPluginInstanceImpl::HandleInputEvent(
     return false;
 
   if (!has_been_clicked_ && is_flash_plugin_ &&
-      event.GetType() == blink::WebInputEvent::kMouseDown &&
+      event.GetType() == blink::WebInputEvent::Type::kMouseDown &&
       (event.GetModifiers() & blink::WebInputEvent::kLeftButtonDown)) {
     has_been_clicked_ = true;
   }

content/renderer/pepper/plugin_instance_throttler_impl.cc

@@ -206,7 +206,7 @@ bool PluginInstanceThrottlerImpl::ConsumeInputEvent(
     return false;
 
   if (state_ != THROTTLER_STATE_MARKED_ESSENTIAL &&
-      event.GetType() == blink::WebInputEvent::kMouseUp &&
+      event.GetType() == blink::WebInputEvent::Type::kMouseUp &&
       (event.GetModifiers() & blink::WebInputEvent::kLeftButtonDown)) {
     bool was_throttled = IsThrottled();
     MarkPluginEssential(UNTHROTTLE_METHOD_BY_CLICK);

content/renderer/render_frame_impl.cc

@@ -6418,7 +6418,7 @@ void RenderFrameImpl::HandlePepperImeCommit(const base::string16& text) {
     base::i18n::UTF16CharIterator iterator(&text);
     int32_t i = 0;
     while (iterator.Advance()) {
-      blink::WebKeyboardEvent char_event(blink::WebInputEvent::kChar,
+      blink::WebKeyboardEvent char_event(blink::WebInputEvent::Type::kChar,
                                          blink::WebInputEvent::kNoModifiers,
                                          ui::EventTimeForNow());
       char_event.windows_key_code = text[i];

content/renderer/render_view_browsertest.cc

@@ -1785,7 +1785,7 @@ TEST_F(RenderViewImplTest, ContextMenu) {
 
   // Create a right click in the center of the iframe. (I'm hoping this will
   // make this a bit more robust in case of some other formatting or other bug.)
-  WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
+  WebMouseEvent mouse_event(WebInputEvent::Type::kMouseDown,
                             WebInputEvent::kNoModifiers, ui::EventTimeForNow());
   mouse_event.button = WebMouseEvent::Button::kRight;
   mouse_event.SetPositionInWidget(250, 250);
@@ -1794,7 +1794,7 @@ TEST_F(RenderViewImplTest, ContextMenu) {
   SendWebMouseEvent(mouse_event);
 
   // Now simulate the corresponding up event which should display the menu
-  mouse_event.SetType(WebInputEvent::kMouseUp);
+  mouse_event.SetType(WebInputEvent::Type::kMouseUp);
   SendWebMouseEvent(mouse_event);
 
   EXPECT_TRUE(render_thread_->sink().GetUniqueMessageMatching(
@@ -1811,7 +1811,7 @@ TEST_F(RenderViewImplTest, AndroidContextMenuSelectionOrdering) {
 
   // Create a long press in the center of the iframe. (I'm hoping this will
   // make this a bit more robust in case of some other formatting or other bug.)
-  WebGestureEvent gesture_event(WebInputEvent::kGestureLongPress,
+  WebGestureEvent gesture_event(WebInputEvent::Type::kGestureLongPress,
                                 WebInputEvent::kNoModifiers,
                                 ui::EventTimeForNow());
   gesture_event.SetPositionInWidget(gfx::PointF(250, 250));

content/renderer/render_widget.cc

@@ -2521,9 +2521,9 @@ void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
   }
 
 #if defined(OS_ANDROID) || defined(USE_AURA)
-  if (event.GetType() == WebInputEvent::kGestureTap) {
+  if (event.GetType() == WebInputEvent::Type::kGestureTap) {
     ShowVirtualKeyboard();
-  } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
+  } else if (event.GetType() == WebInputEvent::Type::kGestureLongPress) {
     DCHECK(GetWebWidget());
     blink::WebInputMethodController* controller = GetInputMethodController();
     if (!controller || controller->TextInputInfo().value.IsEmpty())

content/renderer/render_widget_fullscreen_pepper.cc

@@ -71,23 +71,23 @@ WebMouseEvent WebMouseEventFromGestureEvent(const WebGestureEvent& gesture) {
   if (gesture.SourceDevice() != blink::WebGestureDevice::kTouchscreen)
     return WebMouseEvent();
 
-  WebInputEvent::Type type = WebInputEvent::kUndefined;
+  WebInputEvent::Type type = WebInputEvent::Type::kUndefined;
   switch (gesture.GetType()) {
-    case WebInputEvent::kGestureScrollBegin:
-      type = WebInputEvent::kMouseDown;
+    case WebInputEvent::Type::kGestureScrollBegin:
+      type = WebInputEvent::Type::kMouseDown;
       break;
-    case WebInputEvent::kGestureScrollUpdate:
-      type = WebInputEvent::kMouseMove;
+    case WebInputEvent::Type::kGestureScrollUpdate:
+      type = WebInputEvent::Type::kMouseMove;
       break;
-    case WebInputEvent::kGestureFlingStart:
+    case WebInputEvent::Type::kGestureFlingStart:
       // A scroll gesture on the touchscreen may end with a GestureScrollEnd
       // when there is no velocity, or a GestureFlingStart when it has a
       // velocity. In both cases, it should end the drag that was initiated by
       // the GestureScrollBegin (and subsequent GestureScrollUpdate) events.
-      type = WebInputEvent::kMouseUp;
+      type = WebInputEvent::Type::kMouseUp;
       break;
-    case WebInputEvent::kGestureScrollEnd:
-      type = WebInputEvent::kMouseUp;
+    case WebInputEvent::Type::kGestureScrollEnd:
+      type = WebInputEvent::Type::kMouseUp;
       break;
     default:
       return WebMouseEvent();
@@ -97,8 +97,8 @@ WebMouseEvent WebMouseEventFromGestureEvent(const WebGestureEvent& gesture) {
                       gesture.GetModifiers() | WebInputEvent::kLeftButtonDown,
                       gesture.TimeStamp());
   mouse.button = WebMouseEvent::Button::kLeft;
-  mouse.click_count = (mouse.GetType() == WebInputEvent::kMouseDown ||
-                       mouse.GetType() == WebInputEvent::kMouseUp);
+  mouse.click_count = (mouse.GetType() == WebInputEvent::Type::kMouseDown ||
+                       mouse.GetType() == WebInputEvent::Type::kMouseUp);
 
   mouse.SetPositionInWidget(gesture.PositionInWidget());
   mouse.SetPositionInScreen(gesture.PositionInScreen());
@@ -311,8 +311,8 @@ WebInputEventResult RenderWidgetFullscreenPepper::ProcessInputEvent(
     const WebGestureEvent* gesture_event =
         static_cast<const WebGestureEvent*>(&event);
     switch (event.GetType()) {
-      case WebInputEvent::kGestureTap: {
-        WebMouseEvent mouse(WebInputEvent::kMouseMove,
+      case WebInputEvent::Type::kGestureTap: {
+        WebMouseEvent mouse(WebInputEvent::Type::kMouseMove,
                             gesture_event->GetModifiers(),
                             gesture_event->TimeStamp());
         mouse.SetPositionInWidget(gesture_event->PositionInWidget());
@@ -321,19 +321,19 @@ WebInputEventResult RenderWidgetFullscreenPepper::ProcessInputEvent(
         mouse.movement_y = 0;
         result |= plugin()->HandleInputEvent(mouse, &cursor);
 
-        mouse.SetType(WebInputEvent::kMouseDown);
+        mouse.SetType(WebInputEvent::Type::kMouseDown);
         mouse.button = WebMouseEvent::Button::kLeft;
         mouse.click_count = gesture_event->data.tap.tap_count;
         result |= plugin()->HandleInputEvent(mouse, &cursor);
 
-        mouse.SetType(WebInputEvent::kMouseUp);
+        mouse.SetType(WebInputEvent::Type::kMouseUp);
         result |= plugin()->HandleInputEvent(mouse, &cursor);
         break;
       }
 
       default: {
         WebMouseEvent mouse = WebMouseEventFromGestureEvent(*gesture_event);
-        if (mouse.GetType() != WebInputEvent::kUndefined)
+        if (mouse.GetType() != WebInputEvent::Type::kUndefined)
           result |= plugin()->HandleInputEvent(mouse, &cursor);
         break;
       }
@@ -355,22 +355,22 @@ WebInputEventResult RenderWidgetFullscreenPepper::ProcessInputEvent(
     // On Windows, we handle it on mouse up.
 #if defined(OS_WIN)
     send_context_menu_event =
-        mouse_event.GetType() == WebInputEvent::kMouseUp &&
+        mouse_event.GetType() == WebInputEvent::Type::kMouseUp &&
         mouse_event.button == WebMouseEvent::Button::kRight;
 #elif defined(OS_MACOSX)
     send_context_menu_event =
-        mouse_event.GetType() == WebInputEvent::kMouseDown &&
+        mouse_event.GetType() == WebInputEvent::Type::kMouseDown &&
         (mouse_event.button == WebMouseEvent::Button::kRight ||
          (mouse_event.button == WebMouseEvent::Button::kLeft &&
           mouse_event.GetModifiers() & WebMouseEvent::kControlKey));
 #else
     send_context_menu_event =
-        mouse_event.GetType() == WebInputEvent::kMouseDown &&
+        mouse_event.GetType() == WebInputEvent::Type::kMouseDown &&
         mouse_event.button == WebMouseEvent::Button::kRight;
 #endif
     if (send_context_menu_event) {
       WebMouseEvent context_menu_event(mouse_event);
-      context_menu_event.SetType(WebInputEvent::kContextMenu);
+      context_menu_event.SetType(WebInputEvent::Type::kContextMenu);
       plugin()->HandleInputEvent(context_menu_event, &cursor);
     }
   }

content/renderer/render_widget_unittest.cc

@@ -228,7 +228,7 @@ class InteractiveRenderWidget : public RenderWidget {
   // Overridden from RenderWidget:
   bool WillHandleGestureEvent(const blink::WebGestureEvent& event) override {
     if (always_overscroll_ &&
-        event.GetType() == blink::WebInputEvent::kGestureScrollUpdate) {
+        event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate) {
       DidOverscroll(gfx::Vector2dF(event.data.scroll_update.delta_x,
                                    event.data.scroll_update.delta_y),
                     gfx::Vector2dF(event.data.scroll_update.delta_x,
@@ -405,9 +405,9 @@ TEST_F(RenderWidgetExternalWidgetUnittest, EventOverscroll) {
       .WillRepeatedly(
           ::testing::Return(blink::WebInputEventResult::kNotHandled));
 
-  blink::WebGestureEvent scroll(blink::WebInputEvent::kGestureScrollUpdate,
-                                blink::WebInputEvent::kNoModifiers,
-                                ui::EventTimeForNow());
+  blink::WebGestureEvent scroll(
+      blink::WebInputEvent::Type::kGestureScrollUpdate,
+      blink::WebInputEvent::kNoModifiers, ui::EventTimeForNow());
   scroll.SetPositionInWidget(gfx::PointF(-10, 0));
   scroll.data.scroll_update.delta_y = 10;
   MockHandledEventCallback handled_event;

content/shell/test_runner/event_sender.cc

@@ -1375,7 +1375,7 @@ void EventSender::DoDragDrop(const WebDragData& drag_data,
   if (!MainFrameWidget())
     return;
 
-  WebMouseEvent event(WebInputEvent::kMouseDown,
+  WebMouseEvent event(WebInputEvent::Type::kMouseDown,
                       ModifiersForPointer(kRawMousePointerId),
                       GetCurrentEventTime());
   InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
@@ -1431,8 +1431,8 @@ void EventSender::PointerDown(int button_number,
     UpdateClickCountForButton(button_type);
     click_count = click_count_;
   }
-  WebMouseEvent event(WebInputEvent::kMouseDown, ModifiersForPointer(pointerId),
-                      GetCurrentEventTime());
+  WebMouseEvent event(WebInputEvent::Type::kMouseDown,
+                      ModifiersForPointer(pointerId), GetCurrentEventTime());
   InitMouseEventGeneric(current_pointer_state_[pointerId].pressed_button_,
                         current_pointer_state_[pointerId].current_buttons_,
                         current_pointer_state_[pointerId].last_pos_,
@@ -1472,8 +1472,8 @@ void EventSender::PointerUp(int button_number,
     current_pointer_state_[pointerId].pressed_button_ =
         WebMouseEvent::Button::kNoButton;
 
-    WebMouseEvent event(WebInputEvent::kMouseUp, ModifiersForPointer(pointerId),
-                        GetCurrentEventTime());
+    WebMouseEvent event(WebInputEvent::Type::kMouseUp,
+                        ModifiersForPointer(pointerId), GetCurrentEventTime());
     int click_count = pointerType == WebPointerProperties::PointerType::kMouse
                           ? click_count_
                           : 0;
@@ -1695,7 +1695,7 @@ void EventSender::KeyDown(const std::string& code_str,
   // On Windows, we might also need to generate a char event to mimic the
   // Windows event flow; on other platforms we create a merged event and test
   // the event flow that that platform provides.
-  WebKeyboardEvent event_down(WebInputEvent::kRawKeyDown, modifiers,
+  WebKeyboardEvent event_down(WebInputEvent::Type::kRawKeyDown, modifiers,
                               GetCurrentEventTime());
   event_down.windows_key_code = code;
   event_down.dom_key =
@@ -1712,7 +1712,7 @@ void EventSender::KeyDown(const std::string& code_str,
     event_down.is_system_key = IsSystemKeyEvent(event_down);
 
   WebKeyboardEvent event_up = event_down;
-  event_up.SetType(WebInputEvent::kKeyUp);
+  event_up.SetType(WebInputEvent::Type::kKeyUp);
   // EventSender.m forces a layout here, with at least one
   // test (fast/forms/focus-control-to-page.html) relying on this.
   if (force_layout_on_events_)
@@ -1729,7 +1729,7 @@ void EventSender::KeyDown(const std::string& code_str,
   HandleInputEventOnViewOrPopup(event_down);
 
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.IsNull()) {
-    WebMouseEvent event(WebInputEvent::kMouseDown,
+    WebMouseEvent event(WebInputEvent::Type::kMouseDown,
                         ModifiersForPointer(kRawMousePointerId),
                         GetCurrentEventTime());
     InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
@@ -1743,7 +1743,7 @@ void EventSender::KeyDown(const std::string& code_str,
 
   if (generate_char) {
     WebKeyboardEvent event_char = event_up;
-    event_char.SetType(WebInputEvent::kChar);
+    event_char.SetType(WebInputEvent::Type::kChar);
     HandleInputEventOnViewOrPopup(event_char);
   }
 
@@ -1780,7 +1780,7 @@ std::vector<std::string> EventSender::ContextClick() {
         GetWebMouseEventModifierForButton(
             current_pointer_state_[kRawMousePointerId].pressed_button_);
   }
-  WebMouseEvent event(WebInputEvent::kMouseDown,
+  WebMouseEvent event(WebInputEvent::Type::kMouseDown,
                       ModifiersForPointer(kRawMousePointerId),
                       GetCurrentEventTime());
   InitMouseEvent(WebMouseEvent::Button::kRight,
@@ -1795,7 +1795,7 @@ std::vector<std::string> EventSender::ContextClick() {
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
       WebMouseEvent::Button::kNoButton;
 
-  WebMouseEvent mouseUpEvent(WebInputEvent::kMouseUp,
+  WebMouseEvent mouseUpEvent(WebInputEvent::Type::kMouseUp,
                              ModifiersForPointer(kRawMousePointerId),
                              GetCurrentEventTime());
   InitMouseEvent(WebMouseEvent::Button::kRight,
@@ -1953,19 +1953,19 @@ void EventSender::GestureScrollFirstPoint(float x, float y) {
 }
 
 void EventSender::TouchStart(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::kTouchStart, args);
+  SendCurrentTouchEvent(WebInputEvent::Type::kTouchStart, args);
 }
 
 void EventSender::TouchMove(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::kTouchMove, args);
+  SendCurrentTouchEvent(WebInputEvent::Type::kTouchMove, args);
 }
 
 void EventSender::TouchCancel(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::kTouchCancel, args);
+  SendCurrentTouchEvent(WebInputEvent::Type::kTouchCancel, args);
 }
 
 void EventSender::TouchEnd(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::kTouchEnd, args);
+  SendCurrentTouchEvent(WebInputEvent::Type::kTouchEnd, args);
 }
 
 void EventSender::NotifyStartOfTouchScroll() {
@@ -2087,52 +2087,52 @@ void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
 
 void EventSender::GestureScrollBegin(blink::WebLocalFrame* frame,
                                      gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureScrollBegin, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureScrollBegin, frame, args);
 }
 
 void EventSender::GestureScrollEnd(blink::WebLocalFrame* frame,
                                    gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureScrollEnd, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureScrollEnd, frame, args);
 }
 
 void EventSender::GestureScrollUpdate(blink::WebLocalFrame* frame,
                                       gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureScrollUpdate, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureScrollUpdate, frame, args);
 }
 
 void EventSender::GestureTap(blink::WebLocalFrame* frame,
                              gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureTap, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureTap, frame, args);
 }
 
 void EventSender::GestureTapDown(blink::WebLocalFrame* frame,
                                  gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureTapDown, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureTapDown, frame, args);
 }
 
 void EventSender::GestureShowPress(blink::WebLocalFrame* frame,
                                    gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureShowPress, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureShowPress, frame, args);
 }
 
 void EventSender::GestureTapCancel(blink::WebLocalFrame* frame,
                                    gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureTapCancel, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureTapCancel, frame, args);
 }
 
 void EventSender::GestureLongPress(blink::WebLocalFrame* frame,
                                    gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureLongPress, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureLongPress, frame, args);
 }
 
 void EventSender::GestureLongTap(blink::WebLocalFrame* frame,
                                  gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureLongTap, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureLongTap, frame, args);
 }
 
 void EventSender::GestureTwoFingerTap(blink::WebLocalFrame* frame,
                                       gin::Arguments* args) {
-  GestureEvent(WebInputEvent::kGestureTwoFingerTap, frame, args);
+  GestureEvent(WebInputEvent::Type::kGestureTwoFingerTap, frame, args);
 }
 
 void EventSender::MouseScrollBy(gin::Arguments* args,
@@ -2143,7 +2143,7 @@ void EventSender::MouseScrollBy(gin::Arguments* args,
   bool send_gestures = true;
   WebMouseWheelEvent wheel_event =
       GetMouseWheelEvent(args, scroll_type, &send_gestures);
-  if (wheel_event.GetType() != WebInputEvent::kUndefined &&
+  if (wheel_event.GetType() != WebInputEvent::Type::kUndefined &&
       HandleInputEventOnViewOrPopup(wheel_event) ==
           WebInputEventResult::kNotHandled &&
       send_gestures) {
@@ -2208,7 +2208,7 @@ void EventSender::MouseMoveTo(blink::WebLocalFrame* frame,
   } else {
     current_pointer_state_[pointerId].last_pos_ = gfx::PointF(x, y);
     current_pointer_state_[pointerId].modifiers_ = modifiers;
-    WebMouseEvent event(WebInputEvent::kMouseMove,
+    WebMouseEvent event(WebInputEvent::Type::kMouseMove,
                         ModifiersForPointer(pointerId), GetCurrentEventTime());
     int click_count = pointerType == WebPointerProperties::PointerType::kMouse
                           ? click_count_
@@ -2230,7 +2230,7 @@ void EventSender::MouseLeave(
   if (force_layout_on_events_)
     UpdateLifecycleToPrePaint();
 
-  WebMouseEvent event(WebInputEvent::kMouseLeave,
+  WebMouseEvent event(WebInputEvent::Type::kMouseLeave,
                       ModifiersForPointer(pointerId), GetCurrentEventTime());
   InitMouseEventGeneric(WebMouseEvent::Button::kNoButton, 0,
                         current_pointer_state_[kRawMousePointerId].last_pos_,
@@ -2309,8 +2309,8 @@ void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
       pointer_event.SetTimeStamp(time_stamp);
       pointer_event.SetModifiers(touch_modifiers_);
       pointer_event.button =
-          (pointer_event.GetType() == WebInputEvent::kPointerDown ||
-           pointer_event.GetType() == WebInputEvent::kPointerUp)
+          (pointer_event.GetType() == WebInputEvent::Type::kPointerDown ||
+           pointer_event.GetType() == WebInputEvent::Type::kPointerUp)
               ? WebPointerProperties::Button::kLeft
               : WebPointerProperties::Button::kNoButton;
 
@@ -2386,7 +2386,7 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
   y += frame->GetPositionInViewportForTesting().y();
 
   switch (type) {
-    case WebInputEvent::kGestureScrollUpdate: {
+    case WebInputEvent::Type::kGestureScrollUpdate: {
       if (!GetScrollUnits(args, &event.data.scroll_update.delta_units))
         return;
 
@@ -2397,15 +2397,15 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
                                        event.data.scroll_update.delta_y);
       break;
     }
-    case WebInputEvent::kGestureScrollBegin:
+    case WebInputEvent::Type::kGestureScrollBegin:
       current_gesture_location_ = gfx::PointF(x, y);
       event.SetPositionInWidget(current_gesture_location_);
       break;
-    case WebInputEvent::kGestureScrollEnd:
-    case WebInputEvent::kGestureFlingStart:
+    case WebInputEvent::Type::kGestureScrollEnd:
+    case WebInputEvent::Type::kGestureFlingStart:
       event.SetPositionInWidget(current_gesture_location_);
       break;
-    case WebInputEvent::kGestureTap: {
+    case WebInputEvent::Type::kGestureTap: {
       float tap_count = 1;
       float width = 30;
       float height = 30;
@@ -2433,7 +2433,7 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
       event.SetPositionInWidget(gfx::PointF(x, y));
       break;
     }
-    case WebInputEvent::kGestureTapUnconfirmed:
+    case WebInputEvent::Type::kGestureTapUnconfirmed:
       if (!args->PeekNext().IsEmpty()) {
         float tap_count;
         if (!args->GetNext(&tap_count)) {
@@ -2446,7 +2446,7 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
       }
       event.SetPositionInWidget(gfx::PointF(x, y));
       break;
-    case WebInputEvent::kGestureTapDown: {
+    case WebInputEvent::Type::kGestureTapDown: {
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
@@ -2466,7 +2466,7 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
       event.data.tap_down.height = height;
       break;
     }
-    case WebInputEvent::kGestureShowPress: {
+    case WebInputEvent::Type::kGestureShowPress: {
       float width = 30;
       float height = 30;
       if (!args->PeekNext().IsEmpty()) {
@@ -2486,11 +2486,11 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
       event.data.show_press.height = height;
       break;
     }
-    case WebInputEvent::kGestureTapCancel:
+    case WebInputEvent::Type::kGestureTapCancel:
       event.SetPositionInWidget(gfx::PointF(x, y));
       break;
-    case WebInputEvent::kGestureLongPress:
-    case WebInputEvent::kGestureLongTap:
+    case WebInputEvent::Type::kGestureLongPress:
+    case WebInputEvent::Type::kGestureLongTap:
       event.SetPositionInWidget(gfx::PointF(x, y));
       if (!args->PeekNext().IsEmpty()) {
         float width;
@@ -2509,7 +2509,7 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
         }
       }
       break;
-    case WebInputEvent::kGestureTwoFingerTap:
+    case WebInputEvent::Type::kGestureTwoFingerTap:
       event.SetPositionInWidget(gfx::PointF(x, y));
       if (!args->PeekNext().IsEmpty()) {
         float first_finger_width;
@@ -2544,9 +2544,9 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
   WebInputEventResult result = HandleInputEventOnViewOrPopup(event);
 
   // Long press might start a drag drop session. Complete it if so.
-  if (type == WebInputEvent::kGestureLongPress &&
+  if (type == WebInputEvent::Type::kGestureLongPress &&
       !current_drag_data_.IsNull()) {
-    WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
+    WebMouseEvent mouse_event(WebInputEvent::Type::kMouseDown,
                               ModifiersForPointer(kRawMousePointerId),
                               GetCurrentEventTime());
 
@@ -2633,7 +2633,7 @@ WebMouseWheelEvent EventSender::GetMouseWheelEvent(gin::Arguments* args,
   }
 
   current_pointer_state_[kRawMousePointerId].modifiers_ = modifiers;
-  WebMouseWheelEvent event(WebInputEvent::kMouseWheel,
+  WebMouseWheelEvent event(WebInputEvent::Type::kMouseWheel,
                            ModifiersForPointer(kRawMousePointerId),
                            GetCurrentEventTime());
   InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
@@ -2770,7 +2770,7 @@ void EventSender::ReplaySavedEvents() {
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
-        WebMouseEvent event(WebInputEvent::kMouseMove,
+        WebMouseEvent event(WebInputEvent::Type::kMouseMove,
                             ModifiersForPointer(kRawMousePointerId),
                             GetCurrentEventTime());
         InitMouseEvent(
@@ -2793,7 +2793,7 @@ void EventSender::ReplaySavedEvents() {
             WebMouseEvent::Button::kNoButton;
         current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
 
-        WebMouseEvent event(WebInputEvent::kMouseUp,
+        WebMouseEvent event(WebInputEvent::Type::kMouseUp,
                             ModifiersForPointer(kRawMousePointerId),
                             GetCurrentEventTime());
         InitMouseEvent(
@@ -2826,7 +2826,7 @@ WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
-  WebGestureEvent begin_event(WebInputEvent::kGestureScrollBegin,
+  WebGestureEvent begin_event(WebInputEvent::Type::kGestureScrollBegin,
                               wheel_event.GetModifiers(), GetCurrentEventTime(),
                               blink::WebGestureDevice::kTouchpad);
   InitGestureEventFromMouseWheel(wheel_event, &begin_event);
@@ -2850,7 +2850,7 @@ void EventSender::SendGesturesForMouseWheelEvent(
   HandleInputEventOnViewOrPopup(begin_event);
 
   WebGestureEvent update_event(
-      WebInputEvent::kGestureScrollUpdate, wheel_event.GetModifiers(),
+      WebInputEvent::Type::kGestureScrollUpdate, wheel_event.GetModifiers(),
       GetCurrentEventTime(), blink::WebGestureDevice::kTouchpad);
   InitGestureEventFromMouseWheel(wheel_event, &update_event);
   update_event.data.scroll_update.delta_x =
@@ -2864,7 +2864,7 @@ void EventSender::SendGesturesForMouseWheelEvent(
     UpdateLifecycleToPrePaint();
   HandleInputEventOnViewOrPopup(update_event);
 
-  WebGestureEvent end_event(WebInputEvent::kGestureScrollEnd,
+  WebGestureEvent end_event(WebInputEvent::Type::kGestureScrollEnd,
                             wheel_event.GetModifiers(), GetCurrentEventTime(),
                             blink::WebGestureDevice::kTouchpad);
   InitGestureEventFromMouseWheel(wheel_event, &end_event);

content/shell/test_runner/test_plugin.cc

@@ -57,13 +57,13 @@ void PremultiplyAlpha(const uint8_t color_in[3],
 
 const char* PointState(blink::WebTouchPoint::State state) {
   switch (state) {
-    case blink::WebTouchPoint::kStateReleased:
+    case blink::WebTouchPoint::State::kStateReleased:
       return "Released";
-    case blink::WebTouchPoint::kStatePressed:
+    case blink::WebTouchPoint::State::kStatePressed:
       return "Pressed";
-    case blink::WebTouchPoint::kStateMoved:
+    case blink::WebTouchPoint::State::kStateMoved:
       return "Moved";
-    case blink::WebTouchPoint::kStateCancelled:
+    case blink::WebTouchPoint::State::kStateCancelled:
       return "Cancelled";
     default:
       return "Unknown";
@@ -87,7 +87,7 @@ void PrintEventDetails(BlinkTestRunner* blink_test_runner,
         static_cast<const blink::WebTouchEvent&>(event);
     PrintTouchList(blink_test_runner, touch.touches, touch.touches_length);
   } else if (blink::WebInputEvent::IsMouseEventType(event.GetType()) ||
-             event.GetType() == blink::WebInputEvent::kMouseWheel) {
+             event.GetType() == blink::WebInputEvent::Type::kMouseWheel) {
     const blink::WebMouseEvent& mouse =
         static_cast<const blink::WebMouseEvent&>(event);
     blink_test_runner->PrintMessage(

content/shell/test_runner/text_input_controller.cc

@@ -371,7 +371,7 @@ std::vector<int> TextInputController::FirstRectForCharacterRange(
 void TextInputController::SetComposition(const std::string& text) {
   // Sends a keydown event with key code = 0xE5 to emulate input method
   // behavior.
-  blink::WebKeyboardEvent key_down(blink::WebInputEvent::kRawKeyDown,
+  blink::WebKeyboardEvent key_down(blink::WebInputEvent::Type::kRawKeyDown,
                                    blink::WebInputEvent::kNoModifiers,
                                    ui::EventTimeForNow());