Refactor EventHandler out of RenderWidgetHostViewAura

content/browser/renderer_host/render_widget_host_view_aura.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/compositor/owned_mailbox.h"
 #include "content/browser/renderer_host/delegated_frame_host.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
+#include "content/browser/renderer_host/render_widget_host_view_event_handler.h"
 #include "content/browser/renderer_host/text_input_manager.h"
 #include "content/common/content_export.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/public/common/context_menu_params.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/cursor_client_observer.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/window_delegate.h"
-#include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/display/display_observer.h"
-#include "ui/events/gestures/motion_event_aura.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/selection_bound.h"
 #include "ui/wm/public/activation_delegate.h"
 
 namespace aura {
 namespace client {
 class ScopedTooltipDisabler;
 }
 }
@@ skipping 35 matching lines @@
 class RenderFrameHostImpl;
 class RenderViewHostDelegateView;
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 class TouchSelectionControllerClientAura;
 struct TextInputState;
 
 // RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
 class CONTENT_EXPORT RenderWidgetHostViewAura
     : public RenderWidgetHostViewBase,
+      NON_EXPORTED_BASE(public RenderWidgetHostViewEventHandler::Delegate),
       public DelegatedFrameHostClient,
       public TextInputManager::Observer,
       public ui::TextInputClient,
       public display::DisplayObserver,
       public aura::WindowTreeHostObserver,
       public aura::WindowDelegate,
       public aura::client::ActivationDelegate,
       public aura::client::FocusChangeObserver,
       public aura::client::CursorClientObserver,
       public cc::BeginFrameObserver {
@@ skipping 14 matching lines @@
   gfx::NativeView GetNativeView() const override;
   gfx::NativeViewAccessible GetNativeViewAccessible() override;
   ui::TextInputClient* GetTextInputClient() override;
   bool HasFocus() const override;
   bool IsSurfaceAvailableForCopy() const override;
   void Show() override;
   void Hide() override;
   bool IsShowing() override;
   gfx::Rect GetViewBounds() const override;
   void SetBackgroundColor(SkColor color) override;
+  bool IsMouseLocked() override;
   gfx::Size GetVisibleViewportSize() const override;
   void SetInsets(const gfx::Insets& insets) override;
   void FocusedNodeTouched(const gfx::Point& location_dips_screen,
                           bool editable) override;
   void SetNeedsBeginFrames(bool needs_begin_frames) override;
 
   // Overridden from RenderWidgetHostViewBase:
   void InitAsPopup(RenderWidgetHostView* parent_host_view,
                    const gfx::Rect& pos) override;
   void InitAsFullscreen(RenderWidgetHostView* reference_host_view) override;
@@ skipping 158 matching lines @@
   // Method to indicate if this instance is shutting down or closing.
   // TODO(shrikant): Discuss around to see if it makes sense to add this method
   // as part of RenderWidgetHostView.
   bool IsClosing() const { return in_shutdown_; }
 
   // Sets whether the overscroll controller should be enabled for this page.
   void SetOverscrollControllerEnabled(bool enabled);
 
   void SnapToPhysicalPixelBoundary();
 
-  ui::TouchSelectionController* selection_controller() const {
-    return selection_controller_.get();
-  }
-
-  TouchSelectionControllerClientAura* selection_controller_client() const {
-    return selection_controller_client_.get();
-  }
-
-  OverscrollController* overscroll_controller() const {
-    return overscroll_controller_.get();
-  }
-
   // Called when the context menu is about to be displayed.
   // Returns true if the context menu should be displayed. We only return false
   // on Windows if the context menu is being displayed in response to a long
   // press gesture. On Windows we should be consistent like other apps and
   // display the menu when the touch is released.
   bool OnShowContextMenu(const ContextMenuParams& params);
 
   // Used in tests to set a mock client for touch selection controller. It will
   // create a new touch selection controller for the new client.
   void SetSelectionControllerClientForTest(
       std::unique_ptr<TouchSelectionControllerClientAura> client);
 
   // Exposed for tests.
   cc::SurfaceId SurfaceIdForTesting() const override;
 
+  // RenderWidgetHostViewEventHandler::Delegate:
+  gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const override;
+  void ForwardKeyboardEvent(const NativeWebKeyboardEvent& event) override;
+  RenderFrameHostImpl* GetFocusedFrame();
+  bool NeedsMouseCapture() override;
+  void SetTooltipsEnabled(bool enable) override;
+  void ShowContextMenu(const ContextMenuParams& params) override;
+  void Shutdown() override;
+
+  RenderWidgetHostViewEventHandler* event_handler() {
+    return event_handler_.get();
+  }
+
  protected:
   ~RenderWidgetHostViewAura() override;
 
   // Exposed for tests.
   aura::Window* window() { return window_; }
 
   DelegatedFrameHost* GetDelegatedFrameHost() const {
     return delegated_frame_host_.get();
   }
 
-  const ui::MotionEventAura& pointer_state() const { return pointer_state_; }
-
  private:
   friend class InputMethodAuraTestBase;
   friend class RenderWidgetHostViewAuraCopyRequestTest;
   friend class TestInputMethodObserver;
   FRIEND_TEST_ALL_PREFIXES(InputMethodResultAuraTest,
                            FinishImeCompositionSession);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
                            PopupRetainsCaptureAfterMouseRelease);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SetCompositionText);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventState);
