Rename RootWindowHost* to WindowTreeHost*

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"
@@ skipping 28 matching lines @@
 class KeyEvent;
 class LayerAnimationSequence;
 class MouseEvent;
 class ScrollEvent;
 class TouchEvent;
 class ViewProp;
 }
 
 namespace aura {
 class RootWindow;
-class RootWindowHost;
+class WindowTreeHost;
 class RootWindowObserver;
 class TestScreen;
 class WindowTargeter;
 
 // RootWindow is responsible for hosting a set of windows.
 class AURA_EXPORT RootWindow : public ui::EventProcessor,
                                public ui::GestureEventHelper,
                                public ui::LayerAnimationObserver,
                                public aura::client::CaptureDelegate,
-                               public aura::RootWindowHostDelegate {
+                               public aura::WindowTreeHostDelegate {
  public:
   struct AURA_EXPORT CreateParams {
     // CreateParams with initial_bounds and default host in pixel.
     explicit CreateParams(const gfx::Rect& initial_bounds);
     ~CreateParams() {}
 
     gfx::Rect initial_bounds;
 
     // A host to use in place of the default one that RootWindow will create.
     // NULL by default.
-    RootWindowHost* host;
+    WindowTreeHost* host;
   };
 
   explicit RootWindow(const CreateParams& params);
   virtual ~RootWindow();
 
-  // Returns the RootWindowHost for the specified accelerated widget, or NULL
+  // Returns the WindowTreeHost for the specified accelerated widget, or NULL
   // if there is none associated.
   static RootWindow* GetForAcceleratedWidget(gfx::AcceleratedWidget widget);
 
   Window* window() {
     return const_cast<Window*>(const_cast<const RootWindow*>(this)->window());
   }
   const Window* window() const { return window_.get(); }
-  RootWindowHost* host() {
-    return const_cast<RootWindowHost*>(
+  WindowTreeHost* host() {
+    return const_cast<WindowTreeHost*>(
         const_cast<const RootWindow*>(this)->host());
   }
-  const RootWindowHost* host() const { return host_.get(); }
+  const WindowTreeHost* host() const { return host_.get(); }
   gfx::NativeCursor last_cursor() const { return last_cursor_; }
   Window* mouse_pressed_handler() { return mouse_pressed_handler_; }
   Window* mouse_moved_handler() { return mouse_moved_handler_; }
 
   // Initializes the root window.
   void Init();
 
   // Stop listening events in preparation for shutdown.
   void PrepareForShutdown();
 
   // Repost event for re-processing. Used when exiting context menus.
   // We only support the ET_MOUSE_PRESSED and ET_GESTURE_TAP_DOWN event
   // types (although the latter is currently a no-op).
   void RepostEvent(const ui::LocatedEvent& event);
 
-  RootWindowHostDelegate* AsRootWindowHostDelegate();
+  WindowTreeHostDelegate* AsWindowTreeHostDelegate();
 
   // Gets/sets the size of the host window.
   void SetHostSize(const gfx::Size& size_in_pixel);
 
   // Sets the bounds of the host window.
   void SetHostBounds(const gfx::Rect& size_in_pizel);
 
   // Sets the currently-displayed cursor. If the cursor was previously hidden
   // via ShowCursor(false), it will remain hidden until ShowCursor(true) is
   // called, at which point the cursor that was last set via SetCursor() will be
@@ skipping 10 matching lines @@
   void MoveCursorTo(const gfx::Point& location);
 
   // Moves the cursor to the |host_location| given in host coordinates.
   void MoveCursorToHostLocation(const gfx::Point& host_location);
 
   // Returns a target window for the given gesture event.
   Window* GetGestureTarget(ui::GestureEvent* 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.
+  // events are dispatched from GestureRecognizer instead of WindowTreeHost.
   void DispatchGestureEvent(ui::GestureEvent* event);
 
   // 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);
 
   // Dispatches OnMouseExited to the |window| which is hiding if nessessary.
   void DispatchMouseExitToHidingWindow(Window* window);
 
   // Dispatches a ui::ET_MOUSE_EXITED event at |point|.
   void DispatchMouseExitAtPoint(const gfx::Point& point);
 
   // Invoked when |window|'s visibility has changed.
   void OnWindowVisibilityChanged(Window* window, bool is_visible);
 
   // Invoked when |window|'s tranfrom has changed. |contained_mouse|
   // indicates if the bounds before change contained the
   // |last_moust_location()|.
   void OnWindowTransformed(Window* window, bool contained_mouse);
 
   // Invoked when the keyboard mapping (in X11 terms: the mapping between
   // keycodes and keysyms) has changed.
   void OnKeyboardMappingChanged();
 
   // The system windowing system has sent a request that we close our window.
-  void OnRootWindowHostCloseRequested();
+  void OnWindowTreeHostCloseRequested();
 
   // Add/remove observer. There is no need to remove the observer if
   // the root window is being deleted. In particular, you SHOULD NOT remove
   // in |WindowObserver::OnWindowDestroying| of the observer observing
   // the root window because it is too late to remove it.
   void AddRootWindowObserver(RootWindowObserver* observer);
   void RemoveRootWindowObserver(RootWindowObserver* observer);
 
   // Gesture Recognition -------------------------------------------------------
 
@@ skipping 28 matching lines @@
 
   // The parameter for OnWindowHidden() to specify why window is hidden.
   enum WindowHiddenReason {
     WINDOW_DESTROYED,  // Window is destroyed.
     WINDOW_HIDDEN,     // Window is hidden.
     WINDOW_MOVING,     // Window is temporarily marked as hidden due to move
                        // across root windows.
   };
 
   // Updates the event with the appropriate transform for the device scale
-  // factor. The RootWindowHostDelegate dispatches events in the physical pixel
+  // factor. The WindowTreeHostDelegate dispatches events in the physical pixel
   // coordinate. But the event processing from RootWindow onwards happen in
   // device-independent pixel coordinate. So it is necessary to update the event
   // received from the host.
   void TransformEventForDeviceScaleFactor(ui::LocatedEvent* event);
 
   // Moves the cursor to the specified location. This method is internally used
   // by MoveCursorTo() and MoveCursorToHostLocation().
   void MoveCursorToInternal(const gfx::Point& root_location,
                             const gfx::Point& host_location);
 
@@ skipping 41 matching lines @@
   virtual void 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:
+  // Overridden from aura::WindowTreeHostDelegate:
   virtual bool OnHostKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual bool OnHostMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual bool OnHostScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual bool OnHostTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnHostCancelMode() OVERRIDE;
   virtual void OnHostActivated() OVERRIDE;
   virtual void OnHostLostWindowCapture() OVERRIDE;
   virtual void OnHostLostMouseGrab() OVERRIDE;
   virtual void OnHostMoved(const gfx::Point& origin) OVERRIDE;
   virtual void OnHostResized(const gfx::Size& size) OVERRIDE;
   virtual RootWindow* AsRootWindow() OVERRIDE;
   virtual const RootWindow* AsRootWindow() const OVERRIDE;
   virtual ui::EventProcessor* GetEventProcessor() OVERRIDE;
 
   ui::EventDispatchDetails OnHostMouseEventImpl(ui::MouseEvent* event)
       WARN_UNUSED_RESULT;
 
   // We hold and aggregate mouse drags and touch moves as a way of throttling
   // resizes when HoldMouseMoves() is called. The following methods are used to
   // dispatch held and newly incoming mouse and touch events, typically when an
   // event other than one of these needs dispatching or a matching
   // ReleaseMouseMoves()/ReleaseTouchMoves() is called.  NOTE: because these
-  // methods dispatch events from RootWindowHost the coordinates are in terms of
+  // methods dispatch events from WindowTreeHost the coordinates are in terms of
   // the root.
   ui::EventDispatchDetails DispatchMouseEventImpl(ui::MouseEvent* event)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchMouseEventRepost(ui::MouseEvent* event)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchMouseEventToTarget(ui::MouseEvent* event,
                                                       Window* target)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchTouchEventImpl(ui::TouchEvent* event)
       WARN_UNUSED_RESULT;
   ui::EventDispatchDetails DispatchHeldEvents() WARN_UNUSED_RESULT;
   // Creates and dispatches synthesized mouse move event using the
   // current mouse location.
   ui::EventDispatchDetails SynthesizeMouseMoveEvent() WARN_UNUSED_RESULT;
 
   void SynthesizeMouseMoveEventAsync();
 
   // Posts a task to send synthesized mouse move event if there
   // is no a pending task.
   void PostMouseMoveEventAfterWindowChange();
 
   void PreDispatchLocatedEvent(Window* target, ui::LocatedEvent* event);
 
   // TODO(beng): evaluate the ideal ownership model.
   scoped_ptr<Window> window_;
 
-  scoped_ptr<RootWindowHost> host_;
+  scoped_ptr<WindowTreeHost> host_;
 
   // Touch ids that are currently down.
   uint32 touch_ids_down_;
 
   // Last cursor set.  Used for testing.
   gfx::NativeCursor last_cursor_;
 
   ObserverList<RootWindowObserver> observers_;
 
   Window* mouse_pressed_handler_;
@@ skipping 21 matching lines @@
 
   // Used to schedule DispatchHeldEvents() when |move_hold_count_| goes to 0.
   base::WeakPtrFactory<RootWindow> held_event_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindow);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_ROOT_WINDOW_H_