Collapse the API surface on WebInputEvent via accessor functions.

content/renderer/pepper/event_conversion.cc

 // Copyright (c) 2012 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/renderer/pepper/event_conversion.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 65 matching lines @@
                   static_cast<int>(WebInputEvent::NumLockOn),
               "NumLock should match");
 static_assert(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISLEFT) ==
                   static_cast<int>(WebInputEvent::IsLeft),
               "IsLeft should match");
 static_assert(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISRIGHT) ==
                   static_cast<int>(WebInputEvent::IsRight),
               "IsRight should match");
 
 PP_InputEvent_Type ConvertEventTypes(const WebInputEvent& event) {
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::MouseDown:
       return PP_INPUTEVENT_TYPE_MOUSEDOWN;
     case WebInputEvent::MouseUp:
       return PP_INPUTEVENT_TYPE_MOUSEUP;
     case WebInputEvent::MouseMove:
       return PP_INPUTEVENT_TYPE_MOUSEMOVE;
     case WebInputEvent::MouseEnter:
       return PP_INPUTEVENT_TYPE_MOUSEENTER;
     case WebInputEvent::MouseLeave:
       return PP_INPUTEVENT_TYPE_MOUSELEAVE;
@@ skipping 39 matching lines @@
                       PP_INPUTEVENT_MODIFIER_ISLEFT |
                       PP_INPUTEVENT_MODIFIER_ISRIGHT);
 }
 
 // Generates a PP_InputEvent with the fields common to all events, as well as
 // the event type from the given web event. Event-specific fields will be zero
 // initialized.
 InputEventData GetEventWithCommonFieldsAndType(const WebInputEvent& web_event) {
   InputEventData result;
   result.event_type = ConvertEventTypes(web_event);
-  result.event_time_stamp = web_event.timeStampSeconds;
+  result.event_time_stamp = web_event.timeStampSeconds();
   return result;
 }
 
 void AppendKeyEvent(const WebInputEvent& event,
                     std::vector<InputEventData>* result_events) {
   const WebKeyboardEvent& key_event =
       static_cast<const WebKeyboardEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = ConvertEventModifiers(key_event.modifiers);
+  result.event_modifiers = ConvertEventModifiers(key_event.modifiers());
   result.key_code = key_event.windowsKeyCode;
   result.code = ui::KeycodeConverter::DomCodeToCodeString(
       static_cast<ui::DomCode>(key_event.domCode));
   result_events->push_back(result);
 }
 
 void AppendCharEvent(const WebInputEvent& event,
                      std::vector<InputEventData>* result_events) {
   const WebKeyboardEvent& key_event =
       static_cast<const WebKeyboardEvent&>(event);
 
   // This is a bit complex, the input event will normally just have one 16-bit
   // character in it, but may be zero or more than one. The text array is
   // just padded with 0 values for the unused ones, but is not necessarily
   // null-terminated.
   //
   // Here we see how many UTF-16 characters we have.
   size_t utf16_char_count = 0;
   while (utf16_char_count < WebKeyboardEvent::textLengthCap &&
          key_event.text[utf16_char_count])
     utf16_char_count++;
 
   // Make a separate InputEventData for each Unicode character in the input.
   base::i18n::UTF16CharIterator iter(key_event.text, utf16_char_count);
   while (!iter.end()) {
     InputEventData result = GetEventWithCommonFieldsAndType(event);
-    result.event_modifiers = ConvertEventModifiers(key_event.modifiers);
+    result.event_modifiers = ConvertEventModifiers(key_event.modifiers());
     base::WriteUnicodeCharacter(iter.get(), &result.character_text);
 
     result_events->push_back(result);
     iter.Advance();
   }
 }
 
 void AppendMouseEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   static_assert(static_cast<int>(WebMouseEvent::Button::NoButton) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
                 "MouseNone should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Left) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
                 "MouseLeft should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Right) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
                 "MouseRight should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Middle) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
                 "MouseMiddle should match");
 
   const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = ConvertEventModifiers(mouse_event.modifiers);
-  if (mouse_event.type == WebInputEvent::MouseDown ||
-      mouse_event.type == WebInputEvent::MouseMove ||
-      mouse_event.type == WebInputEvent::MouseUp) {
+  result.event_modifiers = ConvertEventModifiers(mouse_event.modifiers());
+  if (mouse_event.type() == WebInputEvent::MouseDown ||
+      mouse_event.type() == WebInputEvent::MouseMove ||
+      mouse_event.type() == WebInputEvent::MouseUp) {
     result.mouse_button =
         static_cast<PP_InputEvent_MouseButton>(mouse_event.button);
   }
   result.mouse_position.x = mouse_event.x;
   result.mouse_position.y = mouse_event.y;
   result.mouse_click_count = mouse_event.clickCount;
   result.mouse_movement.x = mouse_event.movementX;
   result.mouse_movement.y = mouse_event.movementY;
   result_events->push_back(result);
 }
 
 void AppendMouseWheelEvent(const WebInputEvent& event,
                            std::vector<InputEventData>* result_events) {
   const WebMouseWheelEvent& mouse_wheel_event =
       static_cast<const WebMouseWheelEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = ConvertEventModifiers(mouse_wheel_event.modifiers);
+  result.event_modifiers = ConvertEventModifiers(mouse_wheel_event.modifiers());
   result.wheel_delta.x = mouse_wheel_event.deltaX;
   result.wheel_delta.y = mouse_wheel_event.deltaY;
   result.wheel_ticks.x = mouse_wheel_event.wheelTicksX;
   result.wheel_ticks.y = mouse_wheel_event.wheelTicksY;
   result.wheel_scroll_by_page = !!mouse_wheel_event.scrollByPage;
   result_events->push_back(result);
 }
 
 enum IncludedTouchPointTypes {
   ALL,     // All pointers targetting the plugin.
@@ skipping 211 matching lines @@
     case PP_INPUTEVENT_TYPE_CONTEXTMENU:
       type = WebInputEvent::ContextMenu;
       break;
     default:
       NOTREACHED();
   }
   WebMouseEvent* mouse_event =
       new WebMouseEvent(type, event.event_modifiers, event.event_time_stamp);
   mouse_event->pointerType = blink::WebPointerProperties::PointerType::Mouse;
   mouse_event->button = static_cast<WebMouseEvent::Button>(event.mouse_button);
