Introduce RootWindowHostDelegate. The RootWindowHost performs most of its communication with RootWi…

ui/aura/root_window.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 UI_AURA_ROOT_WINDOW_H_
 #define UI_AURA_ROOT_WINDOW_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/client/capture_delegate.h"
+#include "ui/aura/root_window_host_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
@@ skipping 44 matching lines @@
   RootWindow* root_window_;
   DISALLOW_COPY_AND_ASSIGN(CompositorLock);
 };
 
 // RootWindow is responsible for hosting a set of windows.
 class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
                                public ui::CompositorObserver,
                                public Window,
                                public ui::GestureEventHelper,
                                public ui::LayerAnimationObserver,
-                               public aura::client::CaptureDelegate {
+                               public aura::client::CaptureDelegate,
+                               public aura::RootWindowHostDelegate {
  public:
   explicit RootWindow(const gfx::Rect& initial_bounds);
   virtual ~RootWindow();
 
   static RootWindow* GetForAcceleratedWidget(gfx::AcceleratedWidget widget);
 
   static void set_hide_host_cursor(bool hide) {
     hide_host_cursor_ = hide;
   }
   static bool hide_host_cursor() {
     return hide_host_cursor_;
   }
 
   ui::Compositor* compositor() { return compositor_.get(); }
   gfx::NativeCursor last_cursor() const { return last_cursor_; }
   Window* mouse_pressed_handler() { return mouse_pressed_handler_; }
   bool cursor_shown() const { return cursor_shown_; }
 
   void set_focus_manager(FocusManager* focus_manager) {
     focus_manager_ = focus_manager;
   }
 
   // Initializes the root window.
   void Init();
 
   // Shows the root window host.
   void ShowRootWindow();
 
+  RootWindowHostDelegate* AsRootWindowHostDelegate();
+
   // Sets the size of the root window.
   void SetHostSize(const gfx::Size& size_in_pixel);
   gfx::Size GetHostSize() const;
 
   // Sets the bounds of the host window.
   void SetHostBounds(const gfx::Rect& size_in_pixel);
 
   // Returns where the RootWindow is on screen.
   gfx::Point GetHostOrigin() const;
 
@@ skipping 11 matching lines @@
 
   // Clips the cursor movement to the root_window.
   bool ConfineCursorToWindow();
 
   // Draws the necessary set of windows.
   void Draw();
 
   // Draw the whole screen.
   void ScheduleFullDraw();
 
-  // Handles a mouse event. Returns true if handled.
-  bool DispatchMouseEvent(MouseEvent* event);
-
-  // Handles a key event. Returns true if handled.
-  bool DispatchKeyEvent(KeyEvent* event);
-
-  // Handles a scroll event. Returns true if handled.
-  bool DispatchScrollEvent(ScrollEvent* event);
-
-  // Handles a touch event. Returns true if handled.
-  bool DispatchTouchEvent(TouchEvent* event);
-
   // Handles a gesture event. Returns true if handled. Unlike the other
   // event-dispatching function (e.g. for touch/mouse/keyboard events), gesture
   // events are dispatched from GestureRecognizer instead of RootWindowHost.
   bool DispatchGestureEvent(GestureEvent* event);
 
-  // Called when the host changes size.
-  void OnHostResized(const gfx::Size& size_in_pixel);
-
   // Invoked when |window| is being destroyed.
   void OnWindowDestroying(Window* window);
 
   // Invoked when |window|'s bounds have changed. |contained_mouse| indicates if
   // the bounds before change contained the |last_moust_location()|.
   void OnWindowBoundsChanged(Window* window, bool contained_mouse);
 
   // Invoked when |window|'s visibility is changed.
   void OnWindowVisibilityChanged(Window* window, bool is_visible);
 
@@ skipping 142 matching lines @@
   virtual bool DispatchCancelTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
   // Overridden from ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(
       ui::LayerAnimationSequence* animation) OVERRIDE;
   virtual void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* animation) OVERRIDE;
   virtual void OnLayerAnimationAborted(
       ui::LayerAnimationSequence* animation) OVERRIDE;
 
+  // Overridden from aura::RootWindowHostDelegate:
+  virtual bool OnHostKeyEvent(KeyEvent* event) OVERRIDE;
+  virtual bool OnHostMouseEvent(MouseEvent* event) OVERRIDE;
+  virtual bool OnHostScrollEvent(ScrollEvent* event) OVERRIDE;
+  virtual bool OnHostTouchEvent(TouchEvent* event) OVERRIDE;
+  virtual void OnHostLostCapture() OVERRIDE;
+  virtual void OnHostPaint() OVERRIDE;
+  virtual void OnHostResized(const gfx::Size& size) OVERRIDE;
+  virtual float GetDeviceScaleFactor() OVERRIDE;
+  virtual RootWindow* AsRootWindow() OVERRIDE;
+
   // We hold and aggregate mouse drags as a way of throttling resizes when
   // HoldMouseMoves() is called. The following methods are used to dispatch held
   // and newly incoming mouse events, typically when an event other than a mouse
   // drag needs dispatching or a matching ReleaseMouseMoves() is called.
   // NOTE: because these methods dispatch events from RootWindowHost the
   // coordinates are in terms of the root.
   bool DispatchMouseEventImpl(MouseEvent* event);
   bool DispatchMouseEventToTarget(MouseEvent* event, Window* target);
   void DispatchHeldMouseMove();
 
@@ skipping 64 matching lines @@
 
   CompositorLock* compositor_lock_;
   bool draw_on_compositor_unlock_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindow);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_ROOT_WINDOW_H_