Rename RootWindowHost* to WindowTreeHost*

ui/views/widget/desktop_aura/desktop_root_window_host_x11.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_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_X11_H_
 #define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_X11_H_
 
 #include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
 
@@ skipping 11 matching lines @@
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
 
 namespace gfx {
 class ImageSkia;
 class ImageSkiaRep;
 }
 
 namespace views {
 class DesktopDragDropClientAuraX11;
 class DesktopDispatcherClient;
-class DesktopRootWindowHostObserverX11;
+class DesktopWindowTreeHostObserverX11;
 class X11DesktopWindowMoveClient;
 class X11ScopedCapture;
 class X11WindowEventFilter;
 
-class VIEWS_EXPORT DesktopRootWindowHostX11 :
-    public DesktopRootWindowHost,
-    public aura::RootWindowHost,
+class VIEWS_EXPORT DesktopWindowTreeHostX11 :
+    public DesktopWindowTreeHost,
+    public aura::WindowTreeHost,
     public base::MessageLoop::Dispatcher {
  public:
-  DesktopRootWindowHostX11(
+  DesktopWindowTreeHostX11(
       internal::NativeWidgetDelegate* native_widget_delegate,
       DesktopNativeWidgetAura* desktop_native_widget_aura);
-  virtual ~DesktopRootWindowHostX11();
+  virtual ~DesktopWindowTreeHostX11();
 
   // A way of converting an X11 |xid| host window into a |content_window_|.
   static aura::Window* GetContentWindowForXID(XID xid);
 
   // A way of converting an X11 |xid| host window into this object.
-  static DesktopRootWindowHostX11* GetHostForXID(XID xid);
+  static DesktopWindowTreeHostX11* GetHostForXID(XID xid);
 
   // Get all open top-level windows. This includes windows that may not be
   // visible. This list is sorted in their stacking order, i.e. the first window
   // is the topmost window.
   static std::vector<aura::Window*> GetAllOpenWindows();
 
   // Returns the current bounds in terms of the X11 Root Window.
   gfx::Rect GetX11RootWindowBounds() const;
 
   // Called by X11DesktopHandler to notify us that the native windowing system
   // has changed our activation.
   void HandleNativeWidgetActivationChanged(bool active);
 
-  void AddObserver(views::DesktopRootWindowHostObserverX11* observer);
-  void RemoveObserver(views::DesktopRootWindowHostObserverX11* observer);
+  void AddObserver(views::DesktopWindowTreeHostObserverX11* observer);
+  void RemoveObserver(views::DesktopWindowTreeHostObserverX11* observer);
 
   // Deallocates the internal list of open windows.
   static void CleanUpWindowList();
 
  protected:
-  // Overridden from DesktopRootWindowHost:
+  // Overridden from DesktopWindowTreeHost:
   virtual void Init(aura::Window* content_window,
                     const Widget::InitParams& params,
                     aura::RootWindow::CreateParams* rw_create_params) OVERRIDE;
   virtual void OnRootWindowCreated(aura::RootWindow* root,
                                    const Widget::InitParams& params) OVERRIDE;
   virtual scoped_ptr<corewm::Tooltip> CreateTooltip() OVERRIDE;
   virtual scoped_ptr<aura::client::DragDropClient>
       CreateDragDropClient(DesktopNativeCursorManager* cursor_manager) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void CloseNow() OVERRIDE;
-  virtual aura::RootWindowHost* AsRootWindowHost() OVERRIDE;
+  virtual aura::WindowTreeHost* AsWindowTreeHost() OVERRIDE;
   virtual void ShowWindowWithState(ui::WindowShowState show_state) OVERRIDE;
   virtual void ShowMaximizedWithBounds(
       const gfx::Rect& restored_bounds) OVERRIDE;
   virtual bool IsVisible() const OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual void StackAtTop() OVERRIDE;
   virtual void CenterWindow(const gfx::Size& size) OVERRIDE;
   virtual void GetWindowPlacement(
       gfx::Rect* bounds,
       ui::WindowShowState* show_state) const OVERRIDE;
@@ skipping 29 matching lines @@
   virtual void SetOpacity(unsigned char opacity) OVERRIDE;
   virtual void SetWindowIcons(const gfx::ImageSkia& window_icon,
                               const gfx::ImageSkia& app_icon) OVERRIDE;
   virtual void InitModalType(ui::ModalType modal_type) OVERRIDE;
   virtual void FlashFrame(bool flash_frame) OVERRIDE;
   virtual void OnRootViewLayout() const OVERRIDE;
   virtual void OnNativeWidgetFocus() OVERRIDE;
   virtual void OnNativeWidgetBlur() OVERRIDE;
   virtual bool IsAnimatingClosed() const OVERRIDE;
 
-  // Overridden from aura::RootWindowHost:
+  // Overridden from aura::WindowTreeHost:
   virtual aura::RootWindow* GetRootWindow() OVERRIDE;
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
   virtual void ToggleFullScreen() OVERRIDE;
   virtual gfx::Rect GetBounds() const OVERRIDE;
   virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
   virtual gfx::Insets GetInsets() const OVERRIDE;
   virtual void SetInsets(const gfx::Insets& insets) OVERRIDE;
   virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE;
@@ skipping 50 matching lines @@
   // Serializes an image to the format used by _NET_WM_ICON.
   void SerializeImageRepresentation(const gfx::ImageSkiaRep& rep,
                                     std::vector<unsigned long>* data);
 
   // See comment for variable open_windows_.
   static std::list<XID>& open_windows();
 
   // Overridden from Dispatcher:
   virtual bool Dispatch(const base::NativeEvent& event) OVERRIDE;
 
-  base::WeakPtrFactory<DesktopRootWindowHostX11> close_widget_factory_;
+  base::WeakPtrFactory<DesktopWindowTreeHostX11> close_widget_factory_;
 
   // X11 things
   // The display and the native X window hosting the root window.
   XDisplay* xdisplay_;
   ::Window xwindow_;
 
   // The native root window.
   ::Window x_root_window_;
 
   ui::X11AtomCache atom_cache_;
@@ skipping 41 matching lines @@
   // TODO(beng): Consider providing an interface to DesktopNativeWidgetAura
   //             instead of providing this route back to Widget.
   internal::NativeWidgetDelegate* native_widget_delegate_;
 
   DesktopNativeWidgetAura* desktop_native_widget_aura_;
 
   aura::Window* content_window_;
 
   // We can optionally have a parent which can order us to close, or own
   // children who we're responsible for closing when we CloseNow().
-  DesktopRootWindowHostX11* window_parent_;
-  std::set<DesktopRootWindowHostX11*> window_children_;
+  DesktopWindowTreeHostX11* window_parent_;
+  std::set<DesktopWindowTreeHostX11*> window_children_;
 
-  ObserverList<DesktopRootWindowHostObserverX11> observer_list_;
+  ObserverList<DesktopWindowTreeHostObserverX11> observer_list_;
 
   // Copy of custom window shape specified via SetShape(), if any.
   ::Region custom_window_shape_;
 
   // The current root window host that has capture. While X11 has something
   // like Windows SetCapture()/ReleaseCapture(), it is entirely implicit and
   // there are no notifications when this changes. We need to track this so we
   // can notify widgets when they have lost capture, which controls a bunch of
   // things in views like hiding menus.
-  static DesktopRootWindowHostX11* g_current_capture;
+  static DesktopWindowTreeHostX11* g_current_capture;
 
   // A list of all (top-level) windows that have been created but not yet
   // destroyed.
   static std::list<XID>* open_windows_;
 
   scoped_ptr<X11ScopedCapture> x11_capture_;
 
   base::string16 window_title_;
 
-  DISALLOW_COPY_AND_ASSIGN(DesktopRootWindowHostX11);
+  DISALLOW_COPY_AND_ASSIGN(DesktopWindowTreeHostX11);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_X11_H_