Extract colors from wallpaper and dynamically update login screen overlay

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 
 #include <utility>
 
 #include "ash/ash_constants.h"
 #include "ash/public/cpp/shelf_types.h"
@@ skipping 309 matching lines @@
     WallpaperManager* manager = WallpaperManager::Get();
     if (manager->pending_inactive_ == this)
       manager->pending_inactive_ = NULL;
 
     started_load_at_ = base::Time::Now();
 
     if (default_) {
       manager->DoSetDefaultWallpaper(account_id_, std::move(on_finish_));
     } else if (!user_wallpaper_.isNull()) {
       SetWallpaper(user_wallpaper_, info_.layout);
+      manager->CalculateProminentColor(user_wallpaper_);
     } else if (!wallpaper_path_.empty()) {
       manager->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal, account_id_,
                      info_, wallpaper_path_, true /* update wallpaper */,
                      base::ThreadTaskRunnerHandle::Get(),
                      base::Passed(std::move(on_finish_)),
                      manager->weak_factory_.GetWeakPtr()));
     } else if (!info_.location.empty()) {
       manager->LoadWallpaper(account_id_, info_, true, std::move(on_finish_));
@@ skipping 380 matching lines @@
     }
 
     CreateSolidDefaultWallpaper();
   }
   // 1x1 wallpaper is actually solid color, so it should be stretched.
   if (default_wallpaper_image_->image().width() == 1 &&
       default_wallpaper_image_->image().height() == 1)
     layout = wallpaper::WALLPAPER_LAYOUT_STRETCH;
 
   SetWallpaper(default_wallpaper_image_->image(), layout);
+  CalculateProminentColor(default_wallpaper_image_->image());
 }
 
 void WallpaperManager::SetUserWallpaperInfo(const AccountId& account_id,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   current_user_wallpaper_info_ = info;
   if (!is_persistent)
     return;
 
@@ skipping 498 matching lines @@
     SetUserWallpaperInfo(account_id, info, true);
 
     if (update_wallpaper)
       DoSetDefaultWallpaper(account_id, std::move(on_finish));
     return;
   }
 
   // Update the image, but keep the path which was set earlier.
   wallpaper_cache_[account_id].second = user_image->image();
 
-  if (update_wallpaper)
+  if (update_wallpaper) {
     SetWallpaper(user_image->image(), layout);
+    CalculateProminentColor(user_image->image());
+  }
 }
 
 void WallpaperManager::StartLoad(const AccountId& account_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
   if (update_wallpaper) {
@@ skipping 184 matching lines @@
   Profile* profile = ProfileHelper::Get()->GetProfileByUser(user);
 
   UMA_HISTOGRAM_ENUMERATION(
       "Ash.Wallpaper.Apps",
       wallpaper_manager_util::ShouldUseAndroidWallpapersApp(profile)
           ? WALLPAPERS_APP_ANDROID
           : WALLPAPERS_PICKER_APP_CHROMEOS,
       WALLPAPERS_APPS_NUM);
 }
 
+void WallpaperManager::SetLoginOverlayCalculatorObserver(
+    wallpaper::WallpaperColorCalculatorObserver* observer) {
+  if (color_calculator_ && !observer) {
+    color_calculator_->RemoveObserver(login_overlay_calculator_observer_);
+    color_calculator_.reset();
+  }
+  login_overlay_calculator_observer_ = observer;
+}
+
+void WallpaperManager::CalculateProminentColor(const gfx::ImageSkia& image) {
+  // No need to calculate colors if there's no observer.
+  if (!login_overlay_calculator_observer_)
+    return;
+  if (color_calculator_) {
+    color_calculator_->RemoveObserver(login_overlay_calculator_observer_);
+    color_calculator_.reset();
+  }
+
+  color_utils::LumaRange luma = color_utils::LumaRange::DARK;
+  color_utils::SaturationRange saturation = color_utils::SaturationRange::MUTED;
+
+  color_calculator_ = base::MakeUnique<wallpaper::WallpaperColorCalculator>(
+      image, luma, saturation, task_runner_);
+  color_calculator_->AddObserver(login_overlay_calculator_observer_);
+  if (!color_calculator_->StartCalculation())
+    SetLoginOverlayCalculatorObserver(nullptr);
+}
+
+void WallpaperManager::getLoginOverlayColors(std::string* dm_color,
+                                             std::string* scroll_color,
+                                             std::string* background_color) {
+  SkColor dm_sk_color = color_calculator_->prominent_color();
+  // The dark muted color should have 100% opacity.
+  dm_sk_color = SkColorSetA(dm_sk_color, 0xFF);
+  SkColor base_sk_color = color_utils::GetResultingPaintColor(
+      SkColorSetA(ash::kShelfDefaultBaseColor,
+                  ash::kShelfTranslucentColorDarkenAlpha),
+      dm_sk_color);
+  SkColor background_sk_color =
+      SkColorSetA(base_sk_color, ash::kShelfTranslucentAlpha);
+  // The alpha value for the login screen background. This constant will be
+  // moved to a separate file when views-based login screen is being developed.
+  constexpr int kLoginTranslucentAlpha = 76;
+  SkColor scroll_sk_color = SkColorSetA(base_sk_color, kLoginTranslucentAlpha);
+  *dm_color = color_utils::SkColorToRgbaString(dm_sk_color);

[jdufault, 2017/06/10 03:05:59]

Output the SkColor values and have the string transformation happen at the call
site when sending to JS/HTML.

[Wenzhao (Colin) Zang, 2017/06/12 21:10:57]

Done.

+  *scroll_color = color_utils::SkColorToRgbaString(scroll_sk_color);
+  *background_color = color_utils::SkColorToRgbaString(background_sk_color);
+}
+
 }  // namespace chromeos