@@ skipping 45 matching lines @@
   // Creates and/or updates the legacy dummy window which corresponds to
   // the bounds of the webcontents. It is needed for accessibility and
   // for scrolling to work in legacy drivers for trackpoints/trackpads, etc.
   void UpdateLegacyWin();
 
   bool UsesNativeWindowFrame() const;
 #endif
 
   ui::InputMethod* GetInputMethod() const;
 
-  // Sends shutdown request.
-  void Shutdown();
-
   // Returns whether the widget needs an input grab to work properly.
   bool NeedsInputGrab();
 
-  // Returns whether the widget needs to grab mouse capture to work properly.
-  bool NeedsMouseCapture();
-
-  // Confirm existing composition text in the webpage and ask the input method
-  // to cancel its ongoing composition session.
-  void FinishImeCompositionSession();
-
-  // This method computes movementX/Y and keeps track of mouse location for
-  // mouse lock on all mouse move events.
-  // |ui_mouse_event| contains the mouse event received.
-  // |event| contains the WebMouseEvent being modified.
-  void ModifyEventMovementAndCoords(const ui::MouseEvent& ui_mouse_event,
-                                    blink::WebMouseEvent* event);
-
   // Sends an IPC to the renderer process to communicate whether or not
   // the mouse cursor is visible anywhere on the screen.
   void NotifyRendererOfCursorVisibilityState(bool is_visible);
 
   // If |clip| is non-empty and and doesn't contain |rect| or |clip| is empty
   // SchedulePaint() is invoked for |rect|.
   void SchedulePaintIfNotInClip(const gfx::Rect& rect, const gfx::Rect& clip);
 
-  // Helper method to determine if, in mouse locked mode, the cursor should be
-  // moved to center.
-  bool ShouldMoveToCenter();
-
   // Called after |window_| is parented to a WindowEventDispatcher.
   void AddedToRootWindow();
 
   // Called prior to removing |window_| from a WindowEventDispatcher.
   void RemovingFromRootWindow();
 
   // DelegatedFrameHostClient implementation.
   ui::Layer* DelegatedFrameHostGetLayer() const override;
   bool DelegatedFrameHostIsVisible() const override;
   SkColor DelegatedFrameHostGetGutterColor(SkColor color) const override;
@@ skipping 23 matching lines @@
                               RenderWidgetHostViewBase* updated_view) override;
 
   // cc::BeginFrameObserver implementation.
   void OnBeginFrame(const cc::BeginFrameArgs& args) override;
   const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
   void OnBeginFrameSourcePausedChanged(bool paused) override;
 
   // Detaches |this| from the input method object.
   void DetachFromInputMethod();
 
