Moves creation of various clients to DesktopNativeWidgetAura

ui/views/widget/desktop_aura/desktop_native_widget_aura.cc

 // 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.
 
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 #include "base/bind.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
+#include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
+#include "ui/views/corewm/cursor_manager.h"
+#include "ui/views/corewm/focus_controller.h"
 #include "ui/views/corewm/input_method_event_filter.h"
+#include "ui/views/corewm/native_cursor_manager.h"
 #include "ui/views/corewm/shadow_controller.h"
 #include "ui/views/corewm/shadow_types.h"
 #include "ui/views/corewm/tooltip.h"
 #include "ui/views/corewm/tooltip_controller.h"
 #include "ui/views/corewm/visibility_controller.h"
 #include "ui/views/corewm/window_modality_controller.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/ime/input_method_bridge.h"
 #include "ui/views/widget/desktop_aura/desktop_capture_client.h"
+#include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
+#include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h"
+#include "ui/views/widget/desktop_aura/desktop_focus_rules.h"
+#include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
+#include "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/window_reorderer.h"
 
 #if defined(OS_WIN)
@@ skipping 158 matching lines @@
 
 void DesktopNativeWidgetAura::OnHostClosed() {
   // Don't invoke Widget::OnNativeWidgetDestroying(), its done by
   // DesktopRootWindowHost.
 
   // The WindowModalityController is at the front of the event pretarget
   // handler list. We destroy it first to preserve order symantics.
   if (window_modality_controller_)
     window_modality_controller_.reset();
 
-  // Make sure we don't still have capture. Otherwise CaptureController and
-  // RootWindow are left referencing a deleted Window.
+  // Make sure we don't have capture. Otherwise CaptureController and RootWindow
+  // are left referencing a deleted Window.
   {
     aura::Window* capture_window = capture_client_->GetCaptureWindow();
     if (capture_window && root_window_->Contains(capture_window))
       capture_window->ReleaseCapture();
   }
 
   // DesktopRootWindowHost owns the ActivationController which ShadowController
   // references. Make sure we destroy ShadowController early on.
   shadow_controller_.reset();
   tooltip_manager_.reset();
@@ skipping 11 matching lines @@
   root_window_.reset();  // Uses input_method_event_filter_ at destruction.
   // RootWindow owns |desktop_root_window_host_|.
   desktop_root_window_host_ = NULL;
   content_window_ = NULL;
 
   native_widget_delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
-void DesktopNativeWidgetAura::InstallInputMethodEventFilter(
+void DesktopNativeWidgetAura::OnDesktopRootWindowHostDestroyed(
     aura::RootWindow* root) {
-  DCHECK(!input_method_event_filter_.get());
+  // |root_window_| is still valid, but DesktopRootWindowHost is nearly
+  // destroyed. Do cleanup here of members DesktopRootWindowHost may also use.
+  aura::client::SetFocusClient(root, NULL);
+  aura::client::SetActivationClient(root, NULL);
+  focus_client_.reset();
 
-  // CEF sets focus to the window the user clicks down on.
-  // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
-  //             handed way of accomplishing focus.
-  // No event filter for aura::Env. Create CompoundEvnetFilter per RootWindow.
-  root_window_event_filter_ = new corewm::CompoundEventFilter;
-  // Pass ownership of the filter to the root_window.
-  root->SetEventFilter(root_window_event_filter_);
+  aura::client::SetDispatcherClient(root, NULL);
+  dispatcher_client_.reset();
 
-  input_method_event_filter_.reset(
-      new corewm::InputMethodEventFilter(root->GetAcceleratedWidget()));
-  input_method_event_filter_->SetInputMethodPropertyInRootWindow(root);
-  root_window_event_filter_->AddHandler(input_method_event_filter_.get());
-}
+  aura::client::SetCursorClient(root, NULL);
+  cursor_client_.reset();
 
-void DesktopNativeWidgetAura::CreateCaptureClient(aura::RootWindow* root) {
-  DCHECK(!capture_client_.get());
-  capture_client_.reset(new DesktopCaptureClient(root));
+  aura::client::SetScreenPositionClient(root, NULL);
+  position_client_.reset();
+
+  aura::client::SetDragDropClient(root, NULL);
+  drag_drop_client_.reset();
 }
 
 void DesktopNativeWidgetAura::HandleActivationChanged(bool active) {
   native_widget_delegate_->OnNativeWidgetActivationChanged(active);
   aura::client::ActivationClient* activation_client =
       aura::client::GetActivationClient(root_window_.get());
   if (!activation_client)
     return;
   if (active) {
     if (GetWidget()->HasFocusManager()) {
@@ skipping 13 matching lines @@
     // If we're not active we need to deactivate the corresponding
     // aura::Window. This way if a child widget is active it gets correctly
     // deactivated (child widgets don't get native desktop activation changes,
     // only aura activation changes).
     aura::Window* active_window = activation_client->GetActiveWindow();
     if (active_window)
       activation_client->DeactivateWindow(active_window);
   }
 }
 
-void DesktopNativeWidgetAura::InstallWindowModalityController(
-    aura::RootWindow* root) {
-  // The WindowsModalityController event filter should be at the head of the
-  // pre target handlers list. This ensures that it handles input events first
-  // when modal windows are at the top of the Zorder.
-  if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
-    window_modality_controller_.reset(
-        new views::corewm::WindowModalityController(root));
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, internal::NativeWidgetPrivate implementation:
 
 void DesktopNativeWidgetAura::InitNativeWidget(
     const Widget::InitParams& params) {
   ownership_ = params.ownership;
   widget_type_ = params.type;
 
   NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_window_);
   // Animations on TYPE_WINDOW are handled by the OS. Additionally if we animate
   // these windows the size of the window gets augmented, effecting restore
   // bounds and maximized windows in bad ways.
   if (params.type == Widget::InitParams::TYPE_WINDOW &&
       !params.remove_standard_frame) {
     content_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
   }
   content_window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
   content_window_->Init(params.layer_type);
   corewm::SetShadowType(content_window_, corewm::SHADOW_TYPE_NONE);
 #if defined(OS_LINUX)  // TODO(scottmg): http://crbug.com/180071
   content_window_->Show();
 #endif
 
-  desktop_root_window_host_ = params.desktop_root_window_host ?
-      params.desktop_root_window_host :
-      DesktopRootWindowHost::Create(native_widget_delegate_,
-                                    this, params.bounds);
-  root_window_.reset(
-      desktop_root_window_host_->Init(content_window_, params));
-
-  UpdateWindowTransparency();
-
   content_window_container_ = new aura::Window(NULL);
   content_window_container_->Init(ui::LAYER_NOT_DRAWN);
   content_window_container_->Show();
   content_window_container_->AddChild(content_window_);
+
+  desktop_root_window_host_ = params.desktop_root_window_host ?
+      params.desktop_root_window_host :
+      DesktopRootWindowHost::Create(native_widget_delegate_, this);
+  aura::RootWindow::CreateParams rw_params(params.bounds);
+  desktop_root_window_host_->Init(content_window_, params, &rw_params);
+
+  root_window_.reset(new aura::RootWindow(rw_params));
+  root_window_->Init();
   root_window_->AddChild(content_window_container_);
+
+  // The WindowsModalityController event filter should be at the head of the
+  // pre target handlers list. This ensures that it handles input events first
+  // when modal windows are at the top of the Zorder.
+  if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
+    window_modality_controller_.reset(
+        new views::corewm::WindowModalityController(root_window_.get()));
+
+  // |root_window_event_filter_| must be created before
+  // OnRootWindowHostCreated() is invoked.
+
+  // CEF sets focus to the window the user clicks down on.
+  // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
+  //             handed way of accomplishing focus.
+  // No event filter for aura::Env. Create CompoundEvnetFilter per RootWindow.
+  root_window_event_filter_ = new corewm::CompoundEventFilter;
+  // Pass ownership of the filter to the root_window.
+  root_window_->SetEventFilter(root_window_event_filter_);
+
+  desktop_root_window_host_->OnRootWindowCreated(root_window_.get(), params);
+
+  native_widget_delegate_->OnNativeWidgetCreated(true);
+
+  UpdateWindowTransparency();
+
+  capture_client_.reset(new DesktopCaptureClient(root_window_.get()));
+
+  corewm::FocusController* focus_controller =
+      new corewm::FocusController(new DesktopFocusRules(content_window_));
+  focus_client_.reset(focus_controller);
+  aura::client::SetFocusClient(root_window_.get(), focus_controller);
+  aura::client::SetActivationClient(root_window_.get(), focus_controller);
+  root_window_->AddPreTargetHandler(focus_controller);
+
+  dispatcher_client_.reset(new DesktopDispatcherClient);
+  aura::client::SetDispatcherClient(root_window_.get(),
+                                    dispatcher_client_.get());
+
+  DesktopNativeCursorManager* desktop_native_cursor_manager =
+      new views::DesktopNativeCursorManager(
+          root_window_.get(),
+          DesktopCursorLoaderUpdater::Create());
+  cursor_client_.reset(
+      new views::corewm::CursorManager(
+          scoped_ptr<corewm::NativeCursorManager>(
+              desktop_native_cursor_manager)));
+  aura::client::SetCursorClient(root_window_.get(), cursor_client_.get());
+
+  position_client_.reset(new DesktopScreenPositionClient());
+  aura::client::SetScreenPositionClient(root_window_.get(),
+                                        position_client_.get());
+
+  InstallInputMethodEventFilter();
+
+  drag_drop_client_ = desktop_root_window_host_->CreateDragDropClient(
+      desktop_native_cursor_manager);
+  aura::client::SetDragDropClient(root_window_.get(), drag_drop_client_.get());
+
+  focus_client_->FocusWindow(content_window_);
+
   OnRootWindowHostResized(root_window_.get());
 
   root_window_->AddRootWindowObserver(this);
 
   window_tree_client_.reset(
       new DesktopNativeWidgetAuraWindowTreeClient(root_window_.get()));
   drop_helper_.reset(new DropHelper(
       static_cast<internal::RootView*>(GetWidget()->GetRootView())));
   aura::client::SetDragDropDelegate(content_window_, this);
 
@@ skipping 653 matching lines @@
   native_widget_delegate_->OnNativeWidgetMove();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, NativeWidget implementation:
 
 ui::EventHandler* DesktopNativeWidgetAura::GetEventHandler() {
   return this;
 }
 
+void DesktopNativeWidgetAura::InstallInputMethodEventFilter() {
+  DCHECK(!input_method_event_filter_.get());
+
+  input_method_event_filter_.reset(
+      new corewm::InputMethodEventFilter(root_window_->GetAcceleratedWidget()));
+  input_method_event_filter_->SetInputMethodPropertyInRootWindow(
+      root_window_.get());
+  root_window_event_filter_->AddHandler(input_method_event_filter_.get());
+}
+
 void DesktopNativeWidgetAura::UpdateWindowTransparency() {
   content_window_->SetTransparent(ShouldUseNativeFrame());
 }
 
 }  // namespace views