Refactor EventHandler out of RenderWidgetHostViewAura

content/browser/renderer_host/render_widget_host_view_aura.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 23 matching lines @@
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_aura.h"
 #include "content/browser/renderer_host/input/touch_selection_controller_client_aura.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
+#include "content/browser/renderer_host/render_widget_host_view_event_handler.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/input_messages.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/text_input_state.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
@@ skipping 61 matching lines @@
 using gfx::SkIRectToRect;
 
 using blink::WebInputEvent;
 using blink::WebGestureEvent;
 using blink::WebTouchEvent;
 
 namespace content {
 
 namespace {
 
-// In mouse lock mode, we need to prevent the (invisible) cursor from hitting
-// the border of the view, in order to get valid movement information. However,
-// forcing the cursor back to the center of the view after each mouse move
-// doesn't work well. It reduces the frequency of useful mouse move messages
-// significantly. Therefore, we move the cursor to the center of the view only
-// if it approaches the border. |kMouseLockBorderPercentage| specifies the width
-// of the border area, in percentage of the corresponding dimension.
-const int kMouseLockBorderPercentage = 15;
-
 // When accelerated compositing is enabled and a widget resize is pending,
 // we delay further resizes of the UI. The following constant is the maximum
 // length of time that we should delay further UI resizes while waiting for a
 // resized frame from a renderer.
 const int kResizeLockTimeoutMs = 67;
 
 #if defined(OS_WIN)
-// A callback function for EnumThreadWindows to enumerate and dismiss
-// any owned popup windows.
-BOOL CALLBACK DismissOwnedPopups(HWND window, LPARAM arg) {
-  const HWND toplevel_hwnd = reinterpret_cast<HWND>(arg);
 
-  if (::IsWindowVisible(window)) {
-    const HWND owner = ::GetWindow(window, GW_OWNER);
-    if (toplevel_hwnd == owner) {
-      ::PostMessage(window, WM_CANCELMODE, 0, 0);
-    }
-  }
-
-  return TRUE;
-}
-#endif
-
-// We don't mark these as handled so that they're sent back to the
-// DefWindowProc so it can generate WM_APPCOMMAND as necessary.
-bool IsXButtonUpEvent(const ui::MouseEvent* event) {
-#if defined(OS_WIN)
-  switch (event->native_event().message) {
-    case WM_XBUTTONUP:
-    case WM_NCXBUTTONUP:
-      return true;
-  }
-#endif
-  return false;
-}
-
-bool IsFractionalScaleFactor(float scale_factor) {
-  return (scale_factor - static_cast<int>(scale_factor)) > 0;
-}
-
-// Reset unchanged touch point to StateStationary for touchmove and
-// touchcancel.
-void MarkUnchangedTouchPointsAsStationary(
-    blink::WebTouchEvent* event,
-    int changed_touch_id) {
-  if (event->type == blink::WebInputEvent::TouchMove ||
-      event->type == blink::WebInputEvent::TouchCancel) {
-    for (size_t i = 0; i < event->touchesLength; ++i) {
-      if (event->touches[i].id != changed_touch_id)
-        event->touches[i].state = blink::WebTouchPoint::StateStationary;
-    }
-  }
-}
-
-gfx::Point GetScreenLocationFromEvent(const ui::LocatedEvent& event) {
-  aura::Window* root =
-      static_cast<aura::Window*>(event.target())->GetRootWindow();
-  aura::client::ScreenPositionClient* spc =
-      aura::client::GetScreenPositionClient(root);
-  if (!spc)
-    return event.root_location();
-
-  gfx::Point screen_location(event.root_location());
-  spc->ConvertPointToScreen(root, &screen_location);
-  return screen_location;
-}
-
-#if defined(OS_WIN)
 // This class implements the ui::OnScreenKeyboardObserver interface
 // which provides notifications about the on screen keyboard on Windows getting
 // displayed or hidden in response to taps on editable fields.
 // It provides functionality to request blink to scroll the input field if it
 // is obscured by the on screen keyboard.
 class WinScreenKeyboardObserver : public ui::OnScreenKeyboardObserver {
  public:
   WinScreenKeyboardObserver(RenderWidgetHostImpl* host,
                             const gfx::Point& location_in_screen,
                             float scale_factor,
@@ skipping 58 matching lines @@
   // The location in DIPs where the touch occurred.
   gfx::Point location_in_screen_;
   // The current device scale factor.
   float device_scale_factor_;
 
   // The content Window.
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(WinScreenKeyboardObserver);
 };
-#endif
+#endif  // defined(OS_WIN)
 
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit
     : public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
@@ skipping 33 matching lines @@
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (target != window_ &&
       (!popup_parent_host_view_ ||
        target != popup_parent_host_view_->window_)) {
     // If we enter this code path it means that we did not receive any focus
     // lost notifications for the popup window. Ensure that blink is aware
     // of the fact that focus was lost for the host window by sending a Blur
     // notification. We also set a flag in the view indicating that we need
     // to force a Focus notification on the next mouse down.
     if (popup_parent_host_view_ && popup_parent_host_view_->host_) {
-      popup_parent_host_view_->set_focus_on_mouse_down_or_key_event_ = true;
+      popup_parent_host_view_->event_handler()
+          ->set_focus_on_mouse_down_or_key_event(true);
       popup_parent_host_view_->host_->Blur();
     }
     // Note: popup_parent_host_view_ may be NULL when there are multiple
     // popup children per view. See: RenderWidgetHostViewAura::InitAsPopup().
     Shutdown();
   }
 }
 
 // We have to implement the WindowObserver interface on a separate object
 // because clang doesn't like implementing multiple interfaces that have
@@ skipping 80 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host,
                                                    bool is_guest_view_hack)
     : host_(RenderWidgetHostImpl::From(host)),
       window_(nullptr),
       in_shutdown_(false),
       in_bounds_changed_(false),
-      is_fullscreen_(false),
       popup_parent_host_view_(nullptr),
       popup_child_host_view_(nullptr),
       is_loading_(false),
       has_composition_text_(false),
-      accept_return_character_(false),
       begin_frame_source_(nullptr),
       needs_begin_frames_(false),
       needs_flush_input_(false),
       added_frame_observer_(false),
-      synthetic_move_sent_(false),
       cursor_visibility_state_in_renderer_(UNKNOWN),
 #if defined(OS_WIN)
       legacy_render_widget_host_HWND_(nullptr),
       legacy_window_destroyed_(false),
       virtual_keyboard_requested_(false),
 #endif
       has_snapped_to_boundary_(false),
       is_guest_view_hack_(is_guest_view_hack),
-      set_focus_on_mouse_down_or_key_event_(false),
       device_scale_factor_(0.0f),
-      disable_input_event_router_for_testing_(false),
       last_active_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
       last_active_widget_routing_id_(MSG_ROUTING_NONE),
+      event_handler_(new RenderWidgetHostViewEventHandler(host_, this, this)),
       weak_ptr_factory_(this) {
   // GuestViews have two RenderWidgetHostViews and so we need to make sure
   // we don't have FrameSinkId collisions.
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   cc::FrameSinkId frame_sink_id =
       is_guest_view_hack_
           ? factory->GetContextFactory()->AllocateFrameSinkId()
           : cc::FrameSinkId(
                 base::checked_cast<uint32_t>(host_->GetProcess()->GetID()),
                 base::checked_cast<uint32_t>(host_->GetRoutingID()));
@@ skipping 66 matching lines @@
     // TODO(jhorwich): Allow multiple popup_child_host_view_ per view, or
     // similar mechanism to ensure a second popup doesn't cause the first one
     // to never get a chance to filter events. See crbug.com/160589.
     DCHECK(old_child->popup_parent_host_view_ == popup_parent_host_view_);
     if (transient_window_client) {
       transient_window_client->RemoveTransientChild(
         popup_parent_host_view_->window_, old_child->window_);
     }
     old_child->popup_parent_host_view_ = NULL;
   }
-  popup_parent_host_view_->popup_child_host_view_ = this;
+  popup_parent_host_view_->SetPopupChild(this);
   window_->SetType(ui::wm::WINDOW_TYPE_MENU);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->SetName("RenderWidgetHostViewAura");
   window_->layer()->SetColor(background_color_);
 
   // Setting the transient child allows for the popup to get mouse events when
   // in a system modal dialog. Do this before calling ParentWindowWithContext
   // below so that the transient parent is visible to WindowTreeClient.
   // This fixes crbug.com/328593.
   if (transient_window_client) {
@@ skipping 24 matching lines @@
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->SetName("RenderWidgetHostViewAura");
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   window_->layer()->SetColor(background_color_);
 
   aura::Window* parent = NULL;
   gfx::Rect bounds;
   if (reference_host_view) {
     aura::Window* reference_window =
         static_cast<RenderWidgetHostViewAura*>(reference_host_view)->window_;
-    if (reference_window) {
-      host_tracker_.reset(new aura::WindowTracker);
-      host_tracker_->Add(reference_window);
-    }
+    event_handler_->TrackHost(reference_window);
     display::Display display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(reference_window);
     parent = reference_window->GetRootWindow();
     bounds = display.bounds();
   }
   aura::client::ParentWindowWithContext(window_, parent, bounds);
   Show();
   Focus();
 
   const display::Display display =
@@ skipping 157 matching lines @@
 
 const cc::BeginFrameArgs& RenderWidgetHostViewAura::LastUsedBeginFrameArgs()
     const {
   return last_begin_frame_args_;
 }
 
 void RenderWidgetHostViewAura::OnBeginFrameSourcePausedChanged(bool paused) {
   // Only used on Android WebView.
 }
 
-void RenderWidgetHostViewAura::SetKeyboardFocus() {
-#if defined(OS_WIN)
-  if (CanFocus()) {
-    aura::WindowTreeHost* host = window_->GetHost();
-    if (host) {
-      gfx::AcceleratedWidget hwnd = host->GetAcceleratedWidget();
-      if (!(::GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_NOACTIVATE))
-        ::SetFocus(hwnd);
-    }
-  }
-#endif
-  // TODO(wjmaclean): can host_ ever be null?
-  if (host_ && set_focus_on_mouse_down_or_key_event_) {
-    set_focus_on_mouse_down_or_key_event_ = false;
-    host_->Focus();
-  }
-}
-
 RenderFrameHostImpl* RenderWidgetHostViewAura::GetFocusedFrame() {
   RenderViewHost* rvh = RenderViewHost::From(host_);
   if (!rvh)
     return nullptr;
   FrameTreeNode* focused_frame =
       rvh->GetDelegate()->GetFrameTree()->GetFocusedFrame();
   if (!focused_frame)
     return nullptr;
 
   return focused_frame->current_frame_host();
 }
 
-bool RenderWidgetHostViewAura::CanRendererHandleEvent(
-    const ui::MouseEvent* event,
-    bool mouse_locked,
-    bool selection_popup) const {
-  if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED)
-    return false;
-
-  if (event->type() == ui::ET_MOUSE_EXITED) {
-    if (mouse_locked || selection_popup)
-      return false;
-#if defined(OS_WIN)
-    // Don't forward the mouse leave message which is received when the context
-    // menu is displayed by the page. This confuses the page and causes state
-    // changes.
-    if (IsShowingContextMenu())
-      return false;
-#endif
-    return true;
-  }
-
-#if defined(OS_WIN)
-  // Renderer cannot handle WM_XBUTTON or NC events.
-  switch (event->native_event().message) {
-    case WM_XBUTTONDOWN:
-    case WM_XBUTTONUP:
-    case WM_XBUTTONDBLCLK:
-    case WM_NCMOUSELEAVE:
-    case WM_NCMOUSEMOVE:
-    case WM_NCLBUTTONDOWN:
-    case WM_NCLBUTTONUP:
-    case WM_NCLBUTTONDBLCLK:
-    case WM_NCRBUTTONDOWN:
-    case WM_NCRBUTTONUP:
-    case WM_NCRBUTTONDBLCLK:
-    case WM_NCMBUTTONDOWN:
-    case WM_NCMBUTTONUP:
-    case WM_NCMBUTTONDBLCLK:
-    case WM_NCXBUTTONDOWN:
-    case WM_NCXBUTTONUP:
-    case WM_NCXBUTTONDBLCLK:
-      return false;
-    default:
-      break;
-  }
-#elif defined(USE_X11)
-  // Renderer only supports standard mouse buttons, so ignore programmable
-  // buttons.
-  switch (event->type()) {
-    case ui::ET_MOUSE_PRESSED:
-    case ui::ET_MOUSE_RELEASED: {
-      const int kAllowedButtons = ui::EF_LEFT_MOUSE_BUTTON |
-                                  ui::EF_MIDDLE_MOUSE_BUTTON |
-                                  ui::EF_RIGHT_MOUSE_BUTTON;
-      return (event->flags() & kAllowedButtons) != 0;
-    }
-    default:
-      break;
-  }
-#endif
-  return true;
-}
-
-bool RenderWidgetHostViewAura::ShouldRouteEvent(const ui::Event* event) const {
-  // We should route an event in two cases:
-  // 1) Mouse events are routed only if cross-process frames are possible.
-  // 2) Touch events are always routed. In the absence of a BrowserPlugin
-  //    we expect the routing to always send the event to this view. If
-  //    one or more BrowserPlugins are present, then the event may be targeted
-  //    to one of them, or this view. This allows GuestViews to have access to
-  //    them while still forcing pinch-zoom to be handled by the top-level
-  //    frame. TODO(wjmaclean): At present, this doesn't work for OOPIF, but
-  //    it should be a simple extension to modify RenderWidgetHostViewChildFrame
-  //    in a similar manner to RenderWidgetHostViewGuest.
-  bool result = host_->delegate() && host_->delegate()->GetInputEventRouter() &&
-                !disable_input_event_router_for_testing_;
-  // ScrollEvents get transformed into MouseWheel events, and so are treated
-  // the same as mouse events for routing purposes.
-  if (event->IsMouseEvent() || event->type() == ui::ET_SCROLL)
-    result = result && SiteIsolationPolicy::AreCrossProcessFramesPossible();
-  return result;
-}
-
 void RenderWidgetHostViewAura::HandleParentBoundsChanged() {
   SnapToPhysicalPixelBoundary();
 #if defined(OS_WIN)
   if (legacy_render_widget_host_HWND_) {
     legacy_render_widget_host_HWND_->SetBounds(
         window_->GetBoundsInRootWindow());
   }
 #endif
   if (!in_shutdown_) {
     // Send screen rects through the delegate if there is one. Not every
@@ skipping 37 matching lines @@
 }
 
 void RenderWidgetHostViewAura::SetBackgroundColor(SkColor color) {
   RenderWidgetHostViewBase::SetBackgroundColor(color);
   bool opaque = GetBackgroundOpaque();
   host_->SetBackgroundOpaque(opaque);
   window_->layer()->SetFillsBoundsOpaquely(opaque);
   window_->layer()->SetColor(color);
 }
 
+bool RenderWidgetHostViewAura::IsMouseLocked() {
+  return event_handler_->mouse_locked();
+}
+
 gfx::Size RenderWidgetHostViewAura::GetVisibleViewportSize() const {
   gfx::Rect requested_rect(GetRequestedRendererSize());
   requested_rect.Inset(insets_);
   return requested_rect.size();
 }
 
 void RenderWidgetHostViewAura::SetInsets(const gfx::Insets& insets) {
   if (insets != insets_) {
     insets_ = insets;
     host_->WasResized();
@@ skipping 344 matching lines @@
 gfx::NativeViewAccessible
 RenderWidgetHostViewAura::AccessibilityGetNativeViewAccessible() {
 #if defined(OS_WIN)
   if (legacy_render_widget_host_HWND_)
     return legacy_render_widget_host_HWND_->window_accessible();
 #endif
   return NULL;
 }
 
 bool RenderWidgetHostViewAura::LockMouse() {
-  aura::Window* root_window = window_->GetRootWindow();
-  if (!root_window)
-    return false;
-
-  if (mouse_locked_)
-    return true;
-
-  mouse_locked_ = true;
-#if !defined(OS_WIN)
-  window_->SetCapture();
-#else
-  UpdateMouseLockRegion();
-#endif
-  aura::client::CursorClient* cursor_client =
-      aura::client::GetCursorClient(root_window);
-  if (cursor_client) {
-    cursor_client->HideCursor();
-    cursor_client->LockCursor();
-  }
-
-  if (ShouldMoveToCenter()) {
-    synthetic_move_sent_ = true;
-    window_->MoveCursorTo(gfx::Rect(window_->bounds().size()).CenterPoint());
-  }
-  tooltip_disabler_.reset(new aura::client::ScopedTooltipDisabler(root_window));
-  return true;
+  return event_handler_->LockMouse();
 }
 
 void RenderWidgetHostViewAura::UnlockMouse() {
-  tooltip_disabler_.reset();
-
-  aura::Window* root_window = window_->GetRootWindow();
-  if (!mouse_locked_ || !root_window)
-    return;
-
-  mouse_locked_ = false;
-
-  if (window_->HasCapture())
-    window_->ReleaseCapture();
-
-#if defined(OS_WIN)
-  ::ClipCursor(NULL);
-#endif
-
-  // Ensure that the global mouse position is updated here to its original
-  // value. If we don't do this then the synthesized mouse move which is posted
-  // after the cursor is moved ends up getting a large movement delta which is
-  // not what sites expect. The delta is computed in the
-  // ModifyEventMovementAndCoords function.
-  global_mouse_position_ = unlocked_global_mouse_position_;
-  window_->MoveCursorTo(unlocked_mouse_position_);
-
-  aura::client::CursorClient* cursor_client =
-      aura::client::GetCursorClient(root_window);
-  if (cursor_client) {
-    cursor_client->UnlockCursor();
-    cursor_client->ShowCursor();
-  }
-
-  host_->LostMouseLock();
+  event_handler_->UnlockMouse();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::TextInputClient implementation:
 void RenderWidgetHostViewAura::SetCompositionText(
     const ui::CompositionText& composition) {
   if (!text_input_manager_ || !text_input_manager_->GetActiveWidget())
     return;
 
   // TODO(suzhe): convert both renderer_host and renderer to use
@@ skipping 49 matching lines @@
 }
 
 void RenderWidgetHostViewAura::InsertChar(const ui::KeyEvent& event) {
   if (popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab()) {
     popup_child_host_view_->InsertChar(event);
     return;
   }
 
   // Ignore character messages for VKEY_RETURN sent on CTRL+M. crbug.com/315547
   // TODO(wjmaclean): can host_ ever be null?
-  if (host_ &&
-      (accept_return_character_ || event.GetCharacter() != ui::VKEY_RETURN)) {
+  if (host_ && (event_handler_->accept_return_character() ||
+                event.GetCharacter() != ui::VKEY_RETURN)) {
     // Send a blink::WebInputEvent::Char event to |host_|.
     ForwardKeyboardEvent(NativeWebKeyboardEvent(event, event.GetCharacter()));
   }
 }
 
 ui::TextInputType RenderWidgetHostViewAura::GetTextInputType() const {
   if (text_input_manager_ && text_input_manager_->GetTextInputState())
     return text_input_manager_->GetTextInputState()->type;
   return ui::TEXT_INPUT_TYPE_NONE;
 }
@@ skipping 348 matching lines @@
   return false;
 }
 
 void RenderWidgetHostViewAura::GetHitTestMask(gfx::Path* mask) const {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::EventHandler implementation:
 
 void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
-  TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnKeyEvent");
-
-  if (popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab()) {
-    popup_child_host_view_->OnKeyEvent(event);
-    if (event->handled())
-      return;
-  }
-
-  // We need to handle the Escape key for Pepper Flash.
-  if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
-    // Focus the window we were created from.
-    if (host_tracker_.get() && !host_tracker_->windows().empty()) {
-      aura::Window* host = *(host_tracker_->windows().begin());
-      aura::client::FocusClient* client = aura::client::GetFocusClient(host);
-      if (client) {
-        // Calling host->Focus() may delete |this|. We create a local observer
-        // for that. In that case we exit without further access to any members.
-        aura::WindowTracker tracker;
-        aura::Window* window = window_;
-        tracker.Add(window);
-        host->Focus();
-        if (!tracker.Contains(window)) {
-          event->SetHandled();
-          return;
-        }
-      }
-    }
-    Shutdown();
-  } else {
-    if (event->key_code() == ui::VKEY_RETURN) {
-      // Do not forward return key release events if no press event was handled.
-      if (event->type() == ui::ET_KEY_RELEASED && !accept_return_character_)
-        return;
-      // Accept return key character events between press and release events.
-      accept_return_character_ = event->type() == ui::ET_KEY_PRESSED;
-    }
-
-    // Call SetKeyboardFocus() for not only ET_KEY_PRESSED but also
-    // ET_KEY_RELEASED. If a user closed the hotdog menu with ESC key press,
-    // we need to notify focus to Blink on ET_KEY_RELEASED for ESC key.
-    SetKeyboardFocus();
-    // We don't have to communicate with an input method here.
-    NativeWebKeyboardEvent webkit_event(*event);
-    ForwardKeyboardEvent(webkit_event);
-  }
-  event->SetHandled();
+  event_handler_->OnKeyEvent(event);
 }
 
 void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
-  TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnMouseEvent");
-
-  ForwardMouseEventToParent(event);
-  // TODO(mgiuca): Return if event->handled() returns true. This currently
-  // breaks drop-down lists which means something is incorrectly setting
-  // event->handled to true (http://crbug.com/577983).
-
-  if (mouse_locked_) {
-    aura::client::CursorClient* cursor_client =
-        aura::client::GetCursorClient(window_->GetRootWindow());
-    DCHECK(!cursor_client || !cursor_client->IsCursorVisible());
-
-    if (event->type() == ui::ET_MOUSEWHEEL) {
-      blink::WebMouseWheelEvent mouse_wheel_event =
-          ui::MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent&>(*event),
-                                     base::Bind(&GetScreenLocationFromEvent));
-      if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
-        host_->ForwardWheelEvent(mouse_wheel_event);
-      return;
-    }
-
-    gfx::Point center(gfx::Rect(window_->bounds().size()).CenterPoint());
-
-    // If we receive non client mouse messages while we are in the locked state
-    // it probably means that the mouse left the borders of our window and
-    // needs to be moved back to the center.
-    if (event->flags() & ui::EF_IS_NON_CLIENT) {
-      synthetic_move_sent_ = true;
-      window_->MoveCursorTo(center);
-      return;
-    }
-
-    blink::WebMouseEvent mouse_event =
-        ui::MakeWebMouseEvent(*event, base::Bind(&GetScreenLocationFromEvent));
-
-    bool is_move_to_center_event = (event->type() == ui::ET_MOUSE_MOVED ||
-        event->type() == ui::ET_MOUSE_DRAGGED) &&
-        mouse_event.x == center.x() && mouse_event.y == center.y();
-
-    // For fractional scale factors, the conversion from pixels to dip and
-    // vice versa could result in off by 1 or 2 errors which hurts us because
-    // we want to avoid sending the artificial move to center event to the
-    // renderer. Sending the move to center to the renderer cause the cursor
-    // to bounce around the center of the screen leading to the lock operation
-    // not working correctly.
-    // Workaround is to treat a mouse move or drag event off by at most 2 px
-    // from the center as a move to center event.
-    if (synthetic_move_sent_ &&
-        IsFractionalScaleFactor(current_device_scale_factor_)) {
-      if (event->type() == ui::ET_MOUSE_MOVED ||
-          event->type() == ui::ET_MOUSE_DRAGGED) {
-        if ((abs(mouse_event.x - center.x()) <= 2) &&
-            (abs(mouse_event.y - center.y()) <= 2)) {
-          is_move_to_center_event = true;
-        }
-      }
-    }
-
-    ModifyEventMovementAndCoords(*event, &mouse_event);
-
-    bool should_not_forward = is_move_to_center_event && synthetic_move_sent_;
-    if (should_not_forward) {
-      synthetic_move_sent_ = false;
-    } else {
-      // Check if the mouse has reached the border and needs to be centered.
-      if (ShouldMoveToCenter()) {
-        synthetic_move_sent_ = true;
-        window_->MoveCursorTo(center);
-      }
-      bool is_selection_popup = popup_child_host_view_ &&
-          popup_child_host_view_->NeedsInputGrab();
-      // Forward event to renderer.
-      if (CanRendererHandleEvent(event, mouse_locked_, is_selection_popup) &&
-          !(event->flags() & ui::EF_FROM_TOUCH)) {
-        host_->ForwardMouseEvent(mouse_event);
-        // Ensure that we get keyboard focus on mouse down as a plugin window
-        // may have grabbed keyboard focus.
-        if (event->type() == ui::ET_MOUSE_PRESSED)
-          SetKeyboardFocus();
-      }
-    }
-    return;
-  }
-
-  // As the overscroll is handled during scroll events from the trackpad, the
-  // RWHVA window is transformed by the overscroll controller. This transform
-  // triggers a synthetic mouse-move event to be generated (by the aura
-  // RootWindow). But this event interferes with the overscroll gesture. So,
-  // ignore such synthetic mouse-move events if an overscroll gesture is in
-  // progress.
-  if (overscroll_controller_ &&
-      overscroll_controller_->overscroll_mode() != OVERSCROLL_NONE &&
-      event->flags() & ui::EF_IS_SYNTHESIZED &&
-      (event->type() == ui::ET_MOUSE_ENTERED ||
-       event->type() == ui::ET_MOUSE_EXITED ||
-       event->type() == ui::ET_MOUSE_MOVED)) {
-    event->StopPropagation();
-    return;
-  }
-
-  if (event->type() == ui::ET_MOUSEWHEEL) {
-#if defined(OS_WIN)
-    // We get mouse wheel/scroll messages even if we are not in the foreground.
-    // So here we check if we have any owned popup windows in the foreground and
-    // dismiss them.
-    aura::WindowTreeHost* host = window_->GetHost();
-    if (host) {
-      HWND parent = host->GetAcceleratedWidget();
-      HWND toplevel_hwnd = ::GetAncestor(parent, GA_ROOT);
-      EnumThreadWindows(GetCurrentThreadId(),
-                        DismissOwnedPopups,
-                        reinterpret_cast<LPARAM>(toplevel_hwnd));
-    }
-#endif
-    blink::WebMouseWheelEvent mouse_wheel_event =
-        ui::MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent&>(*event),
-                                   base::Bind(&GetScreenLocationFromEvent));
-    if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0) {
-      if (ShouldRouteEvent(event)) {
-        host_->delegate()->GetInputEventRouter()->RouteMouseWheelEvent(
-            this, &mouse_wheel_event, *event->latency());
-      } else {
-        ProcessMouseWheelEvent(mouse_wheel_event, *event->latency());
-      }
-    }
-  } else {
-    bool is_selection_popup =
-        popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab();
-    if (CanRendererHandleEvent(event, mouse_locked_, is_selection_popup) &&
-        !(event->flags() & ui::EF_FROM_TOUCH)) {
-      // Confirm existing composition text on mouse press, to make sure
-      // the input caret won't be moved with an ongoing composition text.
-      if (event->type() == ui::ET_MOUSE_PRESSED)
-        FinishImeCompositionSession();
-
-      blink::WebMouseEvent mouse_event = ui::MakeWebMouseEvent(
-          *event, base::Bind(&GetScreenLocationFromEvent));
-      ModifyEventMovementAndCoords(*event, &mouse_event);
-      if (ShouldRouteEvent(event)) {
-        host_->delegate()->GetInputEventRouter()->RouteMouseEvent(
-            this, &mouse_event, *event->latency());
-      } else {
-        ProcessMouseEvent(mouse_event, *event->latency());
-      }
-
-      // Ensure that we get keyboard focus on mouse down as a plugin window may
-      // have grabbed keyboard focus.
-      if (event->type() == ui::ET_MOUSE_PRESSED)
-        SetKeyboardFocus();
-    }
-  }
-
-  switch (event->type()) {
-    case ui::ET_MOUSE_PRESSED:
-      window_->SetCapture();
-      break;
-    case ui::ET_MOUSE_RELEASED:
-      if (!NeedsMouseCapture())
-        window_->ReleaseCapture();
-      break;
-    default:
-      break;
-  }
-
-  if (!IsXButtonUpEvent(event))
-    event->SetHandled();
+  event_handler_->OnMouseEvent(event);
 }
 
 cc::FrameSinkId RenderWidgetHostViewAura::FrameSinkIdAtPoint(
     cc::SurfaceHittestDelegate* delegate,
     const gfx::Point& point,
     gfx::Point* transformed_point) {
   DCHECK(device_scale_factor_ != 0.0f);
 
   // The surface hittest happens in device pixels, so we need to convert the
   // |point| from DIPs to pixels before hittesting.
@@ skipping 73 matching lines @@
     if (rvh && rvh->GetDelegate())
       rvh->GetDelegate()->SetIsVirtualKeyboardRequested(false);
 
     DCHECK(ui::OnScreenKeyboardDisplayManager::GetInstance());
     ui::OnScreenKeyboardDisplayManager::GetInstance()->DismissVirtualKeyboard();
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) {
-  TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnScrollEvent");
-
-  if (event->type() == ui::ET_SCROLL) {
-#if !defined(OS_WIN)
-    // TODO(ananta)
-    // Investigate if this is true for Windows 8 Metro ASH as well.
-    if (event->finger_count() != 2)
-      return;
-#endif
-    blink::WebGestureEvent gesture_event = ui::MakeWebGestureEventFlingCancel();
-    // Coordinates need to be transferred to the fling cancel gesture only
-    // for Surface-targeting to ensure that it is targeted to the correct
-    // RenderWidgetHost.
-    gesture_event.x = event->x();
-    gesture_event.y = event->y();
-    blink::WebMouseWheelEvent mouse_wheel_event = ui::MakeWebMouseWheelEvent(
-        *event, base::Bind(&GetScreenLocationFromEvent));
-    if (ShouldRouteEvent(event)) {
-      host_->delegate()->GetInputEventRouter()->RouteGestureEvent(
-          this, &gesture_event, ui::LatencyInfo(ui::SourceEventType::WHEEL));
-      host_->delegate()->GetInputEventRouter()->RouteMouseWheelEvent(
-          this, &mouse_wheel_event, *event->latency());
-    } else {
-      host_->ForwardGestureEvent(gesture_event);
-      host_->ForwardWheelEventWithLatencyInfo(mouse_wheel_event,
-                                              *event->latency());
-    }
-    RecordAction(base::UserMetricsAction("TrackpadScroll"));
-  } else if (event->type() == ui::ET_SCROLL_FLING_START ||
-             event->type() == ui::ET_SCROLL_FLING_CANCEL) {
-    blink::WebGestureEvent gesture_event = ui::MakeWebGestureEvent(
-        *event, base::Bind(&GetScreenLocationFromEvent));
-    if (ShouldRouteEvent(event)) {
-      host_->delegate()->GetInputEventRouter()->RouteGestureEvent(
-          this, &gesture_event, ui::LatencyInfo(ui::SourceEventType::WHEEL));
-    } else {
-      host_->ForwardGestureEvent(gesture_event);
-    }
-    if (event->type() == ui::ET_SCROLL_FLING_START)
-      RecordAction(base::UserMetricsAction("TrackpadScrollFling"));
-  }
-
-  event->SetHandled();
+  event_handler_->OnScrollEvent(event);
 }
 
 void RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) {
-  TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnTouchEvent");
-
-  bool had_no_pointer = !pointer_state_.GetPointerCount();
-
-  // Update the touch event first.
-  if (!pointer_state_.OnTouch(*event)) {
-    event->StopPropagation();
-    return;
-  }
-
-  blink::WebTouchEvent touch_event;
-  bool handled = selection_controller_->WillHandleTouchEvent(pointer_state_);
-  if (handled) {
-    event->SetHandled();
-  } else {
-    touch_event = ui::CreateWebTouchEventFromMotionEvent(
-        pointer_state_, event->may_cause_scrolling());
-  }
-  pointer_state_.CleanupRemovedTouchPoints(*event);
-
-  if (handled)
-    return;
-
-  if (had_no_pointer)
-    selection_controller_client_->OnTouchDown();
-  if (!pointer_state_.GetPointerCount())
-    selection_controller_client_->OnTouchUp();
-
-  // It is important to always mark events as being handled asynchronously when
-  // they are forwarded. This ensures that the current event does not get
-  // processed by the gesture recognizer before events currently awaiting
-  // dispatch in the touch queue.
-  event->DisableSynchronousHandling();
-
-  // Set unchanged touch point to StateStationary for touchmove and
-  // touchcancel to make sure only send one ack per WebTouchEvent.
-  MarkUnchangedTouchPointsAsStationary(&touch_event, event->touch_id());
-  if (ShouldRouteEvent(event)) {
-    host_->delegate()->GetInputEventRouter()->RouteTouchEvent(
-        this, &touch_event, *event->latency());
-  } else {
-    ProcessTouchEvent(touch_event, *event->latency());
-  }
+  event_handler_->OnTouchEvent(event);
 }
 
 void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
