Wallpaper resize extents compositor lock timeout.

ash/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 <string>
 #include <utility>
 
 #include "ash/ash_switches.h"
+#include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wallpaper/wallpaper_controller_observer.h"
 #include "ash/wallpaper/wallpaper_delegate.h"
 #include "ash/wallpaper/wallpaper_view.h"
 #include "ash/wallpaper/wallpaper_widget_controller.h"
 #include "ash/wm_window.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/task_runner.h"
 #include "components/wallpaper/wallpaper_color_calculator.h"
 #include "components/wallpaper/wallpaper_resizer.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/color_analysis.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;
+constexpr int kWallpaperReloadDelayMs = 100;
+
+// How long to wait for resizing of the the wallpaper.
+constexpr int kCompositorLockTimeoutMs = 750;
 
 // Returns true if a color should be extracted from the wallpaper based on the
 // command kAshShelfColor line arg.
 bool IsShelfColoringEnabled() {
   const bool kDefaultValue = true;
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshShelfColor)) {
     return kDefaultValue;
   }
@@ skipping 119 matching lines @@
   wallpaper_mode_ = WALLPAPER_IMAGE;
   InstallDesktopControllerForAllWindows();
 }
 
 void WallpaperController::OnDisplayConfigurationChanged() {
   gfx::Size max_display_size = GetMaxDisplaySizeInNative();
   if (current_max_display_size_ != max_display_size) {
     current_max_display_size_ = max_display_size;
     if (wallpaper_mode_ == WALLPAPER_IMAGE && current_wallpaper_) {
       timer_.Stop();
+      GetInternalDisplayCompositorLock();
       timer_.Start(FROM_HERE,
                    base::TimeDelta::FromMilliseconds(wallpaper_reload_delay_),
                    base::Bind(&WallpaperController::UpdateWallpaper,
                               base::Unretained(this), false /* clear cache */));
     }
   }
 }
 
 void WallpaperController::OnRootWindowAdded(WmWindow* root_window) {
   // The wallpaper hasn't been set yet.
@@ skipping 83 matching lines @@
 void WallpaperController::SetWallpaper(const SkBitmap& wallpaper,
                                        wallpaper::WallpaperLayout layout) {
   if (wallpaper.isNull())
     return;
 
   SetWallpaperImage(gfx::ImageSkia::CreateFrom1xBitmap(wallpaper), layout);
 }
 
 void WallpaperController::OnWallpaperResized() {
   CalculateWallpaperColors();
+  compositor_lock_.reset();
 }
 
 void WallpaperController::OnColorCalculationComplete() {
   const SkColor color = color_calculator_->prominent_color();
   color_calculator_.reset();
   SetProminentColor(color);
 }
 
 void WallpaperController::InstallDesktopController(WmWindow* root_window) {
   WallpaperWidgetController* component = nullptr;
@@ skipping 111 matching lines @@
 }
 
 bool WallpaperController::MoveToUnlockedContainer() {
   if (!locked_)
     return false;
 
   locked_ = false;
   return ReparentWallpaper(GetWallpaperContainerId(false));
 }
 
+void WallpaperController::GetInternalDisplayCompositorLock() {
+  if (display::Display::HasInternalDisplay()) {
+    compositor_lock_ =
+        Shell::Get()
+            ->window_tree_host_manager()
+            ->GetRootWindowForDisplayId(display::Display::InternalDisplayId())
+            ->layer()
+            ->GetCompositor()
+            ->GetCompositorLock(this, base::TimeDelta::FromMilliseconds(
+                                          kCompositorLockTimeoutMs));
+  }
+}
+
+void WallpaperController::CompositorLockTimedOut() {
+  compositor_lock_.reset();
+}
+
 }  // namespace ash