Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/input/touch_emulator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/input/touch_emulator.h"
 
 #include "build/build_config.h"
 #include "content/browser/renderer_host/input/motion_event_web.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/grit/content_resources.h"
@@ skipping 24 matching lines @@
       ui::GetGestureProviderConfig(config_type);
   config.gesture_begin_end_types_enabled = false;
   config.gesture_detector_config.swipe_enabled = false;
   config.gesture_detector_config.two_finger_tap_enabled = false;
   return config;
 }
 
 int ModifiersWithoutMouseButtons(const WebInputEvent& event) {
   const int all_buttons = WebInputEvent::LeftButtonDown |
       WebInputEvent::MiddleButtonDown | WebInputEvent::RightButtonDown;
-  return event.modifiers & ~all_buttons;
+  return event.modifiers() & ~all_buttons;
 }
 
 // Time between two consecutive mouse moves, during which second mouse move
 // is not converted to touch.
 const double kMouseMoveDropIntervalSeconds = 5.f / 1000;
 
 } // namespace
 
 TouchEmulator::TouchEmulator(TouchEmulatorClient* client,
                              float device_scale_factor)
@@ skipping 94 matching lines @@
 
   cursor->InitFromCursorInfo(cursor_info);
   return gfx::ScaleSize(gfx::SizeF(cursor_image.Size()), 1.f / scale);
 }
 
 bool TouchEmulator::HandleMouseEvent(const WebMouseEvent& mouse_event) {
   if (!enabled())
     return false;
 
   if (mouse_event.button == WebMouseEvent::Button::Right &&
-      mouse_event.type == WebInputEvent::MouseDown) {
+      mouse_event.type() == WebInputEvent::MouseDown) {
     client_->ShowContextMenuAtPoint(gfx::Point(mouse_event.x, mouse_event.y));
   }
 
   if (mouse_event.button != WebMouseEvent::Button::Left)
     return true;
 
-  if (mouse_event.type == WebInputEvent::MouseMove) {
+  if (mouse_event.type() == WebInputEvent::MouseMove) {
     if (last_mouse_event_was_move_ &&
-        mouse_event.timeStampSeconds < last_mouse_move_timestamp_ +
-            kMouseMoveDropIntervalSeconds)
+        mouse_event.timeStampSeconds() <
+            last_mouse_move_timestamp_ + kMouseMoveDropIntervalSeconds)
       return true;
 
     last_mouse_event_was_move_ = true;
-    last_mouse_move_timestamp_ = mouse_event.timeStampSeconds;
+    last_mouse_move_timestamp_ = mouse_event.timeStampSeconds();
   } else {
     last_mouse_event_was_move_ = false;
   }
 
-  if (mouse_event.type == WebInputEvent::MouseDown)
+  if (mouse_event.type() == WebInputEvent::MouseDown)
     mouse_pressed_ = true;
-  else if (mouse_event.type == WebInputEvent::MouseUp)
+  else if (mouse_event.type() == WebInputEvent::MouseUp)
     mouse_pressed_ = false;
 
-  UpdateShiftPressed((mouse_event.modifiers & WebInputEvent::ShiftKey) != 0);
+  UpdateShiftPressed((mouse_event.modifiers() & WebInputEvent::ShiftKey) != 0);
 
-  if (mouse_event.type != WebInputEvent::MouseDown &&
-      mouse_event.type != WebInputEvent::MouseMove &&
-      mouse_event.type != WebInputEvent::MouseUp) {
+  if (mouse_event.type() != WebInputEvent::MouseDown &&
+      mouse_event.type() != WebInputEvent::MouseMove &&
+      mouse_event.type() != WebInputEvent::MouseUp) {
     return true;
   }
 
   FillTouchEventAndPoint(mouse_event);
   HandleEmulatedTouchEvent(touch_event_);
 
   // Do not pass mouse events to the renderer.
   return true;
 }
 
 bool TouchEmulator::HandleMouseWheelEvent(const WebMouseWheelEvent& event) {
   if (!enabled())
     return false;
 
   // Send mouse wheel for easy scrolling when there is no active touch.
   return emulated_stream_active_sequence_count_ > 0;
 }
 
 bool TouchEmulator::HandleKeyboardEvent(const WebKeyboardEvent& event) {
   if (!enabled())
     return false;
 
-  if (!UpdateShiftPressed((event.modifiers & WebInputEvent::ShiftKey) != 0))
+  if (!UpdateShiftPressed((event.modifiers() & WebInputEvent::ShiftKey) != 0))
     return false;
 
   if (!mouse_pressed_)
     return false;
 
   // Note: The necessary pinch events will be lazily inserted by
   // |OnGestureEvent| depending on the state of |shift_pressed_|, using the
   // scroll stream as the event driver.
   if (shift_pressed_) {
     // TODO(dgozman): Add secondary touch point and set anchor.
@@ skipping 68 matching lines @@
   // middle of a sequence), so don't decrement sequence count below zero.
   if (is_sequence_end && native_stream_active_sequence_count_)
     native_stream_active_sequence_count_--;
   return false;
 }
 
 void TouchEmulator::OnGestureEvent(const ui::GestureEventData& gesture) {
   WebGestureEvent gesture_event =
       ui::CreateWebGestureEventFromGestureEventData(gesture);
 
-  switch (gesture_event.type) {
+  switch (gesture_event.type()) {
     case WebInputEvent::Undefined:
       NOTREACHED() << "Undefined WebInputEvent type";
       // Bail without sending the junk event to the client.
       return;
 
     case WebInputEvent::GestureScrollBegin:
       client_->ForwardEmulatedGestureEvent(gesture_event);
       // PinchBegin must always follow ScrollBegin.
       if (InPinchGestureMode())
         PinchBegin(gesture_event);
@@ skipping 101 matching lines @@
   DCHECK(pinch_gesture_active_);
   pinch_gesture_active_ = false;
   WebGestureEvent pinch_event =
       GetPinchGestureEvent(WebInputEvent::GesturePinchEnd, event);
   client_->ForwardEmulatedGestureEvent(pinch_event);
 }
 
 void TouchEmulator::ScrollEnd(const WebGestureEvent& event) {
   WebGestureEvent scroll_event(WebInputEvent::GestureScrollEnd,
                                ModifiersWithoutMouseButtons(event),
-                               event.timeStampSeconds);
+                               event.timeStampSeconds());
   scroll_event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   client_->ForwardEmulatedGestureEvent(scroll_event);
 }
 
 WebGestureEvent TouchEmulator::GetPinchGestureEvent(
     WebInputEvent::Type type,
     const WebInputEvent& original_event) {
   WebGestureEvent event(type, ModifiersWithoutMouseButtons(original_event),
-                        original_event.timeStampSeconds);
+                        original_event.timeStampSeconds());
   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   event.x = pinch_anchor_.x();
   event.y = pinch_anchor_.y();
   return event;
 }
 
 void TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
   WebInputEvent::Type eventType;
-  switch (mouse_event.type) {
+  switch (mouse_event.type()) {
     case WebInputEvent::MouseDown:
       eventType = WebInputEvent::TouchStart;
       break;
     case WebInputEvent::MouseMove:
       eventType = WebInputEvent::TouchMove;
       break;
     case WebInputEvent::MouseUp:
       eventType = WebInputEvent::TouchEnd;
       break;
     default:
       eventType = WebInputEvent::Undefined;
-      NOTREACHED() << "Invalid event for touch emulation: " << mouse_event.type;
+      NOTREACHED() << "Invalid event for touch emulation: "
+                   << mouse_event.type();
   }
   touch_event_.touchesLength = 1;
   touch_event_.setModifiers(ModifiersWithoutMouseButtons(mouse_event));
   WebTouchEventTraits::ResetTypeAndTouchStates(
-      eventType, mouse_event.timeStampSeconds, &touch_event_);
+      eventType, mouse_event.timeStampSeconds(), &touch_event_);
   WebTouchPoint& point = touch_event_.touches[0];
   point.id = 0;
   point.radiusX = 0.5f * cursor_size_.width();
   point.radiusY = 0.5f * cursor_size_.height();
   point.force = 1.f;
   point.rotationAngle = 0.f;
   point.position.x = mouse_event.x;
   point.screenPosition.x = mouse_event.globalX;
   point.position.y = mouse_event.y;
   point.screenPosition.y = mouse_event.globalY;
   point.tiltX = 0;
   point.tiltY = 0;
   point.pointerType = blink::WebPointerProperties::PointerType::Touch;
 }
 
 bool TouchEmulator::InPinchGestureMode() const {
   return shift_pressed_;
 }
 
 }  // namespace content