-  // Before calling RenderWidgetHost::ForwardKeyboardEvent(), this method
-  // calls our keybindings handler against the event and send matched
-  // edit commands to renderer instead.
-  void ForwardKeyboardEvent(const NativeWebKeyboardEvent& event);
-
   // Dismisses a Web Popup on a mouse or touch press outside the popup and its
   // parent.
   void ApplyEventFilterForPopupExit(ui::LocatedEvent* event);
 
-  // Converts |rect| from window coordinate to screen coordinate.
-  gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const;
-
   // Converts |rect| from screen coordinate to window coordinate.
   gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const;
 
-  // Helper function to set keyboard focus to the main window.
-  void SetKeyboardFocus();
-
-  RenderFrameHostImpl* GetFocusedFrame();
-
-  // Returns true if the |event| passed in can be forwarded to the renderer.
-  bool CanRendererHandleEvent(const ui::MouseEvent* event,
-                              bool mouse_locked,
-                              bool selection_popup) const;
-
-  // Returns true when we can do SurfaceHitTesting for the event type.
-  bool ShouldRouteEvent(const ui::Event* event) const;
-
   // Called when the parent window bounds change.
   void HandleParentBoundsChanged();
 
   // Called when the parent window hierarchy for our window changes.
   void ParentHierarchyChanged();
 
   // Helper function to be called whenever new selection information is
   // received. It will update selection controller.
   void SelectionUpdated(bool is_editable,
                         bool is_empty_text_form_control,
                         const gfx::SelectionBound& start,
                         const gfx::SelectionBound& end);
 
   // Helper function to create a selection controller.
   void CreateSelectionController();
 
-  // Performs gesture handling needed for touch text selection. Sets event as
-  // handled if it should not be further processed.
-  void HandleGestureForTouchSelection(ui::GestureEvent* event);
+  // Used to set the |popup_child_host_view_| on the |popup_parent_host_view_|
+  // and to notify the |event_handler_|.
+  void SetPopupChild(RenderWidgetHostViewAura* popup_child_host_view);
 
   // Forwards a mouse event to this view's parent window delegate.
   void ForwardMouseEventToParent(ui::MouseEvent* event);
 
   // Adds/Removes frame observer based on state.
   void UpdateNeedsBeginFramesInternal();
 
-  // Returns the RenderViewHostDelegateView instance for this view. Returns
-  // NULL on failure.
-  RenderViewHostDelegateView* GetRenderViewHostDelegateView();
-
   // The model object.
   RenderWidgetHostImpl* const host_;
 
   aura::Window* window_;
 
   std::unique_ptr<DelegatedFrameHost> delegated_frame_host_;
 
   std::unique_ptr<WindowObserver> window_observer_;
 
   // Tracks the ancestors of the RWHVA window for window location changes.
   std::unique_ptr<WindowAncestorObserver> ancestor_window_observer_;
 
   // Are we in the process of closing?  Tracked so fullscreen views can avoid
   // sending a second shutdown request to the host when they lose the focus
   // after requesting shutdown for another reason (e.g. Escape key).
   bool in_shutdown_;
 
   // True if in the process of handling a window bounds changed notification.
   bool in_bounds_changed_;
 
-  // Is this a fullscreen view?
-  bool is_fullscreen_;
-
   // Our parent host view, if this is a popup.  NULL otherwise.
   RenderWidgetHostViewAura* popup_parent_host_view_;
 
   // Our child popup host. NULL if we do not have a child popup.
   RenderWidgetHostViewAura* popup_child_host_view_;
 
   class EventFilterForPopupExit;
   friend class EventFilterForPopupExit;
   std::unique_ptr<ui::EventHandler> event_filter_for_popup_exit_;
 
   // True when content is being loaded. Used to show an hourglass cursor.
   bool is_loading_;
 
   // The cursor for the page. This is passed up from the renderer.
   WebCursor current_cursor_;
 
