Reland "Fix white flash when user signs out and fix wallpaper animation regression"

ash/desktop_background/desktop_background_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/desktop_background/desktop_background_controller.h"
 
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_factory.h"
@@ skipping 88 matching lines @@
   const WallpaperResolution resolution_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperOperation);
 };
 
 DesktopBackgroundController::DesktopBackgroundController()
     : locked_(false),
       desktop_background_mode_(BACKGROUND_SOLID_COLOR),
       background_color_(kTransparentColor),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  InstallComponentForAllWindows();
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
   CancelPendingWallpaperOperation();
 }
 
 gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
   if (current_wallpaper_.get())
     return current_wallpaper_->wallpaper_image;
   return gfx::ImageSkia();
@@ skipping 86 matching lines @@
   if (wallpaper_op_.get())
     wallpaper_op_->Cancel();
 
   // Cancel reply callback for previous request.
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void DesktopBackgroundController::SetDesktopBackgroundSolidColorMode(
     SkColor color) {
   background_color_ = color;
-  if (desktop_background_mode_ != BACKGROUND_SOLID_COLOR) {
-    desktop_background_mode_ = BACKGROUND_SOLID_COLOR;
-    InstallComponentForAllWindows();
-    return;
-  }
+  desktop_background_mode_ = BACKGROUND_SOLID_COLOR;
 
-  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
-  for (Shell::RootWindowList::iterator iter = root_windows.begin();
-       iter != root_windows.end(); ++iter) {
-    aura::RootWindow* root_window = *iter;
-    internal::DesktopBackgroundWidgetController* component = root_window->
-        GetProperty(internal::kWindowDesktopComponent);
-    DCHECK(component);
-    DCHECK(component->layer());
-    component->layer()->SetColor(background_color_ );
-  }
+  InstallComponentForAllWindows();
 }
 
 void DesktopBackgroundController::CreateEmptyWallpaper() {
   current_wallpaper_.reset(NULL);
   SetDesktopBackgroundImageMode();
 }
 
 void DesktopBackgroundController::MoveDesktopToLockedContainer() {
   if (locked_)
     return;
   locked_ = true;
   ReparentBackgroundWidgets(GetBackgroundContainerId(false),
                             GetBackgroundContainerId(true));
 }
 
 void DesktopBackgroundController::MoveDesktopToUnlockedContainer() {
   if (!locked_)
     return;
   locked_ = false;
   ReparentBackgroundWidgets(GetBackgroundContainerId(true),
                             GetBackgroundContainerId(false));
 }
 
 void DesktopBackgroundController::OnWindowDestroying(aura::Window* window) {
    window->SetProperty(internal::kWindowDesktopComponent,
        static_cast<internal::DesktopBackgroundWidgetController*>(NULL));
+   window->SetProperty(internal::kComponentWrapper,
+       static_cast<internal::ComponentWrapper*>(NULL));
 }
 
 void DesktopBackgroundController::SetDesktopBackgroundImageMode() {
-  if (desktop_background_mode_ != BACKGROUND_IMAGE) {
-    desktop_background_mode_ = BACKGROUND_IMAGE;
-    InstallComponentForAllWindows();
-    return;
-  }
-
-  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
-  for (Shell::RootWindowList::iterator iter = root_windows.begin();
-      iter != root_windows.end(); ++iter) {
-    aura::RootWindow* root_window = *iter;
-    internal::DesktopBackgroundWidgetController* component = root_window->
-        GetProperty(internal::kWindowDesktopComponent);
-    DCHECK(component);
-    DCHECK(component->widget());
-    aura::Window* window = component->widget()->GetNativeView();
-    gfx::Rect bounds = window->bounds();
-    window->SchedulePaintInRect(gfx::Rect(0, 0,
-                                          bounds.width(), bounds.height()));
-  }
+  desktop_background_mode_ = BACKGROUND_IMAGE;
+  InstallComponentForAllWindows();
 }
 
 void DesktopBackgroundController::OnWallpaperLoadCompleted(
     scoped_refptr<WallpaperOperation> wo) {
   current_wallpaper_.reset(wo->ReleaseWallpaperData());
 
   SetDesktopBackgroundImageMode();
 
   DCHECK(wo.get() == wallpaper_op_.get());
   wallpaper_op_ = NULL;
@@ skipping 27 matching lines @@
       ui::Layer* layer = SetColorLayerForContainer(background_color_,
                                                    root_window,
                                                    container_id);
       component = new internal::DesktopBackgroundWidgetController(layer);
       break;
     }
     default: {
       NOTREACHED();
     }
   }
-  if (NULL == root_window->GetProperty(internal::kWindowDesktopComponent)) {
+  if (NULL == root_window->GetProperty(internal::kComponentWrapper)) {
     // First time for this root window
     root_window->AddObserver(this);
   }
-  root_window->SetProperty(internal::kWindowDesktopComponent, component);
+  root_window->SetProperty(internal::kComponentWrapper,
+                           new internal::ComponentWrapper(component));
 }
 
 void DesktopBackgroundController::InstallComponentForAllWindows() {
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     InstallComponent(*iter);
   }
 }
 
 void DesktopBackgroundController::ReparentBackgroundWidgets(int src_container,
                                                             int dst_container) {
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
     iter != root_windows.end(); ++iter) {
     aura::RootWindow* root_window = *iter;
-    internal::DesktopBackgroundWidgetController* component = root_window->
-        GetProperty(internal::kWindowDesktopComponent);
-    DCHECK(component);
-    component->Reparent(root_window,
-                        src_container,
-                        dst_container);
+    if (root_window->GetProperty(internal::kComponentWrapper)) {
+      internal::DesktopBackgroundWidgetController* component = root_window->
+          GetProperty(internal::kComponentWrapper)->component();
+      DCHECK(component);
+      component->Reparent(root_window,
+                          src_container,
+                          dst_container);
+    }
   }
 }
 
 int DesktopBackgroundController::GetBackgroundContainerId(bool locked) {
   return locked ? internal::kShellWindowId_LockScreenBackgroundContainer :
                   internal::kShellWindowId_DesktopBackgroundContainer;
 }
 
 WallpaperResolution DesktopBackgroundController::GetAppropriateResolution() {
   WallpaperResolution resolution = SMALL;
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     gfx::Size root_window_size = (*iter)->GetHostSize();
     if (root_window_size.width() > kSmallWallpaperMaximalWidth ||
         root_window_size.height() > kSmallWallpaperMaximalHeight)
       resolution = LARGE;
   }
   return resolution;
 }
 
 }  // namespace ash