Rename ash desktop_background to wallpaper.

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/aura/aura_layout_manager_adapter.h"
@@ skipping 20 matching lines @@
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/root_window_layout_manager.h"
 #include "ash/common/wm/switchable_windows.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/display/display_manager.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/shelf/shelf_window_targeter.h"
 #include "ash/shell.h"
 #include "ash/touch/touch_hud_debug.h"
 #include "ash/touch/touch_hud_projection.h"
 #include "ash/touch/touch_observer_hud.h"
+#include "ash/wallpaper/wallpaper_widget_controller.h"
 #include "ash/wm/lock_layout_manager.h"
 #include "ash/wm/panels/attached_panel_window_targeter.h"
 #include "ash/wm/panels/panel_window_event_handler.h"
 #include "ash/wm/stacking_controller.h"
-#include "ash/wm/system_background_controller.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
+#include "ash/wm/system_wallpaper_controller.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 25 matching lines @@
 #include "ui/chromeos/touch_exploration_controller.h"
 #endif
 
 namespace ash {
 namespace {
 
 #if defined(OS_CHROMEOS)
 // Duration for the animation that hides the boot splash screen, in
 // milliseconds.  This should be short enough in relation to
 // wm/window_animation.cc's brightness/grayscale fade animation that the login
-// background image animation isn't hidden by the splash screen animation.
+// wallpaper image animation isn't hidden by the splash screen animation.
 const int kBootSplashScreenHideDurationMs = 500;
 #endif
 
 float ToRelativeValue(int value, int src, int dst) {
   return static_cast<float>(value) / static_cast<float>(src) * dst;
 }
 
 void MoveOriginRelativeToSize(const gfx::Size& src_size,
                               const gfx::Size& dst_size,
                               gfx::Rect* bounds_in_out) {
@@ skipping 43 matching lines @@
       kShellWindowId_DockedContainer,
       kShellWindowId_PanelContainer,
       kShellWindowId_AlwaysOnTopContainer,
       kShellWindowId_SystemModalContainer,
       kShellWindowId_LockSystemModalContainer,
       kShellWindowId_UnparentedControlContainer,
       kShellWindowId_OverlayContainer,
   };
   const int kExtraContainerIdsToMoveInUnifiedMode[] = {
       kShellWindowId_LockScreenContainer,
-      kShellWindowId_LockScreenBackgroundContainer,
+      kShellWindowId_LockScreenWallpaperContainer,
   };
   std::vector<int> container_ids(
       kContainerIdsToMove,
       kContainerIdsToMove + arraysize(kContainerIdsToMove));
   // Check the default_multi_display_mode because this is also necessary
   // in trasition between mirror <-> unified mode.
   if (Shell::GetInstance()
           ->display_manager()
           ->current_default_multi_display_mode() == DisplayManager::UNIFIED) {
     for (int id : kExtraContainerIdsToMoveInUnifiedMode)
@@ skipping 147 matching lines @@
 }
 
 aura::Window* RootWindowController::GetRootWindow() {
   return GetHost()->window();
 }
 
 const aura::Window* RootWindowController::GetRootWindow() const {
   return GetHost()->window();
 }
 
-void RootWindowController::SetWallpaperController(
-    DesktopBackgroundWidgetController* controller) {
-  wallpaper_controller_.reset(controller);
+void RootWindowController::SetWallpaperWidgetController(
+    WallpaperWidgetController* controller) {
+  wallpaper_widget_controller_.reset(controller);
 }
 
-void RootWindowController::SetAnimatingWallpaperController(
-    AnimatingDesktopController* controller) {
-  if (animating_wallpaper_controller_.get())
-    animating_wallpaper_controller_->StopAnimating();
-  animating_wallpaper_controller_.reset(controller);
+void RootWindowController::SetAnimatingWallpaperWidgetController(
+    AnimatingWallpaperWidgetController* controller) {
+  if (animating_wallpaper_widget_controller_.get())
+    animating_wallpaper_widget_controller_->StopAnimating();
+  animating_wallpaper_widget_controller_.reset(controller);
 }
 
 void RootWindowController::Shutdown() {
   WmShell::Get()->RemoveShellObserver(this);
 
 #if defined(OS_CHROMEOS)
   if (touch_exploration_manager_) {
     touch_exploration_manager_.reset();
   }
 #endif
 
-  if (animating_wallpaper_controller_.get())
-    animating_wallpaper_controller_->StopAnimating();
-  wallpaper_controller_.reset();
-  animating_wallpaper_controller_.reset();
+  if (animating_wallpaper_widget_controller_.get())
+    animating_wallpaper_widget_controller_->StopAnimating();
+  wallpaper_widget_controller_.reset();
+  animating_wallpaper_widget_controller_.reset();
   aura::Window* root_window = GetRootWindow();
   WmWindow* root_shutting_down = WmWindowAura::Get(root_window);
   WmShell* shell = WmShell::Get();
   // Change the target root window before closing child windows. If any child
   // being removed triggers a relayout of the shelf it will try to build a
   // window list adding windows from the target root window's containers which
   // may have already gone away.
   if (shell->GetRootWindowForNewWindows() == root_shutting_down) {
     // The root window for new windows is being destroyed. Switch to the primary
     // root window if possible.
     WmWindow* primary_root = shell->GetPrimaryRootWindow();
     shell->set_root_window_for_new_windows(
         primary_root == root_shutting_down ? nullptr : primary_root);
   }
 
   CloseChildWindows();
   GetRootWindowSettings(root_window)->controller = NULL;
   workspace_controller_.reset();
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   GetRootWindowSettings(root_window)->display_id =
       display::Display::kInvalidDisplayID;
   ash_host_->PrepareForShutdown();
 
-  system_background_.reset();
+  system_wallpaper_.reset();
   aura::client::SetScreenPositionClient(root_window, NULL);
 }
 
 bool RootWindowController::CanWindowReceiveEvents(aura::Window* window) {
   if (GetRootWindow() != window->GetRootWindow())
     return false;
 
   // Always allow events to fall through to the virtual keyboard even if
   // displaying a system modal dialog.
   if (IsVirtualKeyboardWindow(window))
@@ skipping 106 matching lines @@
   return shelf_.get();
 }
 
 void RootWindowController::UpdateAfterLoginStatusChange(LoginStatus status) {
   if (status != LoginStatus::NOT_LOGGED_IN)
     mouse_event_target_.reset();
   if (shelf_widget_->status_area_widget())
     shelf_widget_->status_area_widget()->UpdateAfterLoginStatusChange(status);
 }
 
-void RootWindowController::HandleInitialDesktopBackgroundAnimationStarted() {
+void RootWindowController::HandleInitialWallpaperAnimationStarted() {
 #if defined(OS_CHROMEOS)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshAnimateFromBootSplashScreen) &&
       boot_splash_screen_.get()) {
-    // Make the splash screen fade out so it doesn't obscure the desktop
-    // wallpaper's brightness/grayscale animation.
+    // Make the splash screen fade out so it doesn't obscure the wallpaper's
+    // brightness/grayscale animation.
     boot_splash_screen_->StartHideAnimation(
         base::TimeDelta::FromMilliseconds(kBootSplashScreenHideDurationMs));
   }
 #endif
 }
 
 void RootWindowController::OnWallpaperAnimationFinished(views::Widget* widget) {
   // Make sure the wallpaper is visible.
-  system_background_->SetColor(SK_ColorBLACK);
+  system_wallpaper_->SetColor(SK_ColorBLACK);
 #if defined(OS_CHROMEOS)
   boot_splash_screen_.reset();
 #endif
 
   WmShell::Get()->wallpaper_delegate()->OnWallpaperAnimationFinished();
   // Only removes old component when wallpaper animation finished. If we
   // remove the old one before the new wallpaper is done fading in there will
   // be a white flash during the animation.
-  if (animating_wallpaper_controller()) {
-    DesktopBackgroundWidgetController* controller =
-        animating_wallpaper_controller()->GetController(true);
-    // |desktop_widget_| should be the same animating widget we try to move
-    // to |kDesktopController|. Otherwise, we may close |desktop_widget_|
-    // before move it to |kDesktopController|.
+  if (animating_wallpaper_widget_controller()) {
+    WallpaperWidgetController* controller =
+        animating_wallpaper_widget_controller()->GetController(true);
     DCHECK_EQ(controller->widget(), widget);
-    // Release the old controller and close its background widget.
-    SetWallpaperController(controller);
+    // Release the old controller and close its wallpaper widget.
+    SetWallpaperWidgetController(controller);
   }
 }
 
 void RootWindowController::CloseChildWindows() {
   mouse_event_target_.reset();
 
   // Remove observer as deactivating keyboard causes |docked_layout_manager_|
   // to fire notifications.
   if (docked_layout_manager_ && shelf_widget_ &&
       shelf_widget_->shelf_layout_manager())
@@ skipping 13 matching lines @@
   if (docked_layout_manager_) {
     docked_layout_manager_->Shutdown();
     docked_layout_manager_ = NULL;
   }
   aura::Window* root_window = GetRootWindow();
   aura::client::SetDragDropClient(root_window, NULL);
 
   if (shelf_widget_)
     shelf_widget_->Shutdown();
 
-  // Close background widget first as it depends on tooltip.
-  wallpaper_controller_.reset();
-  animating_wallpaper_controller_.reset();
+  // Close wallpaper widget first as it depends on tooltip.
+  wallpaper_widget_controller_.reset();
+  animating_wallpaper_widget_controller_.reset();
 
   workspace_controller_.reset();
   aura::client::SetTooltipClient(root_window, NULL);
 
   // Explicitly destroy top level windows. We do this as during part of
   // destruction such windows may query the RootWindow for state.
   aura::WindowTracker non_toplevel_windows;
   non_toplevel_windows.Add(root_window);
   while (!non_toplevel_windows.windows().empty()) {
     const aura::Window* non_toplevel_window =
@@ skipping 52 matching lines @@
   ShellDelegate* delegate = WmShell::Get()->delegate();
   DCHECK(delegate);
   menu_model_.reset(delegate->CreateContextMenu(wm_shelf_aura_.get(), nullptr));
   if (!menu_model_)
     return;
 
   menu_model_adapter_.reset(new views::MenuModelAdapter(
       menu_model_.get(),
       base::Bind(&RootWindowController::OnMenuClosed, base::Unretained(this))));
 
-  // Background controller may not be set yet if user clicked on status are
+  // Wallpaper controller may not be set yet if user clicked on status are
   // before initial animation completion. See crbug.com/222218
-  if (!wallpaper_controller_.get())
+  if (!wallpaper_widget_controller_.get())
     return;
 
   menu_runner_.reset(new views::MenuRunner(
       menu_model_adapter_->CreateMenu(),
       views::MenuRunner::CONTEXT_MENU | views::MenuRunner::ASYNC));
   ignore_result(
-      menu_runner_->RunMenuAt(wallpaper_controller_->widget(), NULL,
+      menu_runner_->RunMenuAt(wallpaper_widget_controller_->widget(), nullptr,
                               gfx::Rect(location_in_screen, gfx::Size()),
                               views::MENU_ANCHOR_TOPLEFT, source_type));
 }
 
 void RootWindowController::UpdateShelfVisibility() {
   shelf_widget_->shelf_layout_manager()->UpdateVisibilityState();
 }
 
 aura::Window* RootWindowController::GetWindowForFullscreenMode() {
   return WmWindowAura::GetAuraWindow(
@@ skipping 81 matching lines @@
 }
 
 void RootWindowController::Init(RootWindowType root_window_type,
                                 bool first_run_after_boot) {
   aura::Window* root_window = GetRootWindow();
   Shell* shell = Shell::GetInstance();
   shell->InitRootWindow(root_window);
 
   root_window_controller_common_->CreateContainers();
 
-  CreateSystemBackground(first_run_after_boot);
+  CreateSystemWallpaper(first_run_after_boot);
 
   InitLayoutManagers();
   InitTouchHuds();
 
   if (Shell::GetPrimaryRootWindowController()
           ->GetSystemModalLayoutManager(NULL)
           ->has_modal_background()) {
     GetSystemModalLayoutManager(NULL)->CreateModalBackground();
   }
 
@@ skipping 68 matching lines @@
       wm_status_container, wm_shelf_aura_.get()));
 
   if (!WmShell::Get()
            ->GetSessionStateDelegate()
            ->IsActiveUserSessionStarted()) {
     // This window exists only to be a event target on login screen.
     // It does not have to handle events, nor be visible.
     mouse_event_target_.reset(new aura::Window(new EmptyWindowDelegate));
     mouse_event_target_->Init(ui::LAYER_NOT_DRAWN);
 
-    aura::Window* lock_background_container =
-        GetContainer(kShellWindowId_LockScreenBackgroundContainer);
-    lock_background_container->AddChild(mouse_event_target_.get());
+    aura::Window* lock_wallpaper_container =
+        GetContainer(kShellWindowId_LockScreenWallpaperContainer);
+    lock_wallpaper_container->AddChild(mouse_event_target_.get());
     mouse_event_target_->Show();
   }
 
   // Create Docked windows layout manager
   WmWindow* docked_container =
       WmWindowAura::Get(GetContainer(kShellWindowId_DockedContainer));
   docked_layout_manager_ = new DockedWindowLayoutManager(docked_container);
   docked_container->SetLayoutManager(base::WrapUnique(docked_layout_manager_));
 
   // Installs SnapLayoutManager to containers who set the
@@ skipping 21 matching lines @@
 }
 
 void RootWindowController::InitTouchHuds() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::GetInstance()->is_touch_hud_projection_enabled())
     EnableTouchHudProjection();
 }
 
-void RootWindowController::CreateSystemBackground(
-    bool is_first_run_after_boot) {
+void RootWindowController::CreateSystemWallpaper(bool is_first_run_after_boot) {
   SkColor color = SK_ColorBLACK;
 #if defined(OS_CHROMEOS)
   if (is_first_run_after_boot)
     color = kChromeOsBootColor;
 #endif
-  system_background_.reset(
-      new SystemBackgroundController(GetRootWindow(), color));
+  system_wallpaper_.reset(
+      new SystemWallpaperController(GetRootWindow(), color));
 
 #if defined(OS_CHROMEOS)
   // Make a copy of the system's boot splash screen so we can composite it
-  // onscreen until the desktop background is ready.
+  // onscreen until the wallpaper is ready.
   if (is_first_run_after_boot &&
       (base::CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kAshCopyHostBackgroundAtBoot) ||
        base::CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kAshAnimateFromBootSplashScreen)))
     boot_splash_screen_.reset(new BootSplashScreen(GetHost()));
 #endif
 }
 
 void RootWindowController::EnableTouchHudProjection() {
@@ skipping 39 matching lines @@
     aura::Window* primary_root_window = Shell::GetInstance()
                                             ->window_tree_host_manager()
                                             ->GetPrimaryRootWindow();
     return GetRootWindowSettings(primary_root_window)->controller;
   }
 
   return GetRootWindowSettings(root_window)->controller;
 }
 
 }  // namespace ash