Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/input/web_input_event_builders_mac.mm

 // Copyright 2015 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.
 
 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006-2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 128 matching lines @@
 
 bool IsSystemKeyEvent(const blink::WebKeyboardEvent& event) {
   // Windows and Linux set |isSystemKey| if alt is down. Blink looks at this
   // flag to decide if it should handle a key or not. E.g. alt-left/right
   // shouldn't be used by Blink to scroll the current page, because we want
   // to get that key back for it to do history navigation. Hence, the
   // corresponding situation on OS X is to set this for cmd key presses.
 
   // cmd-b and and cmd-i are system wide key bindings that OS X doesn't
   // handle for us, so the editor handles them.
-  int modifiers = event.modifiers & blink::WebInputEvent::InputModifiers;
+  int modifiers = event.modifiers() & blink::WebInputEvent::InputModifiers;
   if (modifiers == blink::WebInputEvent::MetaKey &&
       event.windowsKeyCode == ui::VKEY_B)
     return false;
   if (modifiers == blink::WebInputEvent::MetaKey &&
       event.windowsKeyCode == ui::VKEY_I)
     return false;
 
-  return event.modifiers & blink::WebInputEvent::MetaKey;
+  return event.modifiers() & blink::WebInputEvent::MetaKey;
 }
 
 blink::WebMouseWheelEvent::Phase PhaseForNSEventPhase(
     NSEventPhase event_phase) {
   uint32_t phase = blink::WebMouseWheelEvent::PhaseNone;
   if (event_phase & NSEventPhaseBegan)
     phase |= blink::WebMouseWheelEvent::PhaseBegan;
   if (event_phase & NSEventPhaseStationary)
     phase |= blink::WebMouseWheelEvent::PhaseStationary;
   if (event_phase & NSEventPhaseChanged)
@@ skipping 26 matching lines @@
 ui::DomKey DomKeyFromEvent(NSEvent* event) {
   ui::DomKey key = ui::DomKeyFromNSEvent(event);
   if (key != ui::DomKey::NONE)
     return key;
   return ui::DomKey::UNIDENTIFIED;
 }
 
 }  // namespace
 
 blink::WebKeyboardEvent WebKeyboardEventBuilder::Build(NSEvent* event) {
-  blink::WebKeyboardEvent result;
-
-  result.type = ui::IsKeyUpEvent(event) ? blink::WebInputEvent::KeyUp
-                                        : blink::WebInputEvent::RawKeyDown;
-
-  result.modifiers = ModifiersFromEvent(event);
+  ui::DomCode dom_code = ui::DomCodeFromNSEvent(event);
+  int modifiers =
+      ModifiersFromEvent(event) | ui::DomCodeToWebInputEventModifiers(dom_code);
 
   if (([event type] != NSFlagsChanged) && [event isARepeat])
-    result.modifiers |= blink::WebInputEvent::IsAutoRepeat;
+    modifiers |= blink::WebInputEvent::IsAutoRepeat;
 
-  ui::DomCode dom_code = ui::DomCodeFromNSEvent(event);
+  blink::WebKeyboardEvent result(ui::IsKeyUpEvent(event)
+                                     ? blink::WebInputEvent::KeyUp
+                                     : blink::WebInputEvent::RawKeyDown,
+                                 modifiers, [event timestamp]);
   result.windowsKeyCode =
       ui::LocatedToNonLocatedKeyboardCode(ui::KeyboardCodeFromNSEvent(event));
-  result.modifiers |= ui::DomCodeToWebInputEventModifiers(dom_code);
   result.nativeKeyCode = [event keyCode];
   result.domCode = static_cast<int>(dom_code);
   result.domKey = DomKeyFromEvent(event);
   NSString* text_str = TextFromEvent(event);
   NSString* unmodified_str = UnmodifiedTextFromEvent(event);
 
   // Begin Apple code, copied from KeyEventMac.mm
 
   // Always use 13 for Enter/Return -- we don't want to use AppKit's
   // different character for Enter.
@@ skipping 11 matching lines @@
 
   // End Apple code.
 
   if ([text_str length] < blink::WebKeyboardEvent::textLengthCap &&
       [unmodified_str length] < blink::WebKeyboardEvent::textLengthCap) {
     [text_str getCharacters:&result.text[0]];
     [unmodified_str getCharacters:&result.unmodifiedText[0]];
   } else
     NOTIMPLEMENTED();
 
-  result.timeStampSeconds = [event timestamp];
   result.isSystemKey = IsSystemKeyEvent(result);
 
   return result;
 }
 
 // WebMouseEvent --------------------------------------------------------------
 
 blink::WebMouseEvent WebMouseEventBuilder::Build(NSEvent* event, NSView* view) {
-  blink::WebMouseEvent result;
-
-  result.clickCount = 0;
+  blink::WebInputEvent::Type event_type = blink::WebInputEvent::Type::Undefined;
+  int click_count = 0;
+  blink::WebMouseEvent::Button button = blink::WebMouseEvent::Button::NoButton;
 
   NSEventType type = [event type];
   switch (type) {
     case NSMouseExited:
-      result.type = blink::WebInputEvent::MouseLeave;
-      result.button = blink::WebMouseEvent::Button::NoButton;
+      event_type = blink::WebInputEvent::MouseLeave;
       break;
     case NSLeftMouseDown:
-      result.type = blink::WebInputEvent::MouseDown;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Left;
+      event_type = blink::WebInputEvent::MouseDown;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Left;
       break;
     case NSOtherMouseDown:
-      result.type = blink::WebInputEvent::MouseDown;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Middle;
+      event_type = blink::WebInputEvent::MouseDown;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Middle;
       break;
     case NSRightMouseDown:
-      result.type = blink::WebInputEvent::MouseDown;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Right;
+      event_type = blink::WebInputEvent::MouseDown;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Right;
       break;
     case NSLeftMouseUp:
-      result.type = blink::WebInputEvent::MouseUp;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Left;
+      event_type = blink::WebInputEvent::MouseUp;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Left;
       break;
     case NSOtherMouseUp:
-      result.type = blink::WebInputEvent::MouseUp;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Middle;
+      event_type = blink::WebInputEvent::MouseUp;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Middle;
       break;
     case NSRightMouseUp:
-      result.type = blink::WebInputEvent::MouseUp;
-      result.clickCount = [event clickCount];
-      result.button = blink::WebMouseEvent::Button::Right;
+      event_type = blink::WebInputEvent::MouseUp;
+      click_count = [event clickCount];
+      button = blink::WebMouseEvent::Button::Right;
       break;
     case NSMouseMoved:
     case NSMouseEntered:
-      result.type = blink::WebInputEvent::MouseMove;
+      event_type = blink::WebInputEvent::MouseMove;
       break;
     case NSLeftMouseDragged:
-      result.type = blink::WebInputEvent::MouseMove;
-      result.button = blink::WebMouseEvent::Button::Left;
+      event_type = blink::WebInputEvent::MouseMove;
+      button = blink::WebMouseEvent::Button::Left;
       break;
     case NSOtherMouseDragged:
-      result.type = blink::WebInputEvent::MouseMove;
-      result.button = blink::WebMouseEvent::Button::Middle;
+      event_type = blink::WebInputEvent::MouseMove;
+      button = blink::WebMouseEvent::Button::Middle;
       break;
     case NSRightMouseDragged:
-      result.type = blink::WebInputEvent::MouseMove;
-      result.button = blink::WebMouseEvent::Button::Right;
+      event_type = blink::WebInputEvent::MouseMove;
+      button = blink::WebMouseEvent::Button::Right;
       break;
     default:
       NOTIMPLEMENTED();
   }
 
+  blink::WebMouseEvent result(event_type, ModifiersFromEvent(event),
+                              [event timestamp]);
+  result.clickCount = click_count;
+  result.button = button;
   SetWebEventLocationFromEventInView(&result, event, view);
 
-  result.modifiers = ModifiersFromEvent(event);
-
-  result.timeStampSeconds = [event timestamp];
-
   // For NSMouseExited and NSMouseEntered, they do not have a subtype. Styluses
   // and mouses share the same cursor, so we will set their pointerType as
   // Unknown for now.
   if (type == NSMouseExited || type == NSMouseEntered) {
     result.pointerType = blink::WebPointerProperties::PointerType::Unknown;
     return result;
   }
 
   // For other mouse events and touchpad events, the pointer type is mouse.
   // For all other tablet events, the pointer type will be just pen.
@@ skipping 15 matching lines @@
     result.tiltY = lround(tilt.y * 90);
   }
   return result;
 }
 
 // WebMouseWheelEvent ---------------------------------------------------------
 
 blink::WebMouseWheelEvent WebMouseWheelEventBuilder::Build(
     NSEvent* event,
     NSView* view) {
-  blink::WebMouseWheelEvent result;
-
-  result.type = blink::WebInputEvent::MouseWheel;
+  blink::WebMouseWheelEvent result(blink::WebInputEvent::MouseWheel,
+                                   ModifiersFromEvent(event),
+                                   [event timestamp]);
   result.button = blink::WebMouseEvent::Button::NoButton;
 
-  result.modifiers = ModifiersFromEvent(event);
-
   SetWebEventLocationFromEventInView(&result, event, view);
 
   // Of Mice and Men
   // ---------------
   //
   // There are three types of scroll data available on a scroll wheel CGEvent.
   // Apple's documentation ([1]) is rather vague in their differences, and not
   // terribly helpful in deciding which to use. This is what's really going on.
   //
   // First, these events behave very differently depending on whether a standard
@@ skipping 112 matching lines @@
     result.hasPreciseScrollingDeltas = true;
   } else {
     result.deltaX = [event deltaX] * ui::kScrollbarPixelsPerCocoaTick;
     result.deltaY = [event deltaY] * ui::kScrollbarPixelsPerCocoaTick;
     result.wheelTicksY =
         CGEventGetIntegerValueField(cg_event, kCGScrollWheelEventDeltaAxis1);
     result.wheelTicksX =
         CGEventGetIntegerValueField(cg_event, kCGScrollWheelEventDeltaAxis2);
   }
 