-  if (mouse_event->type == WebInputEvent::MouseMove) {
-    if (mouse_event->modifiers & WebInputEvent::LeftButtonDown)
+  if (mouse_event->type() == WebInputEvent::MouseMove) {
+    if (mouse_event->modifiers() & WebInputEvent::LeftButtonDown)
       mouse_event->button = WebMouseEvent::Button::Left;
-    else if (mouse_event->modifiers & WebInputEvent::MiddleButtonDown)
+    else if (mouse_event->modifiers() & WebInputEvent::MiddleButtonDown)
       mouse_event->button = WebMouseEvent::Button::Middle;
-    else if (mouse_event->modifiers & WebInputEvent::RightButtonDown)
+    else if (mouse_event->modifiers() & WebInputEvent::RightButtonDown)
       mouse_event->button = WebMouseEvent::Button::Right;
   }
   mouse_event->x = event.mouse_position.x;
   mouse_event->y = event.mouse_position.y;
   mouse_event->clickCount = event.mouse_click_count;
   mouse_event->movementX = event.mouse_movement.x;
   mouse_event->movementY = event.mouse_movement.y;
   return mouse_event;
 }
 
@@ skipping 91 matching lines @@
   *code = vk_code;
   *text = vk_text;
 }
 
 }  // namespace
 
 void CreateInputEventData(const WebInputEvent& event,
                           std::vector<InputEventData>* result) {
   result->clear();
 
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::MouseDown:
     case WebInputEvent::MouseUp:
     case WebInputEvent::MouseMove:
     case WebInputEvent::MouseEnter:
     case WebInputEvent::MouseLeave:
     case WebInputEvent::ContextMenu:
       AppendMouseEvent(event, result);
       break;
     case WebInputEvent::MouseWheel:
       AppendMouseWheelEvent(event, result);
@@ skipping 92 matching lines @@
       break;
     }
 
     case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYUP: {
 // Windows key down events should always be "raw" to avoid an ASSERT.
 #if defined(OS_WIN)
       WebKeyboardEvent* web_keyboard_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
-      if (web_keyboard_event->type == WebInputEvent::KeyDown)
-        web_keyboard_event->type = WebInputEvent::RawKeyDown;
+      if (web_keyboard_event->type() == WebInputEvent::KeyDown)
+        web_keyboard_event->setType(WebInputEvent::RawKeyDown);
 #endif
       events.push_back(std::move(original_event));
       break;
     }
 
     case PP_INPUTEVENT_TYPE_CHAR: {
       WebKeyboardEvent* web_char_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
 
       WebUChar code = 0, text = 0;
       bool needs_shift_modifier = false, generate_char = false;
       GetKeyCode(event.character_text,
                  &code,
                  &text,
                  &needs_shift_modifier,
                  &generate_char);
 
       // Synthesize key down and key up events in all cases.
       std::unique_ptr<WebKeyboardEvent> key_down_event(new WebKeyboardEvent(
           WebInputEvent::RawKeyDown,
           needs_shift_modifier ? WebInputEvent::ShiftKey
                                : WebInputEvent::NoModifiers,
-          web_char_event->timeStampSeconds));
+          web_char_event->timeStampSeconds()));
       std::unique_ptr<WebKeyboardEvent> key_up_event(new WebKeyboardEvent());
 
       key_down_event->windowsKeyCode = code;
       key_down_event->nativeKeyCode = code;
 
       // If a char event is needed, set the text fields.
       if (generate_char) {
         key_down_event->text[0] = text;
         key_down_event->unmodifiedText[0] = text;
       }
@@ skipping 12 matching lines @@
       break;
     }
 
     default:
       break;
   }
   return events;
 }
 
 PP_InputEvent_Class ClassifyInputEvent(const WebInputEvent& event) {
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::MouseDown:
     case WebInputEvent::MouseUp:
     case WebInputEvent::MouseMove:
     case WebInputEvent::MouseEnter:
     case WebInputEvent::MouseLeave:
     case WebInputEvent::ContextMenu:
       return PP_INPUTEVENT_CLASS_MOUSE;
     case WebInputEvent::MouseWheel:
       return PP_INPUTEVENT_CLASS_WHEEL;
     case WebInputEvent::RawKeyDown:
     case WebInputEvent::KeyDown:
     case WebInputEvent::KeyUp:
     case WebInputEvent::Char:
       return PP_INPUTEVENT_CLASS_KEYBOARD;
     case WebInputEvent::TouchCancel:
     case WebInputEvent::TouchEnd:
     case WebInputEvent::TouchMove:
     case WebInputEvent::TouchStart:
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::TouchScrollStarted:
       return PP_InputEvent_Class(0);
     default:
-      CHECK(WebInputEvent::isGestureEventType(event.type));
+      CHECK(WebInputEvent::isGestureEventType(event.type()));
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content