-  // Stores the current state of the active pointers targeting this
-  // object.
-  ui::MotionEventAura pointer_state_;
-
-
   // Indicates if there is onging composition text.
   bool has_composition_text_;
 
-  // Whether return characters should be passed on to the RenderWidgetHostImpl.
-  bool accept_return_character_;
-
   // Current tooltip text.
   base::string16 tooltip_;
 
   // The begin frame source being observed.  Null if none.
   cc::BeginFrameSource* begin_frame_source_;
   cc::BeginFrameArgs last_begin_frame_args_;
 
   // Whether a request for begin frames has been issued.
   bool needs_begin_frames_;
 
   // Whether a request to flush input has been issued.
   bool needs_flush_input_;
 
   // Whether or not a frame observer has been added.
   bool added_frame_observer_;
 
-  // Used to record the last position of the mouse.
-  // While the mouse is locked, they store the last known position just as mouse
-  // lock was entered.
-  // Relative to the upper-left corner of the view.
-  gfx::Point unlocked_mouse_position_;
-  // Relative to the upper-left corner of the screen.
-  gfx::Point unlocked_global_mouse_position_;
-  // Last cursor position relative to screen. Used to compute movementX/Y.
-  gfx::Point global_mouse_position_;
-  // In mouse locked mode, we synthetically move the mouse cursor to the center
-  // of the window when it reaches the window borders to avoid it going outside.
-  // This flag is used to differentiate between these synthetic mouse move
-  // events vs. normal mouse move events.
-  bool synthetic_move_sent_;
-
-  // Used to track the state of the window we're created from. Only used when
-  // created fullscreen.
-  std::unique_ptr<aura::WindowTracker> host_tracker_;
-
   // Used to track the last cursor visibility update that was sent to the
   // renderer via NotifyRendererOfCursorVisibilityState().
   enum CursorVisibilityState {
     UNKNOWN,
     VISIBLE,
     NOT_VISIBLE,
   };
   CursorVisibilityState cursor_visibility_state_in_renderer_;
 
 #if defined(OS_WIN)
@@ skipping 18 matching lines @@
   std::unique_ptr<ContextMenuParams> last_context_menu_params_;
 
   // Set to true if we requested the on screen keyboard to be displayed.
   bool virtual_keyboard_requested_;
 
   std::unique_ptr<ui::OnScreenKeyboardObserver> keyboard_observer_;
 #endif
 
   bool has_snapped_to_boundary_;
 
-  std::unique_ptr<TouchSelectionControllerClientAura>
-      selection_controller_client_;
-  std::unique_ptr<ui::TouchSelectionController> selection_controller_;
-
-  std::unique_ptr<OverscrollController> overscroll_controller_;
-
   // The last scroll offset of the view.
   gfx::Vector2dF last_scroll_offset_;
 
   gfx::Insets insets_;
 
   std::vector<ui::LatencyInfo> software_latency_info_;
 
   std::unique_ptr<aura::client::ScopedTooltipDisabler> tooltip_disabler_;
 
   // True when this view acts as a platform view hack for a
   // RenderWidgetHostViewGuest.
   bool is_guest_view_hack_;
 
-  // This flag when set ensures that we send over a notification to blink that
-  // the current view has focus. Defaults to false.
-  bool set_focus_on_mouse_down_or_key_event_;
-
   float device_scale_factor_;
 
-  // Allows tests to send gesture events for testing without first sending a
-  // corresponding touch sequence, as would be required by
-  // RenderWidgetHostInputEventRouter.
-  bool disable_input_event_router_for_testing_;
-
   // The routing and process IDs for the last RenderWidgetHost which had a
   // TextInputState of non-NONE.
   int32_t last_active_widget_process_id_;
   int32_t last_active_widget_routing_id_;
 
+  // While this is a ui::EventHandler for targetting, |event_handler_| actually
+  // provides an implementation, and directs events to |host_|.
+  std::unique_ptr<RenderWidgetHostViewEventHandler> event_handler_;
+
   base::WeakPtrFactory<RenderWidgetHostViewAura> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_