Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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/browser/renderer_host/render_widget_host_view_mac.h"
 
 #import <Carbon/Carbon.h>
 #import <objc/runtime.h>
 #include <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
@@ skipping 61 matching lines @@
 #include "ui/base/cocoa/animation_utils.h"
 #import "ui/base/cocoa/appkit_utils.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #import "ui/base/cocoa/fullscreen_window_manager.h"
 #import "ui/base/cocoa/underlay_opengl_hosting_window.h"
 #include "ui/base/layout.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gl/gl_switches.h"
 
 using content::BrowserAccessibility;
@@ skipping 1061 matching lines @@
                                       location:location
                                  modifierFlags:0
                                      timestamp:0
                                   windowNumber:window_number()
                                        context:nil
                                    eventNumber:0
                                     clickCount:0
                                       pressure:0];
   WebMouseEvent web_event = WebMouseEventBuilder::Build(event, cocoa_view_);
   if (showing)
-    web_event.type = WebInputEvent::MouseLeave;
+    web_event.setType(WebInputEvent::MouseLeave);
   ForwardMouseEvent(web_event);
 }
 
 bool RenderWidgetHostViewMac::IsPopup() const {
   return popup_type_ != blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
@@ skipping 27 matching lines @@
 
 ui::AcceleratedWidgetMac* RenderWidgetHostViewMac::GetAcceleratedWidgetMac()
     const {
   return browser_compositor_->GetAcceleratedWidgetMac();
 }
 
 void RenderWidgetHostViewMac::ForwardMouseEvent(const WebMouseEvent& event) {
   if (render_widget_host_)
     render_widget_host_->ForwardMouseEvent(event);
 
-  if (event.type == WebInputEvent::MouseLeave) {
+  if (event.type() == WebInputEvent::MouseLeave) {
     [cocoa_view_ setToolTipAtMousePoint:nil];
     tooltip_text_.clear();
   }
 }
 
 void RenderWidgetHostViewMac::SetNeedsBeginFrames(bool needs_begin_frames) {
   needs_begin_frames_ = needs_begin_frames;
   UpdateNeedsBeginFramesInternal();
 }
 
@@ skipping 254 matching lines @@
   [NSCursor unhide];
 
   if (render_widget_host_)
     render_widget_host_->LostMouseLock();
 }
 
 void RenderWidgetHostViewMac::GestureEventAck(
     const blink::WebGestureEvent& event,
     InputEventAckState ack_result) {
   bool consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
-  switch (event.type) {
+  switch (event.type()) {
     case blink::WebInputEvent::GestureScrollBegin:
     case blink::WebInputEvent::GestureScrollUpdate:
     case blink::WebInputEvent::GestureScrollEnd:
       [cocoa_view_ processedGestureScrollEvent:event consumed:consumed];
       return;
     default:
       break;
   }
 }
 
@@ skipping 29 matching lines @@
   if (!id.is_valid())
     return GetFrameSinkId();
   return id.frame_sink_id();
 }
 
 bool RenderWidgetHostViewMac::ShouldRouteEvent(
     const WebInputEvent& event) const {
   // See also RenderWidgetHostViewAura::ShouldRouteEvent.
   // TODO(wjmaclean): Update this function if RenderWidgetHostViewMac implements
   // OnTouchEvent(), to match what we are doing in RenderWidgetHostViewAura.
-  DCHECK(WebInputEvent::isMouseEventType(event.type) ||
-         event.type == WebInputEvent::MouseWheel);
+  DCHECK(WebInputEvent::isMouseEventType(event.type()) ||
+         event.type() == WebInputEvent::MouseWheel);
   return render_widget_host_->delegate() &&
          render_widget_host_->delegate()->GetInputEventRouter() &&
          SiteIsolationPolicy::AreCrossProcessFramesPossible();
 }
 
 void RenderWidgetHostViewMac::ProcessMouseEvent(
     const blink::WebMouseEvent& event,
     const ui::LatencyInfo& latency) {
   render_widget_host_->ForwardMouseEventWithLatencyInfo(event, latency);
 }
@@ skipping 345 matching lines @@
       [responderDelegate_ respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [responderDelegate_ handleEvent:theEvent];
     if (handled)
       return;
   }
 
   if ([self shouldIgnoreMouseEvent:theEvent]) {
     // If this is the first such event, send a mouse exit to the host view.
     if (!mouseEventWasIgnored_ && renderWidgetHostView_->render_widget_host_) {
       WebMouseEvent exitEvent = WebMouseEventBuilder::Build(theEvent, self);
-      exitEvent.type = WebInputEvent::MouseLeave;
+      exitEvent.setType(WebInputEvent::MouseLeave);
       exitEvent.button = WebMouseEvent::Button::NoButton;
       renderWidgetHostView_->ForwardMouseEvent(exitEvent);
     }
     mouseEventWasIgnored_ = YES;
     return;
   }
 
   if (mouseEventWasIgnored_) {
     // If this is the first mouse event after a previous event that was ignored
     // due to the hitTest, send a mouse enter event to the host view.
     if (renderWidgetHostView_->render_widget_host_) {
       WebMouseEvent enterEvent = WebMouseEventBuilder::Build(theEvent, self);
-      enterEvent.type = WebInputEvent::MouseMove;
+      enterEvent.setType(WebInputEvent::MouseMove);
       enterEvent.button = WebMouseEvent::Button::NoButton;
       ui::LatencyInfo latency_info(ui::SourceEventType::OTHER);
       latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
       if (renderWidgetHostView_->ShouldRouteEvent(enterEvent)) {
         renderWidgetHostView_->render_widget_host_->delegate()
             ->GetInputEventRouter()
             ->RouteMouseEvent(renderWidgetHostView_.get(), &enterEvent,
                               latency_info);
       } else {
         renderWidgetHostView_->ProcessMouseEvent(enterEvent, latency_info);
@@ skipping 125 matching lines @@
   // Don't cancel child popups; the key events are probably what's triggering
   // the popup in the first place.
 
   RenderWidgetHostImpl* widgetHost = renderWidgetHostView_->render_widget_host_;
   DCHECK(widgetHost);
 
   NativeWebKeyboardEvent event(theEvent);
 
   // Force fullscreen windows to close on Escape so they won't keep the keyboard
   // grabbed or be stuck onscreen if the renderer is hanging.
-  if (event.type == NativeWebKeyboardEvent::RawKeyDown &&
+  if (event.type() == NativeWebKeyboardEvent::RawKeyDown &&
       event.windowsKeyCode == ui::VKEY_ESCAPE &&
       renderWidgetHostView_->pepper_fullscreen_window()) {
     RenderWidgetHostViewMac* parent =
         renderWidgetHostView_->fullscreen_parent_host_view();
     if (parent)
       parent->cocoa_view()->suppressNextEscapeKeyUp_ = YES;
     widgetHost->ShutdownAndDestroyWidget(true);
     return;
   }
 
   // If there are multiple widgets on the page (such as when there are
   // out-of-process iframes), pick the one that should process this event.
   if (widgetHost->delegate())
     widgetHost = widgetHost->delegate()->GetFocusedRenderWidgetHost(widgetHost);
   if (!widgetHost)
     return;
 
   // Suppress the escape key up event if necessary.
   if (event.windowsKeyCode == ui::VKEY_ESCAPE && suppressNextEscapeKeyUp_) {
-    if (event.type == NativeWebKeyboardEvent::KeyUp)
+    if (event.type() == NativeWebKeyboardEvent::KeyUp)
       suppressNextEscapeKeyUp_ = NO;
     return;
   }
 
   // Do not forward key up events unless preceded by a matching key down,
   // otherwise we might get an event from releasing the return key in the
   // omnibox (http://crbug.com/338736).
   if ([theEvent type] == NSKeyUp) {
     auto numErased = keyDownCodes_.erase([theEvent keyCode]);
     if (numErased < 1)
@@ skipping 127 matching lines @@
   // edit commands, then we need to send the real key event and corresponding
   // edit commands here. This usually occurs when the input method wants to
   // finish current composition session but still wants the application to
   // handle the key event. See http://crbug.com/48161 for reference.
   if (delayEventUntilAfterImeCompostion) {
     // If |delayEventUntilAfterImeCompostion| is YES, then a fake key down event
     // with windowsKeyCode == 0xE5 has already been sent to webkit.
     // So before sending the real key down event, we need to send a fake key up
     // event to balance it.
     NativeWebKeyboardEvent fakeEvent = event;
-    fakeEvent.type = blink::WebInputEvent::KeyUp;
+    fakeEvent.setType(blink::WebInputEvent::KeyUp);
     fakeEvent.skip_in_browser = true;
     widgetHost->ForwardKeyboardEvent(fakeEvent);
     // Not checking |renderWidgetHostView_->render_widget_host_| here because
     // a key event with |skip_in_browser| == true won't be handled by browser,
     // thus it won't destroy the widget.
 
     if (!editCommands_.empty()) {
       widgetHost->Send(new InputMsg_SetEditCommandsForNextKeyEvent(
           widgetHost->GetRoutingID(), editCommands_));
     }
     widgetHost->ForwardKeyboardEvent(event);
 
     // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
     // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
     // be set to NULL. So we check it here and return immediately if it's NULL.
     if (!renderWidgetHostView_->render_widget_host_)
       return;
   }
 
   const NSUInteger kCtrlCmdKeyMask = NSControlKeyMask | NSCommandKeyMask;
   // Only send a corresponding key press event if there is no marked text.
   if (!hasMarkedText_) {
     if (!textInserted && textToBeInserted_.length() == 1) {
       // If a single character was inserted, then we just send it as a keypress
       // event.
-      event.type = blink::WebInputEvent::Char;
+      event.setType(blink::WebInputEvent::Char);
       event.text[0] = textToBeInserted_[0];
       event.text[1] = 0;
       event.skip_in_browser = true;
       widgetHost->ForwardKeyboardEvent(event);
     } else if ((!textInserted || delayEventUntilAfterImeCompostion) &&
                event.text[0] != '\0' &&
                (([theEvent modifierFlags] & kCtrlCmdKeyMask) ||
                 (hasEditCommands_ && editCommands_.empty()))) {
       // We don't get insertText: calls if ctrl or cmd is down, or the key event
       // generates an insert command. So synthesize a keypress event for these
       // cases, unless the key event generated any other command.
-      event.type = blink::WebInputEvent::Char;
+      event.setType(blink::WebInputEvent::Char);
       event.skip_in_browser = true;
       widgetHost->ForwardKeyboardEvent(event);
     }
   }
 
   // Possibly autohide the cursor.
   if ([RenderWidgetHostViewCocoa shouldAutohideCursorForEvent:theEvent])
     [NSCursor setHiddenUntilMouseMoves:YES];
 }
 
@@ skipping 40 matching lines @@
 
 - (void)endGestureWithEvent:(NSEvent*)event {
   [responderDelegate_ endGestureWithEvent:event];
   gestureBeginEvent_.reset();
 
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
   if (gestureBeginPinchSent_) {
     WebGestureEvent endEvent(WebGestureEventBuilder::Build(event, self));
-    endEvent.type = WebInputEvent::GesturePinchEnd;
+    endEvent.setType(WebInputEvent::GesturePinchEnd);
     renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(endEvent);
     gestureBeginPinchSent_ = NO;
   }
 }
 
 - (void)touchesMovedWithEvent:(NSEvent*)event {
   [responderDelegate_ touchesMovedWithEvent:event];
 }
 
 - (void)touchesBeganWithEvent:(NSEvent*)event {
@@ skipping 197 matching lines @@
 
   if (!pinchHasReachedZoomThreshold_) {
       pinchUnusedAmount_ *= (1 + [event magnification]);
       if (pinchUnusedAmount_ < 0.667 || pinchUnusedAmount_ > 1.5)
           pinchHasReachedZoomThreshold_ = true;
   }
 
   // Send a GesturePinchBegin event if none has been sent yet.
   if (!gestureBeginPinchSent_) {
     WebGestureEvent beginEvent(*gestureBeginEvent_);
-    beginEvent.type = WebInputEvent::GesturePinchBegin;
+    beginEvent.setType(WebInputEvent::GesturePinchBegin);
     renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(beginEvent);
     gestureBeginPinchSent_ = YES;
   }
 
   // Send a GesturePinchUpdate event.
   WebGestureEvent updateEvent = WebGestureEventBuilder::Build(event, self);
   updateEvent.data.pinchUpdate.zoomDisabled = !pinchHasReachedZoomThreshold_;
   renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(updateEvent);
 }
 
@@ skipping 700 matching lines @@
 
 - (void)viewDidMoveToWindow {
   if ([self window])
     [self updateScreenProperties];
   renderWidgetHostView_->browser_compositor_->SetNSViewAttachedToWindow(
       [self window]);
 
   // If we switch windows (or are removed from the view hierarchy), cancel any
   // open mouse-downs.
   if (hasOpenMouseDown_) {
-    WebMouseEvent event;
-    event.type = WebInputEvent::MouseUp;
+    WebMouseEvent event(WebInputEvent::MouseUp, WebInputEvent::NoModifiers,
+                        ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
     event.button = WebMouseEvent::Button::Left;
     renderWidgetHostView_->ForwardMouseEvent(event);
 
     hasOpenMouseDown_ = NO;
   }
 }
 
 - (void)viewDidChangeBackingProperties {
   NSScreen* screen = [[self window] screen];
   if (screen) {
@@ skipping 172 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end