Extracting more than one wallpaper prominent color

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"
@@ skipping 12 matching lines @@
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_scheduler/post_task.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"
 
+using color_utils::ColorProfile;
+using color_utils::ColorProfiles;
+using color_utils::LumaRange;
+using color_utils::SaturationRange;
+
 namespace ash {
 
 namespace {
 
 // How long to wait reloading the wallpaper after the display size has changed.
 constexpr int kWallpaperReloadDelayMs = 100;
 
 // How long to wait for resizing of the the wallpaper.
 constexpr int kCompositorLockTimeoutMs = 750;
 
@@ skipping 14 matching lines @@
       switch_value != switches::kAshShelfColorDisabled) {
     LOG(WARNING) << "Invalid '--" << switches::kAshShelfColor << "' value of '"
                  << switch_value << "'. Defaulting to "
                  << (kDefaultValue ? "enabled." : "disabled.");
     return kDefaultValue;
   }
 
   return switch_value == switches::kAshShelfColorEnabled;
 }
 
-// Returns the |luma| and |saturation| output parameters based on the
-// kAshShelfColorScheme command line arg.
-void GetProminentColorProfile(color_utils::LumaRange* luma,
-                              color_utils::SaturationRange* saturation) {
+// Gets the color profiles for extracting wallpaper prominent colors.
+ColorProfiles GetProminentColorProfiles() {
+  return {ColorProfile(LumaRange::DARK, SaturationRange::VIBRANT),
+          ColorProfile(LumaRange::NORMAL, SaturationRange::VIBRANT),
+          ColorProfile(LumaRange::LIGHT, SaturationRange::VIBRANT),
+          ColorProfile(LumaRange::DARK, SaturationRange::MUTED),
+          ColorProfile(LumaRange::NORMAL, SaturationRange::MUTED),
+          ColorProfile(LumaRange::LIGHT, SaturationRange::MUTED)};
+}
+
+// Returns color profile used for shelf based on the kAshShelfColorScheme
+// command line arg.
+ColorProfile GetShelfProminentColorProfile() {
   const std::string switch_value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kAshShelfColorScheme);
 
-  *luma = color_utils::LumaRange::DARK;
-  *saturation = color_utils::SaturationRange::MUTED;
+  ColorProfile color_profile(LumaRange::DARK, SaturationRange::MUTED);
 
   if (switch_value.find("light") != std::string::npos)
-    *luma = color_utils::LumaRange::LIGHT;
+    color_profile.luma = LumaRange::LIGHT;
   else if (switch_value.find("normal") != std::string::npos)
-    *luma = color_utils::LumaRange::NORMAL;
+    color_profile.luma = LumaRange::NORMAL;
   else if (switch_value.find("dark") != std::string::npos)
-    *luma = color_utils::LumaRange::DARK;
+    color_profile.luma = LumaRange::DARK;
 
   if (switch_value.find("vibrant") != std::string::npos)
-    *saturation = color_utils::SaturationRange::VIBRANT;
+    color_profile.saturation = SaturationRange::VIBRANT;
   else if (switch_value.find("muted") != std::string::npos)
-    *saturation = color_utils::SaturationRange::MUTED;
+    color_profile.saturation = SaturationRange::MUTED;
+
+  return color_profile;
 }
 
 }  // namespace
 
+const SkColor WallpaperController::kInvalidColor = SK_ColorTRANSPARENT;
+
 WallpaperController::WallpaperController()
     : locked_(false),
       wallpaper_mode_(WALLPAPER_NONE),
