Moves creation of various clients to DesktopNativeWidgetAura

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/Xlib.h>
 
 // Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
 #undef RootWindow
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
-#include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/base/cursor/cursor_loader_x11.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/views/views_export.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
 
-namespace aura {
-namespace client {
-class FocusClient;
-class ScreenPositionClient;
-}
-}
-
 namespace views {
 class DesktopDragDropClientAuraX11;
 class DesktopDispatcherClient;
 class DesktopRootWindowHostObserverX11;
 class X11DesktopWindowMoveClient;
 class X11WindowEventFilter;
 
-namespace corewm {
-class CursorManager;
-}
-
 class VIEWS_EXPORT DesktopRootWindowHostX11 :
     public DesktopRootWindowHost,
     public aura::RootWindowHost,
     public base::MessageLoop::Dispatcher {
  public:
   DesktopRootWindowHostX11(
       internal::NativeWidgetDelegate* native_widget_delegate,
-      DesktopNativeWidgetAura* desktop_native_widget_aura,
-      const gfx::Rect& initial_bounds);
+      DesktopNativeWidgetAura* desktop_native_widget_aura);
   virtual ~DesktopRootWindowHostX11();
 
   // 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);
 
   // Get all open top-level windows. This includes windows that may not be
   // visible.
   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);
 
   // Deallocates the internal list of open windows.
   static void CleanUpWindowList();
 
  protected:
   // Overridden from DesktopRootWindowHost:
-  virtual aura::RootWindow* Init(aura::Window* content_window,
-                                 const Widget::InitParams& params) OVERRIDE;
+  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 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 CenterWindow(const gfx::Size& size) OVERRIDE;
   virtual void GetWindowPlacement(
@@ skipping 140 matching lines @@
   // Local flag for fullscreen state to avoid a state mismatch between
   // server and local window_properties_ during app-initiated fullscreen.
   bool is_fullscreen_;
 
   // True if the window should stay on top of most other windows.
   bool is_always_on_top_;
 
   // We are owned by the RootWindow, but we have to have a back pointer to it.
   aura::RootWindow* root_window_;
 
-  // aura:: objects that we own.
-  scoped_ptr<aura::client::FocusClient> focus_client_;
-  scoped_ptr<views::corewm::CursorManager> cursor_client_;
   scoped_ptr<DesktopDispatcherClient> dispatcher_client_;
-  scoped_ptr<aura::client::ScreenPositionClient> position_client_;
-  scoped_ptr<DesktopDragDropClientAuraX11> drag_drop_client_;
+
+  DesktopDragDropClientAuraX11* drag_drop_client_;
 
   // Current Aura cursor.
   gfx::NativeCursor current_cursor_;
 
   scoped_ptr<X11WindowEventFilter> x11_window_event_filter_;
   scoped_ptr<X11DesktopWindowMoveClient> x11_window_move_client_;
 
   // TODO(beng): Consider providing an interface to DesktopNativeWidgetAura
   //             instead of providing this route back to Widget.
   internal::NativeWidgetDelegate* native_widget_delegate_;
@@ skipping 15 matching lines @@
   // A list of all (top-level) windows that have been created but not yet
   // destroyed.
   static std::list<XID>* open_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopRootWindowHostX11);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_X11_H_