Introdcue AshWindowTreeHost and move ash/chrome specific code in WTH to ash.

ash/root_window_controller.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 "ash/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/display/display_manager.h"
 #include "ash/focus_cycler.h"
 #include "ash/high_contrast/high_contrast_controller.h"
+#include "ash/host/ash_window_tree_host.h"
 #include "ash/root_window_settings.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/switchable_windows.h"
@@ skipping 229 matching lines @@
                                 ui::Layer* new_layer) OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EmptyWindowDelegate);
 };
 
 }  // namespace
 
 namespace internal {
 
-void RootWindowController::CreateForPrimaryDisplay(aura::WindowTreeHost* host) {
+void RootWindowController::CreateForPrimaryDisplay(AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host);
   controller->Init(RootWindowController::PRIMARY,
                    Shell::GetInstance()->delegate()->IsFirstRunAfterBoot());
 }
 
 void RootWindowController::CreateForSecondaryDisplay(
-    aura::WindowTreeHost* host) {
+    AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host);
   controller->Init(RootWindowController::SECONDARY, false /* first run */);
 }
 
 void RootWindowController::CreateForVirtualKeyboardDisplay(
-    aura::WindowTreeHost* host) {
+    AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host);
   controller->Init(RootWindowController::VIRTUAL_KEYBOARD,
                    false /* first run */);
 }
 
 // static
 RootWindowController* RootWindowController::ForShelf(aura::Window* window) {
   return GetRootWindowController(window->GetRootWindow());
 }
 
@@ skipping 12 matching lines @@
 aura::Window* RootWindowController::GetContainerForWindow(
     aura::Window* window) {
   aura::Window* container = window->parent();
   while (container && container->type() != ui::wm::WINDOW_TYPE_UNKNOWN)
     container = container->parent();
   return container;
 }
 
 RootWindowController::~RootWindowController() {
   Shutdown();
-  host_.reset();
+  ash_host_.reset();
   // The CaptureClient needs to be around for as long as the RootWindow is
   // valid.
   capture_client_.reset();
 }
 
 void RootWindowController::SetWallpaperController(
     DesktopBackgroundWidgetController* controller) {
   wallpaper_controller_.reset(controller);
 }
 
@@ skipping 55 matching lines @@
   }
   return modal_container ? static_cast<SystemModalContainerLayoutManager*>(
       modal_container->layout_manager()) : NULL;
 }
 
 aura::Window* RootWindowController::GetContainer(int container_id) {
   return root_window()->GetChildById(container_id);
 }
 
 const aura::Window* RootWindowController::GetContainer(int container_id) const {
-  return host_->window()->GetChildById(container_id);
+  return ash_host_->AsWindowTreeHost()->window()->GetChildById(container_id);
 }
 
 void RootWindowController::ShowShelf() {
   if (!shelf_->shelf())
     return;
   shelf_->shelf()->SetVisible(true);
   shelf_->status_area_widget()->Show();
 }
 
 void RootWindowController::OnShelfCreated() {
@@ skipping 248 matching lines @@
       keyboard_controller->RemoveObserver(shelf()->shelf_layout_manager());
       keyboard_controller->RemoveObserver(panel_layout_manager_);
       keyboard_controller->RemoveObserver(docked_layout_manager_);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowController, private:
 
-RootWindowController::RootWindowController(aura::WindowTreeHost* host)
-    : host_(host),
+RootWindowController::RootWindowController(AshWindowTreeHost* ash_host)
+    : ash_host_(ash_host),
       root_window_layout_(NULL),
       docked_layout_manager_(NULL),
       panel_layout_manager_(NULL),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
   GetRootWindowSettings(root_window())->controller = this;
   screen_dimmer_.reset(new ScreenDimmer(root_window()));
 
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowTreeClient(root_window(), stacking_controller_.get());
   capture_client_.reset(new ::wm::ScopedCaptureClient(root_window()));
 }
 
 void RootWindowController::Init(RootWindowType root_window_type,
                                 bool first_run_after_boot) {
   Shell* shell = Shell::GetInstance();
   shell->InitRootWindow(root_window());
 
-  host_->SetCursor(ui::kCursorPointer);
+  ash_host_->AsWindowTreeHost()->SetCursor(ui::kCursorPointer);
   CreateContainersInRootWindow(root_window());
 
   if (root_window_type == VIRTUAL_KEYBOARD) {
     shell->InitKeyboard();
     return;
   }
 
   CreateSystemBackground(first_run_after_boot);
 
   InitLayoutManagers();
   InitTouchHuds();
 
   if (Shell::GetPrimaryRootWindowController()->
       GetSystemModalLayoutManager(NULL)->has_modal_background()) {
     GetSystemModalLayoutManager(NULL)->CreateModalBackground();
   }
 
   shell->AddShellObserver(this);
 
   if (root_window_type == PRIMARY) {
     root_window_layout()->OnWindowResized();
     if (!keyboard::IsKeyboardUsabilityExperimentEnabled())
       shell->InitKeyboard();
   } else {
     root_window_layout()->OnWindowResized();
     shell->desktop_background_controller()->OnRootWindowAdded(root_window());
     shell->high_contrast_controller()->OnRootWindowAdded(root_window());
-    host_->Show();
+    ash_host_->AsWindowTreeHost()->Show();
 
     // Create a shelf if a user is already logged in.
     if (shell->session_state_delegate()->NumberOfLoggedInUsers())
       shelf()->CreateShelf();
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   root_window_layout_ = new RootWindowLayoutManager(root_window());
   root_window()->SetLayoutManager(root_window_layout_);
@@ skipping 288 matching lines @@
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(
     const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : NULL;
 }
 
 }  // namespace internal
 }  // namespace ash