-      prominent_color_(kInvalidColor),
+      color_profiles_(GetProminentColorProfiles()),
       wallpaper_reload_delay_(kWallpaperReloadDelayMs),
       sequenced_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
           {base::TaskPriority::USER_VISIBLE,
            // Don't need to finish resize or color extraction during shutdown.
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       scoped_session_observer_(this) {
+  prominent_colors_ =
+      std::vector<SkColor>(color_profiles_.size(), kInvalidColor);
   ShellPort::Get()->AddDisplayObserver(this);
   Shell::Get()->AddShellObserver(this);
 }
 
 WallpaperController::~WallpaperController() {
   if (current_wallpaper_)
     current_wallpaper_->RemoveObserver(this);
   if (color_calculator_)
     color_calculator_->RemoveObserver(this);
   ShellPort::Get()->RemoveDisplayObserver(this);
@@ skipping 19 matching lines @@
 
 void WallpaperController::AddObserver(WallpaperControllerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WallpaperController::RemoveObserver(
     WallpaperControllerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+WallpaperController::ColorProfileIndex
+WallpaperController::GetShelfColorProfileIndex() const {
+  return GetColorProfileIndex(GetShelfProminentColorProfile());
+}
+
 wallpaper::WallpaperLayout WallpaperController::GetWallpaperLayout() const {
   if (current_wallpaper_)
     return current_wallpaper_->layout();
   return wallpaper::WALLPAPER_LAYOUT_CENTER_CROPPED;
 }
 
 void WallpaperController::SetWallpaperImage(const gfx::ImageSkia& image,
                                             wallpaper::WallpaperLayout layout) {
   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;
   }
 
   current_wallpaper_.reset(new wallpaper::WallpaperResizer(
       image, GetMaxDisplaySizeInNative(), layout, sequenced_task_runner_));
   current_wallpaper_->AddObserver(this);
   current_wallpaper_->StartResize();
 
   for (auto& observer : observers_)
     observer.OnWallpaperDataChanged();
   wallpaper_mode_ = WALLPAPER_IMAGE;
   InstallDesktopControllerForAllWindows();
 }
 
 void WallpaperController::CreateEmptyWallpaper() {
-  SetProminentColor(kInvalidColor);
+  SetProminentColors(
+      std::vector<SkColor>(color_profiles_.size(), kInvalidColor));
   current_wallpaper_.reset();
   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_) {
@@ skipping 99 matching lines @@
 
   SetWallpaperImage(gfx::ImageSkia::CreateFrom1xBitmap(wallpaper), layout);
 }
 
 void WallpaperController::OnWallpaperResized() {
   CalculateWallpaperColors();
   compositor_lock_.reset();
 }
 
 void WallpaperController::OnColorCalculationComplete() {
-  const SkColor color = color_calculator_->prominent_color();
+  const std::vector<SkColor> colors = color_calculator_->prominent_colors();
   color_calculator_.reset();
-  SetProminentColor(color);
+  SetProminentColors(colors);
 }
 
 void WallpaperController::InstallDesktopController(aura::Window* root_window) {
   WallpaperWidgetController* component = nullptr;
   int container_id = GetWallpaperContainerId(locked_);
 
   switch (wallpaper_mode_) {
     case WALLPAPER_IMAGE: {
       component = new WallpaperWidgetController(
           CreateWallpaper(root_window, container_id));
@@ skipping 49 matching lines @@
 int WallpaperController::GetWallpaperContainerId(bool locked) {
   return locked ? kShellWindowId_LockScreenWallpaperContainer
                 : kShellWindowId_WallpaperContainer;
 }
 
 void WallpaperController::UpdateWallpaper(bool clear_cache) {
   current_wallpaper_.reset();
   Shell::Get()->wallpaper_delegate()->UpdateWallpaper(clear_cache);
 }
 
-void WallpaperController::SetProminentColor(SkColor color) {
-  if (prominent_color_ == color)
+void WallpaperController::SetProminentColors(
+    const std::vector<SkColor>& colors) {
+  if (prominent_colors_ == colors)
     return;
 
-  prominent_color_ = color;
+  prominent_colors_ = colors;
   for (auto& observer : observers_)
     observer.OnWallpaperColorsChanged();
 }
 
+WallpaperController::ColorProfileIndex
+WallpaperController::GetColorProfileIndex(ColorProfile color_profile) const {
+  if (color_profile.saturation == SaturationRange::VIBRANT) {
+    switch (color_profile.luma) {
+      case LumaRange::DARK:
+        return COLOR_PROFILE_INDEX_DARK_VIBRANT;
+      case LumaRange::NORMAL:
+        return COLOR_PROFILE_INDEX_NORMAL_VIBRANT;
+      case LumaRange::LIGHT:
+        return COLOR_PROFILE_INDEX_LIGHT_VIBRANT;
+    }
+  } else {
+    switch (color_profile.luma) {
+      case LumaRange::DARK:
+        return COLOR_PROFILE_INDEX_DARK_MUTED;
+      case LumaRange::NORMAL:
+        return COLOR_PROFILE_INDEX_NORMAL_MUTED;
+      case LumaRange::LIGHT:
+        return COLOR_PROFILE_INDEX_LIGHT_MUTED;
+    }
+  }
+  NOTREACHED();
+  return COLOR_PROFILE_INDEX_DARK_MUTED;
+}
+
 void WallpaperController::CalculateWallpaperColors() {
   if (color_calculator_) {
     color_calculator_->RemoveObserver(this);
     color_calculator_.reset();
   }
 
   if (!ShouldCalculateColors()) {
-    SetProminentColor(kInvalidColor);
+    SetProminentColors(
+        std::vector<SkColor>(color_profiles_.size(), kInvalidColor));
     return;
   }
 
-  color_utils::LumaRange luma;
-  color_utils::SaturationRange saturation;
-  GetProminentColorProfile(&luma, &saturation);
-
   color_calculator_ = base::MakeUnique<wallpaper::WallpaperColorCalculator>(
-      GetWallpaper(), luma, saturation, sequenced_task_runner_);
+      GetWallpaper(), color_profiles_, sequenced_task_runner_);
   color_calculator_->AddObserver(this);
-  if (!color_calculator_->StartCalculation())
-    SetProminentColor(kInvalidColor);
+  if (!color_calculator_->StartCalculation()) {
+    SetProminentColors(
+        std::vector<SkColor>(color_profiles_.size(), kInvalidColor));
+  }
 }
 
 bool WallpaperController::ShouldCalculateColors() const {
   gfx::ImageSkia image = GetWallpaper();
   return IsShelfColoringEnabled() &&
          Shell::Get()->session_controller()->GetSessionState() ==
              session_manager::SessionState::ACTIVE &&
          !image.isNull();
 }
 
@@ skipping 25 matching lines @@
               base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
     }
   }
 }
 
 void WallpaperController::CompositorLockTimedOut() {
   compositor_lock_.reset();
 }
 
 }  // namespace ash