-  result.timeStampSeconds = [event timestamp];
-
   result.phase = PhaseForEvent(event);
   result.momentumPhase = MomentumPhaseForEvent(event);
 
   return result;
 }
 
 blink::WebGestureEvent WebGestureEventBuilder::Build(NSEvent* event,
                                                      NSView* view) {
   blink::WebGestureEvent result;
 
   // Use a temporary WebMouseEvent to get the location.
   blink::WebMouseEvent temp;
 
   SetWebEventLocationFromEventInView(&temp, event, view);
   result.x = temp.x;
   result.y = temp.y;
   result.globalX = temp.globalX;
   result.globalY = temp.globalY;
 
-  result.modifiers = ModifiersFromEvent(event);
-  result.timeStampSeconds = [event timestamp];
+  result.setModifiers(ModifiersFromEvent(event));
+  result.setTimeStampSeconds([event timestamp]);
 
   result.sourceDevice = blink::WebGestureDeviceTouchpad;
   switch ([event type]) {
     case NSEventTypeMagnify:
-      result.type = blink::WebInputEvent::GesturePinchUpdate;
+      result.setType(blink::WebInputEvent::GesturePinchUpdate);
       result.data.pinchUpdate.scale = [event magnification] + 1.0;
       break;
     case NSEventTypeSmartMagnify:
       // Map the Cocoa "double-tap with two fingers" zoom gesture to regular
       // GestureDoubleTap, because the effect is similar to single-finger
       // double-tap zoom on mobile platforms. Note that tapCount is set to 1
       // because the gesture type already encodes that information.
-      result.type = blink::WebInputEvent::GestureDoubleTap;
+      result.setType(blink::WebInputEvent::GestureDoubleTap);
       result.data.tap.tapCount = 1;
       break;
     case NSEventTypeBeginGesture:
     case NSEventTypeEndGesture:
       // The specific type of a gesture is not defined when the gesture begin
       // and end NSEvents come in. Leave them undefined. The caller will need
       // to specify them when the gesture is differentiated.
-      result.type = blink::WebInputEvent::Undefined;
       break;
     default:
       NOTIMPLEMENTED();
-      result.type = blink::WebInputEvent::Undefined;
   }
 
   return result;
 }
 
 }  // namespace content