Collapse the API surface on WebInputEvent via accessor functions.

Move type, size, timeStampSeconds and modifiers to be private members.
This change will help harden the API so that we can place DCHECKS on
certain states.

Design: https://docs.google.com/document/d/1s4Lfy22CNU1OZ5Rec6Oano_5BvIhdK6uFVsVe7FphKI/edit

BUG=625684
TBR=jochen@chromium.org, wez@chromium.org, thestig@chromium.org, sadrul@chromium.org, rockot@chromium.org, dcheng@chromium.org, girard@chromium.org
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_site_isolation

Review-Url: https://codereview.chromium.org/2573073003
Cr-Commit-Position: refs/heads/master@{#443407}

blimp/client/core/input/blimp_input_handler_wrapper.cc

@@ -101,7 +101,7 @@ void BlimpInputHandlerWrapper::DispatchNonBlockingEventToMainThread(
     blink::WebScopedInputEvent event,
     const ui::LatencyInfo& latency_info) {
   DCHECK(compositor_thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(event->type, blink::WebInputEvent::MouseWheel);
+  DCHECK_EQ(event->type(), blink::WebInputEvent::MouseWheel);
 
   NOTIMPLEMENTED()
       << "Dispatching Non Blocking Events to the engine is not supported";

blimp/client/core/input/blimp_input_manager.cc

@@ -79,8 +79,8 @@ void BlimpInputManager::OnGestureEvent(const ui::GestureEventData& gesture) {
   // to 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.type == blink::WebInputEvent::GestureTap &&
-      web_gesture.modifiers == blink::WebInputEvent::ShiftKey) {
+  if (web_gesture.type() == blink::WebInputEvent::GestureTap &&
+      web_gesture.modifiers() == blink::WebInputEvent::ShiftKey) {
     web_gesture.setModifiers(blink::WebInputEvent::NoModifiers);
   }
 

blimp/engine/session/tab.cc

@@ -167,7 +167,7 @@ void Tab::SendPageLoadStatusUpdate(PageLoadStatus load_status) {
 
 void Tab::OnWebGestureEvent(content::RenderWidgetHost* render_widget_host,
                             std::unique_ptr<blink::WebGestureEvent> event) {
-  TRACE_EVENT1("blimp", "Tab::OnWebGestureEvent", "type", event->type);
+  TRACE_EVENT1("blimp", "Tab::OnWebGestureEvent", "type", event->type());
   render_widget_host->ForwardGestureEvent(*event);
 }
 

blimp/net/input_message_generator.cc

@@ -19,7 +19,7 @@ void CommonWebGestureToProto(const blink::WebGestureEvent& event,
                              InputMessage::Type type,
                              InputMessage* proto) {
   proto->set_type(type);
-  proto->set_timestamp_seconds(event.timeStampSeconds);
+  proto->set_timestamp_seconds(event.timeStampSeconds());
 
   GestureCommon* common = proto->mutable_gesture_common();
   common->set_x(event.x);
@@ -152,7 +152,7 @@ std::unique_ptr<BlimpMessage> InputMessageGenerator::GenerateMessage(
   InputMessage* details;
   std::unique_ptr<BlimpMessage> message = CreateBlimpMessage(&details);
 
-  switch (event.type) {
+  switch (event.type()) {
     case blink::WebInputEvent::Type::GestureScrollBegin:
       GestureScrollBeginToProto(event, details);
       break;
@@ -215,7 +215,7 @@ std::unique_ptr<BlimpMessage> InputMessageGenerator::GenerateMessage(
     case blink::WebInputEvent::Type::TouchEnd:
     case blink::WebInputEvent::Type::TouchCancel:
     case blink::WebInputEvent::Type::TouchScrollStarted:
-      DVLOG(1) << "Unsupported WebInputEvent type " << event.type;
+      DVLOG(1) << "Unsupported WebInputEvent type " << event.type();
       return nullptr;
   }
 

blimp/net/input_message_unittest.cc

@@ -30,8 +30,8 @@ void ValidateWebGestureEventRoundTripping(const blink::WebGestureEvent& event) {
       processor.ProcessMessage(proto->input());
   EXPECT_NE(nullptr, new_event.get());
 
-  EXPECT_EQ(event.size, new_event->size);
-  EXPECT_EQ(0, memcmp(&event, new_event.get(), event.size));
+  EXPECT_EQ(event.size(), new_event->size());
+  EXPECT_EQ(0, memcmp(&event, new_event.get(), event.size()));
 }
 
 blink::WebGestureEvent BuildBaseTestEvent(blink::WebInputEvent::Type type) {

chrome/browser/android/vr_shell/vr_controller.cc

@@ -196,21 +196,21 @@ std::vector<std::unique_ptr<WebGestureEvent>> VrController::DetectGestures() {
   UpdateTouchInfo();
   UpdateGestureFromTouchInfo(gesture.get());
 
-  if (gesture->type == WebInputEvent::Undefined &&
+  if (gesture->type() == WebInputEvent::Undefined &&
       ButtonUpHappened(gvr::kControllerButtonClick)) {
-    gesture->type = WebInputEvent::GestureTapDown;
+    gesture->setType(WebInputEvent::GestureTapDown);
     gesture->x = 0;
     gesture->y = 0;
   }
   gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
   gesture_list.push_back(std::move(gesture));
 
-  if (gesture_list.back()->type == WebInputEvent::GestureScrollEnd) {
+  if (gesture_list.back()->type() == WebInputEvent::GestureScrollEnd) {
     if (!ButtonDownHappened(gvr::kControllerButtonClick)) {
-      std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent());
-      fling->timeStampSeconds = gesture_list.back()->timeStampSeconds;
+      std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent(
+          WebInputEvent::GestureFlingStart, WebInputEvent::NoModifiers,
+          gesture_list.back()->timeStampSeconds()));
       fling->sourceDevice = blink::WebGestureDeviceTouchpad;
-      fling->type = WebInputEvent::GestureFlingStart;
       if (IsHorizontalGesture()) {
         fling->data.flingStart.velocityX =
             overall_velocity_.x * kDisplacementScaleFactor;
@@ -227,8 +227,8 @@ std::vector<std::unique_ptr<WebGestureEvent>> VrController::DetectGestures() {
 }
 
 void VrController::UpdateGestureFromTouchInfo(WebGestureEvent* gesture) {
-  gesture->timeStampSeconds =
-      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+  gesture->setTimeStampSeconds(
+      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF());
   switch (state_) {
     // User has not put finger on touch pad.
     case WAITING:
@@ -258,7 +258,7 @@ void VrController::HandleWaitingState(WebGestureEvent* gesture) {
     *cur_touch_point_ = touch_info_->touch_point;
     state_ = TOUCHING;
 
-    gesture->type = WebInputEvent::GestureFlingCancel;
+    gesture->setType(WebInputEvent::GestureFlingCancel);
     gesture->data.flingCancel.preventBoosting = false;
   }
 }
@@ -276,7 +276,7 @@ void VrController::HandleDetectingState(WebGestureEvent* gesture) {
       !InSlop(touch_info_->touch_point.position) &&
       !ButtonDownHappened(gvr::kControllerButtonClick)) {
     state_ = SCROLLING;
-    gesture->type = WebInputEvent::GestureScrollBegin;
+    gesture->setType(WebInputEvent::GestureScrollBegin);
     UpdateGesture(gesture);
     gesture->data.scrollBegin.deltaXHint =
         displacement_.x * kDisplacementScaleFactor;
@@ -291,11 +291,11 @@ void VrController::HandleScrollingState(WebGestureEvent* gesture) {
   if (touch_info_->touch_up || !(touch_info_->is_touching) ||
       ButtonDownHappened(gvr::kControllerButtonClick)) {
     // Gesture ends.
-    gesture->type = WebInputEvent::GestureScrollEnd;
+    gesture->setType(WebInputEvent::GestureScrollEnd);
     UpdateGesture(gesture);
   } else if (touch_position_changed) {
     // User continues scrolling and there is a change in touch position.
-    gesture->type = WebInputEvent::GestureScrollUpdate;
+    gesture->setType(WebInputEvent::GestureScrollUpdate);
     UpdateGesture(gesture);
     if (IsHorizontalGesture()) {
       gesture->data.scrollUpdate.deltaX =

chrome/browser/android/vr_shell/vr_input_manager.cc

@@ -21,11 +21,9 @@ WebGestureEvent MakeGestureEvent(WebInputEvent::Type type,
                                  double time,
                                  float x,
                                  float y) {
-  WebGestureEvent result;
-  result.type = type;
+  WebGestureEvent result(type, WebInputEvent::NoModifiers, time);
   result.x = x;
   result.y = y;
-  result.timeStampSeconds = time;
   result.sourceDevice = blink::WebGestureDeviceTouchpad;
   return result;
 }
@@ -44,20 +42,20 @@ base::WeakPtr<VrInputManager> VrInputManager::GetWeakPtr() {
 
 void VrInputManager::ProcessUpdatedGesture(
     std::unique_ptr<blink::WebInputEvent> event) {
-  if (WebInputEvent::isMouseEventType(event->type)) {
+  if (WebInputEvent::isMouseEventType(event->type())) {
     ForwardMouseEvent(static_cast<const blink::WebMouseEvent&>(*event));
   } else {
     SendGesture(static_cast<const blink::WebGestureEvent&>(*event));
   }
 }
 
 void VrInputManager::SendGesture(const WebGestureEvent& gesture) {
-  if (gesture.type == WebGestureEvent::GestureTapDown) {
+  if (gesture.type() == WebGestureEvent::GestureTapDown) {
     ForwardGestureEvent(gesture);
 
     // Generate and forward Tap
     WebGestureEvent tap_event =
-        MakeGestureEvent(WebInputEvent::GestureTap, gesture.timeStampSeconds,
+        MakeGestureEvent(WebInputEvent::GestureTap, gesture.timeStampSeconds(),
                          gesture.x, gesture.y);
     tap_event.data.tap.tapCount = 1;
     ForwardGestureEvent(tap_event);

chrome/browser/android/vr_shell/vr_shell_gl.cc

@@ -121,16 +121,14 @@ std::unique_ptr<blink::WebMouseEvent> MakeMouseEvent(WebInputEvent::Type type,
                                                      double timestamp,
                                                      float x,
                                                      float y) {
-  std::unique_ptr<blink::WebMouseEvent> mouse_event(new blink::WebMouseEvent);
-  mouse_event->type = type;
+  std::unique_ptr<blink::WebMouseEvent> mouse_event(new blink::WebMouseEvent(
+      type, blink::WebInputEvent::NoModifiers, timestamp));
   mouse_event->pointerType = blink::WebPointerProperties::PointerType::Mouse;
   mouse_event->x = x;
   mouse_event->y = y;
   mouse_event->windowX = x;
   mouse_event->windowY = y;
-  mouse_event->timeStampSeconds = timestamp;
   mouse_event->clickCount = 1;
-  mouse_event->modifiers = 0;
 
   return mouse_event;
 }
@@ -417,11 +415,10 @@ void VrShellGl::UpdateController(const gvr::Vec3f& forward_vector) {
     if (touch_pending_ || controller_->ButtonUpHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
-      std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
+      std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent(
+          WebInputEvent::GestureTapDown, WebInputEvent::NoModifiers,
+          (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF()));
       gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
-      gesture->timeStampSeconds =
-          (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
-      gesture->type = WebInputEvent::GestureTapDown;
       gesture->x = 0;
       gesture->y = 0;
       SendGesture(InputTarget::CONTENT, std::move(gesture));
@@ -528,21 +525,20 @@ void VrShellGl::SendEventsToTarget(InputTarget input_target,
                                    int pixel_y) {
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list =
       controller_->DetectGestures();
-  double timestamp = gesture_list.front()->timeStampSeconds;
+  double timestamp = gesture_list.front()->timeStampSeconds();
 
   if (touch_pending_) {
     touch_pending_ = false;
-    std::unique_ptr<WebGestureEvent> event(new WebGestureEvent());
-    event->type = WebInputEvent::GestureTapDown;
+    std::unique_ptr<WebGestureEvent> event(new WebGestureEvent(
+        WebInputEvent::GestureTapDown, WebInputEvent::NoModifiers, timestamp));
     event->sourceDevice = blink::WebGestureDeviceTouchpad;
-    event->timeStampSeconds = timestamp;
     event->x = pixel_x;
     event->y = pixel_y;
     gesture_list.push_back(std::move(event));
   }
 
   for (const auto& gesture : gesture_list) {
-    switch (gesture->type) {
+    switch (gesture->type()) {
       case WebInputEvent::GestureScrollBegin:
       case WebInputEvent::GestureScrollUpdate:
       case WebInputEvent::GestureScrollEnd:

chrome/browser/chromeos/first_run/first_run_view.cc

@@ -63,9 +63,9 @@ bool FirstRunView::PreHandleGestureEvent(
     content::WebContents* source,
     const blink::WebGestureEvent& event) {
   // Disable pinch zooming.
-  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
-      event.type == blink::WebGestureEvent::GesturePinchUpdate ||
-      event.type == blink::WebGestureEvent::GesturePinchEnd;
+  return event.type() == blink::WebGestureEvent::GesturePinchBegin ||
+         event.type() == blink::WebGestureEvent::GesturePinchUpdate ||
+         event.type() == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 }  // namespace chromeos

chrome/browser/chromeos/input_method/textinput_test_helper.cc

@@ -196,15 +196,16 @@ bool TextInputTestHelper::ClickElement(const std::string& id,
   if (!ConvertRectFromString(coordinate, &rect))
     return false;
 
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.button = blink::WebMouseEvent::Button::Left;
   mouse_event.x = rect.CenterPoint().x();
   mouse_event.y = rect.CenterPoint().y();
   mouse_event.clickCount = 1;
   tab->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(mouse_event);
 
-  mouse_event.type = blink::WebInputEvent::MouseUp;
+  mouse_event.setType(blink::WebInputEvent::MouseUp);
   tab->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(mouse_event);
   return true;
 }

chrome/browser/chromeos/login/ui/webui_login_view.cc

@@ -529,7 +529,7 @@ void WebUILoginView::HandleKeyboardEvent(content::WebContents* source,
   // Make sure error bubble is cleared on keyboard event. This is needed
   // when the focus is inside an iframe. Only clear on KeyDown to prevent hiding
   // an immediate authentication error (See crbug.com/103643).
-  if (event.type == blink::WebInputEvent::KeyDown) {
+  if (event.type() == blink::WebInputEvent::KeyDown) {
     content::WebUI* web_ui = GetWebUI();
     if (web_ui)
       web_ui->CallJavascriptFunctionUnsafe("cr.ui.Oobe.clearErrors");
@@ -621,9 +621,9 @@ bool WebUILoginView::PreHandleGestureEvent(
     content::WebContents* source,
     const blink::WebGestureEvent& event) {
   // Disable pinch zooming.
-  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
-      event.type == blink::WebGestureEvent::GesturePinchUpdate ||
-      event.type == blink::WebGestureEvent::GesturePinchEnd;
+  return event.type() == blink::WebGestureEvent::GesturePinchBegin ||
+         event.type() == blink::WebGestureEvent::GesturePinchUpdate ||
+         event.type() == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 void WebUILoginView::OnLoginPromptVisible() {

chrome/browser/devtools/devtools_window.cc

@@ -274,7 +274,7 @@ void DevToolsEventForwarder::SetWhitelistedShortcuts(
 bool DevToolsEventForwarder::ForwardEvent(
     const content::NativeWebKeyboardEvent& event) {
   std::string event_type;
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::KeyDown:
     case WebInputEvent::RawKeyDown:
       event_type = kKeyDownEventName;
@@ -288,10 +288,9 @@ bool DevToolsEventForwarder::ForwardEvent(
 
   int key_code = ui::LocatedToNonLocatedKeyboardCode(
       static_cast<ui::KeyboardCode>(event.windowsKeyCode));
-  int modifiers = event.modifiers & (WebInputEvent::ShiftKey |
-                                     WebInputEvent::ControlKey |
-                                     WebInputEvent::AltKey |
-                                     WebInputEvent::MetaKey);
+  int modifiers =
+      event.modifiers() & (WebInputEvent::ShiftKey | WebInputEvent::ControlKey |
+                           WebInputEvent::AltKey | WebInputEvent::MetaKey);
   int key = CombineKeyCodeAndModifiers(key_code, modifiers);
   if (whitelisted_keys_.find(key) == whitelisted_keys_.end())
     return false;
@@ -1126,9 +1125,9 @@ bool DevToolsWindow::PreHandleGestureEvent(
     WebContents* source,
     const blink::WebGestureEvent& event) {
   // Disable pinch zooming.
-  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
-      event.type == blink::WebGestureEvent::GesturePinchUpdate ||
-      event.type == blink::WebGestureEvent::GesturePinchEnd;
+  return event.type() == blink::WebGestureEvent::GesturePinchBegin ||
+         event.type() == blink::WebGestureEvent::GesturePinchUpdate ||
+         event.type() == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 void DevToolsWindow::ShowCertificateViewerInDevTools(

chrome/browser/extensions/extension_view_host.cc

@@ -178,7 +178,7 @@ bool ExtensionViewHost::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   if (extension_host_type() == VIEW_TYPE_EXTENSION_POPUP &&
-      event.type == NativeWebKeyboardEvent::RawKeyDown &&
+      event.type() == NativeWebKeyboardEvent::RawKeyDown &&
       event.windowsKeyCode == ui::VKEY_ESCAPE) {
     DCHECK(is_keyboard_shortcut != NULL);
     *is_keyboard_shortcut = true;
@@ -198,7 +198,7 @@ void ExtensionViewHost::HandleKeyboardEvent(
     WebContents* source,
     const NativeWebKeyboardEvent& event) {
   if (extension_host_type() == VIEW_TYPE_EXTENSION_POPUP) {
-    if (event.type == NativeWebKeyboardEvent::RawKeyDown &&
+    if (event.type() == NativeWebKeyboardEvent::RawKeyDown &&
         event.windowsKeyCode == ui::VKEY_ESCAPE) {
       Close();
       return;
@@ -211,9 +211,9 @@ bool ExtensionViewHost::PreHandleGestureEvent(
     content::WebContents* source,
     const blink::WebGestureEvent& event) {
   // Disable pinch zooming.
-  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
-      event.type == blink::WebGestureEvent::GesturePinchUpdate ||
-      event.type == blink::WebGestureEvent::GesturePinchEnd;
+  return event.type() == blink::WebGestureEvent::GesturePinchBegin ||
+         event.type() == blink::WebGestureEvent::GesturePinchUpdate ||
+         event.type() == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 content::ColorChooser* ExtensionViewHost::OpenColorChooser(

chrome/browser/page_load_metrics/metrics_web_contents_observer.cc

@@ -309,7 +309,7 @@ void MetricsWebContentsObserver::NavigationStopped() {
 void MetricsWebContentsObserver::OnInputEvent(
     const blink::WebInputEvent& event) {
   // Ignore browser navigation or reload which comes with type Undefined.
-  if (event.type == blink::WebInputEvent::Type::Undefined)
+  if (event.type() == blink::WebInputEvent::Type::Undefined)
     return;
 
   if (committed_load_)

chrome/browser/page_load_metrics/observers/core_page_load_metrics_observer.cc

@@ -577,7 +577,7 @@ void CorePageLoadMetricsObserver::OnUserInput(
   base::TimeTicks now;
   if (!first_paint_.is_null() &&
       first_user_interaction_after_first_paint_.is_null() &&
-      event.type != blink::WebInputEvent::MouseMove) {
+      event.type() != blink::WebInputEvent::MouseMove) {
     if (now.is_null())
       now = base::TimeTicks::Now();
     first_user_interaction_after_first_paint_ = now;
@@ -587,8 +587,8 @@ void CorePageLoadMetricsObserver::OnUserInput(
     return;
 
   if (!received_non_scroll_input_after_first_paint_) {
-    if (event.type == blink::WebInputEvent::GestureTap ||
-        event.type == blink::WebInputEvent::MouseUp) {
+    if (event.type() == blink::WebInputEvent::GestureTap ||
+        event.type() == blink::WebInputEvent::MouseUp) {
       received_non_scroll_input_after_first_paint_ = true;
       if (now.is_null())
         now = base::TimeTicks::Now();
@@ -598,7 +598,7 @@ void CorePageLoadMetricsObserver::OnUserInput(
     }
   }
   if (!received_scroll_input_after_first_paint_ &&
-      event.type == blink::WebInputEvent::GestureScrollBegin) {
+      event.type() == blink::WebInputEvent::GestureScrollBegin) {
     received_scroll_input_after_first_paint_ = true;
     if (now.is_null())
       now = base::TimeTicks::Now();