Collapse the API surface on WebInputEvent via accessor functions.

components/test_runner/event_sender.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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 455 matching lines @@
 
 // Get the edit command corresponding to a keyboard event.
 // Returns true if the specified event corresponds to an edit command, the name
 // of the edit command will be stored in |*name|.
 bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) {
 #if defined(OS_MACOSX)
 // We only cares about Left,Right,Up,Down keys with Command or Command+Shift
 // modifiers. These key events correspond to some special movement and
 // selection editor commands. These keys will be marked as system key, which
 // prevents them from being handled. Thus they must be handled specially.
-  if ((event.modifiers & ~WebKeyboardEvent::ShiftKey) !=
+  if ((event.modifiers() & ~WebKeyboardEvent::ShiftKey) !=
       WebKeyboardEvent::MetaKey)
     return false;
 
   switch (event.windowsKeyCode) {
     case ui::VKEY_LEFT:
       *name = "MoveToBeginningOfLine";
       break;
     case ui::VKEY_RIGHT:
       *name = "MoveToEndOfLine";
       break;
     case ui::VKEY_UP:
       *name = "MoveToBeginningOfDocument";
       break;
     case ui::VKEY_DOWN:
       *name = "MoveToEndOfDocument";
       break;
     default:
       return false;
   }
 
-  if (event.modifiers & WebKeyboardEvent::ShiftKey)
+  if (event.modifiers() & WebKeyboardEvent::ShiftKey)
     name->append("AndModifySelection");
 
   return true;
 #else
   return false;
 #endif
 }
 
 bool IsSystemKeyEvent(const WebKeyboardEvent& event) {
 #if defined(OS_MACOSX)
-  return event.modifiers & WebInputEvent::MetaKey &&
-      event.windowsKeyCode != ui::VKEY_B &&
-      event.windowsKeyCode != ui::VKEY_I;
+  return event.modifiers() & WebInputEvent::MetaKey &&
+         event.windowsKeyCode != ui::VKEY_B &&
+         event.windowsKeyCode != ui::VKEY_I;
 #else
-  return !!(event.modifiers & WebInputEvent::AltKey);
+  return !!(event.modifiers() & WebInputEvent::AltKey);
 #endif
 }
 
 bool GetScrollUnits(gin::Arguments* args, WebGestureEvent::ScrollUnits* units) {
   std::string units_string;
   if (!args->PeekNext().IsEmpty()) {
     if (args->PeekNext()->IsString())
       args->GetNext(&units_string);
     if (units_string == "Page") {
       *units = WebGestureEvent::Page;
@@ skipping 1150 matching lines @@
   event_down.domKey = static_cast<int>(
       ui::KeycodeConverter::KeyStringToDomKey(domKeyString));
   event_down.domCode = static_cast<int>(
       ui::KeycodeConverter::CodeStringToDomCode(domCodeString));
 
   if (generate_char) {
     event_down.text[0] = text;
     event_down.unmodifiedText[0] = text;
   }
 
-  if (event_down.modifiers != 0)
+  if (event_down.modifiers() != 0)
     event_down.isSystemKey = IsSystemKeyEvent(event_down);
 
   WebKeyboardEvent event_up = event_down;
   event_up.setType(WebInputEvent::KeyUp);
   // 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_)
     widget()->updateAllLifecyclePhases();
 
   // In the browser, if a keyboard event corresponds to an editor command,
@@ skipping 429 matching lines @@
 }
 
 void EventSender::MouseScrollBy(gin::Arguments* args,
                                 MouseScrollType scroll_type) {
   // TODO(dtapuska): Gestures really should be sent by the MouseWheelEventQueue
   // class in the browser. But since the event doesn't propogate up into
   // the browser generate the events here. See crbug.com/596095.
   bool send_gestures = true;
   WebMouseWheelEvent wheel_event =
       GetMouseWheelEvent(args, scroll_type, &send_gestures);
-  if (wheel_event.type != WebInputEvent::Undefined &&
+  if (wheel_event.type() != WebInputEvent::Undefined &&
       HandleInputEventOnViewOrPopup(wheel_event) ==
           WebInputEventResult::NotHandled &&
       send_gestures) {
     SendGesturesForMouseWheelEvent(wheel_event);
   }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
@@ skipping 534 matching lines @@
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
   WebPoint client_point(event->x, event->y);
   WebPoint screen_point(event->globalX, event->globalY);
   current_drag_effect_ = drag_effect;
   if (current_drag_effect_) {
     // Specifically pass any keyboard modifiers to the drop method. This allows
     // tests to control the drop type (i.e. copy or move).
     mainFrameWidget()->dragTargetDrop(current_drag_data_, client_point,
-                                      screen_point, event->modifiers);
+                                      screen_point, event->modifiers());
   } else {
     mainFrameWidget()->dragTargetDragLeave();
   }
   current_drag_data_.reset();
   mainFrameWidget()->dragSourceEndedAt(client_point, screen_point,
                                        current_drag_effect_);
   mainFrameWidget()->dragSourceSystemDragEnded();
 }
 
 void EventSender::DoDragAfterMouseUp(const WebMouseEvent& raw_event) {
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
-  last_click_time_sec_ = event->timeStampSeconds;
+  last_click_time_sec_ = event->timeStampSeconds();
   last_click_pos_ = current_pointer_state_[kRawMousePointerId].last_pos_;
 
   // If we're in a drag operation, complete it.
   if (current_drag_data_.isNull())
     return;
 
   WebPoint client_point(event->x, event->y);
   WebPoint screen_point(event->globalX, event->globalY);
   blink::WebDragOperation drag_effect = mainFrameWidget()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
-      event->modifiers);
+      event->modifiers());
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
   FinishDragAndDrop(raw_event, drag_effect);
 }
 
 void EventSender::DoDragAfterMouseMove(const WebMouseEvent& raw_event) {
   if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::Button::NoButton ||
       current_drag_data_.isNull()) {
     return;
   }
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
   WebPoint client_point(event->x, event->y);
   WebPoint screen_point(event->globalX, event->globalY);
   current_drag_effect_ = mainFrameWidget()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_,
-      event->modifiers);
+      event->modifiers());
 }
 
 void EventSender::ReplaySavedEvents() {
   replaying_saved_events_ = true;
   while (!mouse_event_queue_.empty()) {
     SavedEvent e = mouse_event_queue_.front();
     mouse_event_queue_.pop_front();
 
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
@@ skipping 36 matching lines @@
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
 }
 
 WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
     const WebInputEvent& raw_event) {
-  last_event_timestamp_ = raw_event.timeStampSeconds;
+  last_event_timestamp_ = raw_event.timeStampSeconds();
 
   WebPagePopup* popup = widget()->pagePopup();
-  if (popup && !WebInputEvent::isKeyboardEventType(raw_event.type)) {
+  if (popup && !WebInputEvent::isKeyboardEventType(raw_event.type())) {
     // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the
     // event does not have to be converted.
     std::unique_ptr<WebInputEvent> scaled_event = ui::ScaleWebInputEvent(
         raw_event, delegate()->GetWindowToViewportScale());
     const WebInputEvent* popup_friendly_event =
         scaled_event.get() ? scaled_event.get() : &raw_event;
     return popup->handleInputEvent(*popup_friendly_event);
   }
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebInputEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
   return widget()->handleInputEvent(*event);
 }
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
   WebGestureEvent begin_event(WebInputEvent::GestureScrollBegin,
-                              wheel_event.modifiers, GetCurrentEventTimeSec());
+                              wheel_event.modifiers(),
+                              GetCurrentEventTimeSec());
   InitGestureEventFromMouseWheel(wheel_event, &begin_event);
   begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
   begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
   if (wheel_event.scrollByPage) {
     begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page;
     if (begin_event.data.scrollBegin.deltaXHint) {
       begin_event.data.scrollBegin.deltaXHint =
           begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
     }
     if (begin_event.data.scrollBegin.deltaYHint) {
       begin_event.data.scrollBegin.deltaYHint =
           begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
     }
   } else {
     begin_event.data.scrollBegin.deltaHintUnits =
         wheel_event.hasPreciseScrollingDeltas
             ? blink::WebGestureEvent::PrecisePixels
             : blink::WebGestureEvent::Pixels;
   }
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(begin_event);
 
   WebGestureEvent update_event(WebInputEvent::GestureScrollUpdate,
-                               wheel_event.modifiers, GetCurrentEventTimeSec());
+                               wheel_event.modifiers(),
+                               GetCurrentEventTimeSec());
   InitGestureEventFromMouseWheel(wheel_event, &update_event);
   update_event.data.scrollUpdate.deltaX =
       begin_event.data.scrollBegin.deltaXHint;
   update_event.data.scrollUpdate.deltaY =
       begin_event.data.scrollBegin.deltaYHint;
   update_event.data.scrollUpdate.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(update_event);
 
   WebGestureEvent end_event(WebInputEvent::GestureScrollEnd,
-                            wheel_event.modifiers, GetCurrentEventTimeSec());
+                            wheel_event.modifiers(), GetCurrentEventTimeSec());
   InitGestureEventFromMouseWheel(wheel_event, &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
 TestInterfaces* EventSender::interfaces() {
@@ skipping 21 matching lines @@
   return view()->mainFrame()->toWebLocalFrame()->frameWidget();
 }
 
 std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates(
     const WebInputEvent& event) {
   return delegate()->TransformScreenToWidgetCoordinates(
       web_widget_test_proxy_base_, event);
 }
 
 }  // namespace test_runner