-  TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnGestureEvent");
-
-  if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
-      event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
-      event->type() == ui::ET_GESTURE_PINCH_END) && !pinch_zoom_enabled_) {
-    event->SetHandled();
-    return;
-  }
-
-  HandleGestureForTouchSelection(event);
-  if (event->handled())
-    return;
-
-  // Confirm existing composition text on TAP gesture, to make sure the input
-  // caret won't be moved with an ongoing composition text.
-  if (event->type() == ui::ET_GESTURE_TAP)
-    FinishImeCompositionSession();
-
-  blink::WebGestureEvent gesture =
-      ui::MakeWebGestureEvent(*event, base::Bind(&GetScreenLocationFromEvent));
-  if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
-    // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
-    // event to stop any in-progress flings.
-    blink::WebGestureEvent fling_cancel = gesture;
-    fling_cancel.type = blink::WebInputEvent::GestureFlingCancel;
-    fling_cancel.sourceDevice = blink::WebGestureDeviceTouchscreen;
-    if (ShouldRouteEvent(event)) {
-      host_->delegate()->GetInputEventRouter()->RouteGestureEvent(
-          this, &fling_cancel, ui::LatencyInfo(ui::SourceEventType::TOUCH));
-    } else {
-      host_->ForwardGestureEvent(fling_cancel);
-    }
-  }
-
-  if (gesture.type != blink::WebInputEvent::Undefined) {
-    if (ShouldRouteEvent(event)) {
-      host_->delegate()->GetInputEventRouter()->RouteGestureEvent(
-          this, &gesture, *event->latency());
-    } else {
-      host_->ForwardGestureEventWithLatencyInfo(gesture, *event->latency());
-    }
-
-    if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
-        event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
-        event->type() == ui::ET_GESTURE_SCROLL_END) {
-      RecordAction(base::UserMetricsAction("TouchscreenScroll"));
-    } else if (event->type() == ui::ET_SCROLL_FLING_START) {
-      RecordAction(base::UserMetricsAction("TouchscreenScrollFling"));
-    }
-  }
-
-  // If a gesture is not processed by the webpage, then WebKit processes it
-  // (e.g. generates synthetic mouse events).
-  event->SetHandled();
+  event_handler_->OnGestureEvent(event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate() const {
   aura::WindowTreeHost* host = window_->GetHost();
   if (!host)
     return true;
   const ui::Event* event = host->dispatcher()->current_event();
@@ skipping 121 matching lines @@
     display::Screen::GetScreen()->RemoveObserver(this);
 
     // This call is usually no-op since |this| object is already removed from
     // the Aura root window and we don't have a way to get an input method
     // object associated with the window, but just in case.
     DetachFromInputMethod();
   }
   if (popup_parent_host_view_) {
     DCHECK(popup_parent_host_view_->popup_child_host_view_ == NULL ||
            popup_parent_host_view_->popup_child_host_view_ == this);
-    popup_parent_host_view_->popup_child_host_view_ = NULL;
+    popup_parent_host_view_->SetPopupChild(nullptr);
   }
   if (popup_child_host_view_) {
     DCHECK(popup_child_host_view_->popup_parent_host_view_ == NULL ||
            popup_child_host_view_->popup_parent_host_view_ == this);
     popup_child_host_view_->popup_parent_host_view_ = NULL;
   }
   event_filter_for_popup_exit_.reset();
 
 #if defined(OS_WIN)
   // The LegacyRenderWidgetHostHWND window should have been destroyed in
@@ skipping 10 matching lines @@
 
 #endif
 
   if (text_input_manager_)
     text_input_manager_->RemoveObserver(this);
 }
 
 void RenderWidgetHostViewAura::CreateAuraWindow() {
   DCHECK(!window_);
   window_ = new aura::Window(this);
+  event_handler_->set_window(window_);
   window_observer_.reset(new WindowObserver(this));
 
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   window_->set_layer_owner_delegate(delegated_frame_host_.get());
   display::Screen::GetScreen()->AddObserver(this);
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
@@ skipping 79 matching lines @@
   return popup_type_ == blink::WebPopupTypePage;
 }
 
 bool RenderWidgetHostViewAura::NeedsMouseCapture() {
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   return NeedsInputGrab();
 #endif
   return false;
 }
 
