mash: Migrate wallpaper controllers to ash/common.

ash/common/wallpaper/wallpaper_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/wallpaper/wallpaper_controller.h"
+#include "ash/common/wallpaper/wallpaper_controller.h"
 
-#include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wallpaper/wallpaper_controller_observer.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
+#include "ash/common/wallpaper/wallpaper_view.h"
+#include "ash/common/wallpaper/wallpaper_widget_controller.h"
+#include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
-#include "ash/root_window_controller.h"
-#include "ash/shell.h"
-#include "ash/wallpaper/wallpaper_controller_observer.h"
-#include "ash/wallpaper/wallpaper_view.h"
-#include "ash/wallpaper/wallpaper_widget_controller.h"
+#include "ash/common/wm_window.h"
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/threading/sequenced_worker_pool.h"
+#include "base/task_runner.h"
 #include "components/wallpaper/wallpaper_resizer.h"
-#include "ui/aura/window.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // How long to wait reloading the wallpaper after the display size has changed.
 const int kWallpaperReloadDelayMs = 100;
 
 }  // namespace
 
-WallpaperController::WallpaperController(
-    base::SequencedWorkerPool* blocking_pool)
+WallpaperController::WallpaperController(base::TaskRunner* task_runner)
     : locked_(false),
       wallpaper_mode_(WALLPAPER_NONE),
       wallpaper_reload_delay_(kWallpaperReloadDelayMs),
-      blocking_pool_(blocking_pool) {
+      task_runner_(task_runner) {
   WmShell::Get()->AddDisplayObserver(this);
   WmShell::Get()->AddShellObserver(this);
 }
 
 WallpaperController::~WallpaperController() {
   WmShell::Get()->RemoveDisplayObserver(this);
   WmShell::Get()->RemoveShellObserver(this);
 }
 
 gfx::ImageSkia WallpaperController::GetWallpaper() const {
@@ skipping 22 matching lines @@
   VLOG(1) << "SetWallpaper: image_id="
           << wallpaper::WallpaperResizer::GetImageId(image)
           << " layout=" << layout;
 
   if (WallpaperIsAlreadyLoaded(image, true /* compare_layouts */, layout)) {
     VLOG(1) << "Wallpaper is already loaded";
     return false;
   }
 
   current_wallpaper_.reset(new wallpaper::WallpaperResizer(
-      image, GetMaxDisplaySizeInNative(), layout, blocking_pool_));
+      image, GetMaxDisplaySizeInNative(), layout, task_runner_));
   current_wallpaper_->StartResize();
 
   FOR_EACH_OBSERVER(WallpaperControllerObserver, observers_,
                     OnWallpaperDataChanged());
   wallpaper_mode_ = WALLPAPER_IMAGE;
   InstallDesktopControllerForAllWindows();
   return true;
 }
 
 void WallpaperController::CreateEmptyWallpaper() {
@@ skipping 96 matching lines @@
     case WALLPAPER_IMAGE: {
       component = new WallpaperWidgetController(
           CreateWallpaper(root_window, container_id));
       break;
     }
     case WALLPAPER_NONE:
       NOTREACHED();
       return;
   }
 
-  aura::Window* aura_root_window = WmWindowAura::GetAuraWindow(root_window);
-  RootWindowController* controller = GetRootWindowController(aura_root_window);
+  WmRootWindowController* controller = root_window->GetRootWindowController();
   controller->SetAnimatingWallpaperWidgetController(
       new AnimatingWallpaperWidgetController(component));
   component->StartAnimating(controller);
 }
 
 void WallpaperController::InstallDesktopControllerForAllWindows() {
   for (WmWindow* root : WmShell::Get()->GetAllRootWindows())
     InstallDesktopController(root);
   current_max_display_size_ = GetMaxDisplaySizeInNative();
 }
 
 bool WallpaperController::ReparentWallpaper(int container) {
   bool moved = false;
-  for (auto* root_window_controller : Shell::GetAllRootWindowControllers()) {
+  for (WmWindow* root_window : WmShell::Get()->GetAllRootWindows()) {
+    WmRootWindowController* root_window_controller =
+        root_window->GetRootWindowController();
     // In the steady state (no animation playing) the wallpaper widget
     // controller exists in the RootWindowController.
     WallpaperWidgetController* wallpaper_widget_controller =
         root_window_controller->wallpaper_widget_controller();
     if (wallpaper_widget_controller) {
       moved |= wallpaper_widget_controller->Reparent(
-          root_window_controller->GetRootWindow(), container);
+          root_window_controller->GetWindow(), container);
     }
     // During wallpaper show animations the controller lives in
     // AnimatingWallpaperWidgetController owned by RootWindowController.
     // NOTE: If an image load happens during a wallpaper show animation there
     // can temporarily be two wallpaper widgets. We must reparent both of them,
     // one above and one here.
     WallpaperWidgetController* animating_controller =
         root_window_controller->animating_wallpaper_widget_controller()
             ? root_window_controller->animating_wallpaper_widget_controller()
                   ->GetController(false)
             : nullptr;
     if (animating_controller) {
       moved |= animating_controller->Reparent(
-          root_window_controller->GetRootWindow(), container);
+          root_window_controller->GetWindow(), container);
     }
   }
   return moved;
 }
 
 int WallpaperController::GetWallpaperContainerId(bool locked) {
   return locked ? kShellWindowId_LockScreenWallpaperContainer
                 : kShellWindowId_WallpaperContainer;
 }
 
 void WallpaperController::UpdateWallpaper(bool clear_cache) {
   current_wallpaper_.reset();
   WmShell::Get()->wallpaper_delegate()->UpdateWallpaper(clear_cache);
 }
 
 }  // namespace ash