-void RenderWidgetHostViewAura::FinishImeCompositionSession() {
-  if (!has_composition_text_)
+void RenderWidgetHostViewAura::SetTooltipsEnabled(bool enable) {
+  if (enable) {
+    tooltip_disabler_.reset();
+  } else {
+    tooltip_disabler_.reset(
+        new aura::client::ScopedTooltipDisabler(window_->GetRootWindow()));
+  }
+}
+
+void RenderWidgetHostViewAura::ShowContextMenu(
+    const ContextMenuParams& params) {
+  // Use RenderViewHostDelegate to get to the WebContentsViewAura, which will
+  // actually show the disambiguation popup.
+  RenderViewHost* rvh = RenderViewHost::From(host_);
+  if (!rvh)
     return;
 
-  if (!!text_input_manager_ && !!text_input_manager_->GetActiveWidget()) {
-    text_input_manager_->GetActiveWidget()->ImeFinishComposingText(false);
-  }
-  ImeCancelComposition();
-}
+  RenderViewHostDelegate* delegate = rvh->GetDelegate();
+  if (!delegate)
+    return;
 
-void RenderWidgetHostViewAura::ModifyEventMovementAndCoords(
-    const ui::MouseEvent& ui_mouse_event,
-    blink::WebMouseEvent* event) {
-  // If the mouse has just entered, we must report zero movementX/Y. Hence we
-  // reset any global_mouse_position set previously.
-  if (ui_mouse_event.type() == ui::ET_MOUSE_ENTERED ||
-      ui_mouse_event.type() == ui::ET_MOUSE_EXITED) {
-      global_mouse_position_.SetPoint(event->globalX, event->globalY);
-  }
-
-  // Movement is computed by taking the difference of the new cursor position
-  // and the previous. Under mouse lock the cursor will be warped back to the
-  // center so that we are not limited by clipping boundaries.
-  // We do not measure movement as the delta from cursor to center because
-  // we may receive more mouse movement events before our warp has taken
-  // effect.
-  event->movementX = event->globalX - global_mouse_position_.x();
-  event->movementY = event->globalY - global_mouse_position_.y();
-
-  global_mouse_position_.SetPoint(event->globalX, event->globalY);
-
-  // Under mouse lock, coordinates of mouse are locked to what they were when
-  // mouse lock was entered.
-  if (mouse_locked_) {
-    event->x = unlocked_mouse_position_.x();
-    event->y = unlocked_mouse_position_.y();
-    event->windowX = unlocked_mouse_position_.x();
-    event->windowY = unlocked_mouse_position_.y();
-    event->globalX = unlocked_global_mouse_position_.x();
-    event->globalY = unlocked_global_mouse_position_.y();
-  } else {
-    unlocked_mouse_position_.SetPoint(event->x, event->y);
-    unlocked_global_mouse_position_.SetPoint(event->globalX, event->globalY);
-  }
+  RenderViewHostDelegateView* delegate_view = delegate->GetDelegateView();
+  if (!delegate_view)
+    return;
+  delegate_view->ShowContextMenu(GetFocusedFrame(), params);
 }
 
 void RenderWidgetHostViewAura::NotifyRendererOfCursorVisibilityState(
     bool is_visible) {
   if (host_->is_hidden() ||
       (cursor_visibility_state_in_renderer_ == VISIBLE && is_visible) ||
       (cursor_visibility_state_in_renderer_ == NOT_VISIBLE && !is_visible))
     return;
 
   cursor_visibility_state_in_renderer_ = is_visible ? VISIBLE : NOT_VISIBLE;
@@ skipping 21 matching lines @@
 
   if (snapped && snapped != window_)
     ui::SnapLayerToPhysicalPixelBoundary(snapped->layer(), window_->layer());
 
   has_snapped_to_boundary_ = true;
 }
 
 bool RenderWidgetHostViewAura::OnShowContextMenu(
     const ContextMenuParams& params) {
 #if defined(OS_WIN)
-  last_context_menu_params_.reset();
-
-  if (params.source_type == ui::MENU_SOURCE_LONG_PRESS) {
-    last_context_menu_params_.reset(new ContextMenuParams);
-    *last_context_menu_params_ = params;
-    return false;
-  }
-#endif
+  event_handler_->SetContextMenuParams(params);
+  return params.source_type != ui::MENU_SOURCE_LONG_PRESS;
+#else
   return true;
+#endif  // defined(OS_WIN)
 }
 
 void RenderWidgetHostViewAura::SetSelectionControllerClientForTest(
     std::unique_ptr<TouchSelectionControllerClientAura> client) {
   selection_controller_client_.swap(client);
   CreateSelectionController();
-  disable_input_event_router_for_testing_ = true;
 }
 
 void RenderWidgetHostViewAura::InternalSetBounds(const gfx::Rect& rect) {
   SnapToPhysicalPixelBoundary();
   // Don't recursively call SetBounds if this bounds update is the result of
   // a Window::SetBoundsInternal call.
   if (!in_bounds_changed_)
     window_->SetBounds(rect);
   host_->WasResized();
   delegated_frame_host_->WasResized();
@@ skipping 35 matching lines @@
     const gfx::Rect& clip) {
   if (!clip.IsEmpty()) {
     gfx::Rect to_paint = gfx::SubtractRects(rect, clip);
     if (!to_paint.IsEmpty())
       window_->SchedulePaintInRect(to_paint);
   } else {
     window_->SchedulePaintInRect(rect);
   }
 }
 
-bool RenderWidgetHostViewAura::ShouldMoveToCenter() {
-  gfx::Rect rect = window_->bounds();
-  rect = ConvertRectToScreen(rect);
-  int border_x = rect.width() * kMouseLockBorderPercentage / 100;
-  int border_y = rect.height() * kMouseLockBorderPercentage / 100;
-
-  return global_mouse_position_.x() < rect.x() + border_x ||
-      global_mouse_position_.x() > rect.right() - border_x ||
-      global_mouse_position_.y() < rect.y() + border_y ||
-      global_mouse_position_.y() > rect.bottom() - border_y;
-}
-
 void RenderWidgetHostViewAura::AddedToRootWindow() {
   window_->GetHost()->AddObserver(this);
   UpdateScreenInfo(window_);
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client) {
     cursor_client->AddObserver(this);
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
@@ skipping 86 matching lines @@
   ui::TouchSelectionController::Config tsc_config;
   tsc_config.max_tap_duration = base::TimeDelta::FromMilliseconds(
       ui::GestureConfiguration::GetInstance()->long_press_time_in_ms());
   tsc_config.tap_slop = ui::GestureConfiguration::GetInstance()
                             ->max_touch_move_in_pixels_for_click();
   tsc_config.enable_longpress_drag_selection = false;
   selection_controller_.reset(new ui::TouchSelectionController(
       selection_controller_client_.get(), tsc_config));
 }
 
-void RenderWidgetHostViewAura::HandleGestureForTouchSelection(
-    ui::GestureEvent* event) {
-  switch (event->type()) {
-    case ui::ET_GESTURE_LONG_PRESS:
-      if (selection_controller_->WillHandleLongPressEvent(
-              event->time_stamp(), event->location_f())) {
-        event->SetHandled();
-      }
-      break;
-    case ui::ET_GESTURE_TAP:
-      if (selection_controller_->WillHandleTapEvent(
-              event->location_f(), event->details().tap_count())) {
-        event->SetHandled();
-      }
-      break;
-    case ui::ET_GESTURE_SCROLL_BEGIN:
-      selection_controller_client_->OnScrollStarted();
-      break;
-    case ui::ET_GESTURE_SCROLL_END:
-      selection_controller_client_->OnScrollCompleted();
-      break;
-#if defined(OS_WIN)
-    case ui::ET_GESTURE_LONG_TAP: {
-      if (!last_context_menu_params_)
-        break;
-
-      std::unique_ptr<ContextMenuParams> context_menu_params =
-          std::move(last_context_menu_params_);
-
-      // On Windows we want to display the context menu when the long press
-      // gesture is released. To achieve that, we switch the saved context
-      // menu params source type to MENU_SOURCE_TOUCH. This is to ensure that
-      // the RenderWidgetHostViewAura::OnShowContextMenu function which is
-      // called from the ShowContextMenu call below, does not treat it as
-      // a context menu request coming in from the long press gesture.
-      DCHECK(context_menu_params->source_type == ui::MENU_SOURCE_LONG_PRESS);
-      context_menu_params->source_type = ui::MENU_SOURCE_TOUCH;
-
-      RenderViewHostDelegateView* delegate_view =
-          GetRenderViewHostDelegateView();
-      if (delegate_view)
-        delegate_view->ShowContextMenu(GetFocusedFrame(),
-                                       *context_menu_params);
-
-      event->SetHandled();
-      // WARNING: we may have been deleted during the call to ShowContextMenu().
-      break;
-    }
-#endif
-    default:
-      break;
-  }
-}
-
-void RenderWidgetHostViewAura::ForwardMouseEventToParent(
-    ui::MouseEvent* event) {
-  // Needed to propagate mouse event to |window_->parent()->delegate()|, but
-  // note that it might be something other than a WebContentsViewAura instance.
-  // TODO(pkotwicz): Find a better way of doing this.
-  // In fullscreen mode which is typically used by flash, don't forward
-  // the mouse events to the parent. The renderer and the plugin process
-  // handle these events.
-  if (is_fullscreen_)
-    return;
-
-  if (event->flags() & ui::EF_FROM_TOUCH)
-    return;
-
-  if (!window_->parent() || !window_->parent()->delegate())
-    return;
-
-  // Take a copy of |event|, to avoid ConvertLocationToTarget mutating the
-  // event.
-  std::unique_ptr<ui::Event> event_copy = ui::Event::Clone(*event);
-  ui::MouseEvent* mouse_event = static_cast<ui::MouseEvent*>(event_copy.get());
-  mouse_event->ConvertLocationToTarget(window_, window_->parent());
-  window_->parent()->delegate()->OnMouseEvent(mouse_event);
-  if (mouse_event->handled())
-    event->SetHandled();
-}
-
-RenderViewHostDelegateView*
-RenderWidgetHostViewAura::GetRenderViewHostDelegateView() {
-  // Use RenderViewHostDelegate to get to the WebContentsViewAura, which will
-  // actually show the disambiguation popup.
-  RenderViewHost* rvh = RenderViewHost::From(host_);
-  if (!rvh)
-    return nullptr;
-
-  RenderViewHostDelegate* delegate = rvh->GetDelegate();
-  if (!delegate)
-    return nullptr;
-
-  return delegate->GetDelegateView();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Layer* RenderWidgetHostViewAura::DelegatedFrameHostGetLayer() const {
   return window_->layer();
 }
 
 bool RenderWidgetHostViewAura::DelegatedFrameHostIsVisible() const {
   return !host_->is_hidden();
 }
@@ skipping 171 matching lines @@
   if (GetTextInputManager()
           ->GetTextSelection(focused_view)
           ->GetSelectedText(&selected_text)) {
     // Set the CLIPBOARD_TYPE_SELECTION to the ui::Clipboard.
     ui::ScopedClipboardWriter clipboard_writer(ui::CLIPBOARD_TYPE_SELECTION);
     clipboard_writer.WriteText(selected_text);
   }
 #endif  // defined(USE_X11) && !defined(OS_CHROMEOS)
 }
 
+void RenderWidgetHostViewAura::SetPopupChild(
+    RenderWidgetHostViewAura* popup_child_host_view) {
+  popup_child_host_view_ = popup_child_host_view;
+  event_handler_->SetPopupChild(
+      popup_child_host_view,
+      popup_child_host_view ? popup_child_host_view->event_handler() : nullptr);
+}
+
 }  // namespace content