Introduce DisplayConfigurationController

chrome/browser/ui/webui/options/chromeos/display_options_handler.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 "chrome/browser/ui/webui/options/chromeos/display_options_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
-#include "ash/display/display_animator.h"
+#include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/display/window_tree_host_manager.h"
-#include "ash/rotator/screen_rotation_animator.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 
-using ash::DisplayManager;
-
 namespace chromeos {
 namespace options {
 namespace {
 
-DisplayManager* GetDisplayManager() {
+ash::DisplayManager* GetDisplayManager() {
   return ash::Shell::GetInstance()->display_manager();
 }
 
+ash::DisplayConfigurationController* GetDisplayConfigurationController() {
+  return ash::Shell::GetInstance()->display_configuration_controller();
+}
+
 int64_t GetDisplayId(const base::ListValue* args) {
   // Assumes the display ID is specified as the first argument.
   std::string id_value;
   if (!args->GetString(0, &id_value)) {
     LOG(ERROR) << "Can't find ID";
     return gfx::Display::kInvalidDisplayID;
   }
 
   int64_t display_id = gfx::Display::kInvalidDisplayID;
   if (!base::StringToInt64(id_value, &display_id)) {
@@ skipping 170 matching lines @@
   web_ui()->RegisterMessageCallback(
       "setMirroring",
       base::Bind(&DisplayOptionsHandler::HandleMirroring,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setPrimary",
       base::Bind(&DisplayOptionsHandler::HandleSetPrimary,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setDisplayLayout",
-      base::Bind(&DisplayOptionsHandler::HandleDisplayLayout,
+      base::Bind(&DisplayOptionsHandler::HandleSetDisplayLayout,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setDisplayMode",
       base::Bind(&DisplayOptionsHandler::HandleSetDisplayMode,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setOrientation",
       base::Bind(&DisplayOptionsHandler::HandleSetOrientation,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setColorProfile",
       base::Bind(&DisplayOptionsHandler::HandleSetColorProfile,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setUnifiedDesktopEnabled",
       base::Bind(&DisplayOptionsHandler::HandleSetUnifiedDesktopEnabled,
                  base::Unretained(this)));
 }
 
 void DisplayOptionsHandler::OnDisplayConfigurationChanging() {
 }
 
 void DisplayOptionsHandler::OnDisplayConfigurationChanged() {
   UpdateDisplaySettingsEnabled();
   SendAllDisplayInfo();
 }
 
 void DisplayOptionsHandler::SendAllDisplayInfo() {
-  DisplayManager* display_manager = GetDisplayManager();
+  ash::DisplayManager* display_manager = GetDisplayManager();
 
   std::vector<gfx::Display> displays;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i)
     displays.push_back(display_manager->GetDisplayAt(i));
   SendDisplayInfo(displays);
 }
 
 void DisplayOptionsHandler::SendDisplayInfo(
     const std::vector<gfx::Display>& displays) {
-  DisplayManager* display_manager = GetDisplayManager();
-  base::FundamentalValue mode(
-      display_manager->IsInMirrorMode() ? DisplayManager::MIRRORING :
-      (display_manager->IsInUnifiedMode() ? DisplayManager::UNIFIED :
-       DisplayManager::EXTENDED));
-
+  ash::DisplayManager* display_manager = GetDisplayManager();
+  ash::DisplayManager::MultiDisplayMode display_mode;
+  if (display_manager->IsInMirrorMode())
+    display_mode = ash::DisplayManager::MIRRORING;
+  else if (display_manager->IsInUnifiedMode())
+    display_mode = ash::DisplayManager::UNIFIED;
+  else
+    display_mode = ash::DisplayManager::EXTENDED;
+  base::FundamentalValue mode(static_cast<int>(display_mode));
   int64_t primary_id = ash::Shell::GetScreen()->GetPrimaryDisplay().id();
   base::ListValue js_displays;
   for (const gfx::Display& display : displays) {
     const ash::DisplayInfo& display_info =
         display_manager->GetDisplayInfo(display.id());
     const gfx::Rect& bounds = display.bounds();
     base::DictionaryValue* js_display = new base::DictionaryValue();
     js_display->SetString("id", base::Int64ToString(display.id()));
     js_display->SetInteger("x", bounds.x());
     js_display->SetInteger("y", bounds.y());
@@ skipping 45 matching lines @@
 void DisplayOptionsHandler::UpdateDisplaySettingsEnabled() {
   bool enabled = GetDisplayManager()->num_connected_displays() <= 2;
   bool show_unified_desktop = GetDisplayManager()->unified_desktop_enabled();
 
   web_ui()->CallJavascriptFunction(
       "options.BrowserOptions.enableDisplaySettings",
       base::FundamentalValue(enabled),
       base::FundamentalValue(show_unified_desktop));
 }
 
-void DisplayOptionsHandler::OnFadeOutForMirroringFinished(bool is_mirroring) {
-  ash::Shell::GetInstance()->display_manager()->SetMirrorMode(is_mirroring);
-  // Not necessary to start fade-in animation. DisplayConfigurator will do that.
-}
-
-void DisplayOptionsHandler::OnFadeOutForDisplayLayoutFinished(
-    int position, int offset) {
-  SetCurrentDisplayLayout(
-      ash::DisplayLayout::FromInts(position, offset));
-  ash::Shell::GetInstance()->display_animator()->StartFadeInAnimation();
-}
-
 void DisplayOptionsHandler::HandleDisplayInfo(
     const base::ListValue* unused_args) {
   SendAllDisplayInfo();
 }
 
 void DisplayOptionsHandler::HandleMirroring(const base::ListValue* args) {
   DCHECK(!args->empty());
+  bool is_mirroring = false;
+  if (!args->GetBoolean(0, &is_mirroring))
+    NOTREACHED();
   content::RecordAction(
       base::UserMetricsAction("Options_DisplayToggleMirroring"));
-  bool is_mirroring = false;
-  args->GetBoolean(0, &is_mirroring);
-  ash::Shell::GetInstance()->display_animator()->StartFadeOutAnimation(
-      base::Bind(&DisplayOptionsHandler::OnFadeOutForMirroringFinished,
-                 base::Unretained(this), is_mirroring));
+  GetDisplayConfigurationController()->SetMirrorMode(is_mirroring,
+                                                     true /* user_action */);
 }
 
 void DisplayOptionsHandler::HandleSetPrimary(const base::ListValue* args) {
   DCHECK(!args->empty());
   int64_t display_id = GetDisplayId(args);
   if (display_id == gfx::Display::kInvalidDisplayID)
     return;
 
   content::RecordAction(base::UserMetricsAction("Options_DisplaySetPrimary"));
-  ash::Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
-      display_id);
+  GetDisplayConfigurationController()->SetPrimaryDisplayId(
+      display_id, true /* user_action */);
 }
 
-void DisplayOptionsHandler::HandleDisplayLayout(const base::ListValue* args) {
-  double layout = -1;
-  double offset = -1;
-  if (!args->GetDouble(0, &layout) || !args->GetDouble(1, &offset)) {
-    LOG(ERROR) << "Invalid parameter";
-    SendAllDisplayInfo();
-    return;
-  }
+void DisplayOptionsHandler::HandleSetDisplayLayout(
+    const base::ListValue* args) {
+  int64_t display_id = GetDisplayId(args);
+  int layout, offset;
+  if (!args->GetInteger(1, &layout))
+    NOTREACHED();
   DCHECK_LE(ash::DisplayLayout::TOP, layout);
   DCHECK_GE(ash::DisplayLayout::LEFT, layout);
+  if (!args->GetInteger(2, &offset))
+    NOTREACHED();
   content::RecordAction(base::UserMetricsAction("Options_DisplayRearrange"));
-  ash::Shell::GetInstance()->display_animator()->StartFadeOutAnimation(
-      base::Bind(&DisplayOptionsHandler::OnFadeOutForDisplayLayoutFinished,
-                 base::Unretained(this), static_cast<int>(layout),
-                 static_cast<int>(offset)));
+  GetDisplayConfigurationController()->SetDisplayLayout(
+      display_id, ash::DisplayLayout::FromInts(layout, offset),
+      true /* user_action */);
 }
 
 void DisplayOptionsHandler::HandleSetDisplayMode(const base::ListValue* args) {
   DCHECK(!args->empty());
 
   int64_t display_id = GetDisplayId(args);
   if (display_id == gfx::Display::kInvalidDisplayID)
     return;
 
   const base::DictionaryValue* mode_data = nullptr;
   if (!args->GetDictionary(1, &mode_data)) {
     LOG(ERROR) << "Failed to get mode data";
     return;
   }
 
   ash::DisplayMode mode;
   if (!ConvertValueToDisplayMode(mode_data, &mode))
     return;
 
   content::RecordAction(
       base::UserMetricsAction("Options_DisplaySetResolution"));
   ash::DisplayManager* display_manager = GetDisplayManager();
   ash::DisplayMode current_mode =
       display_manager->GetActiveModeForDisplayId(display_id);
-  if (display_manager->SetDisplayMode(display_id, mode) &&
-      !gfx::Display::IsInternalDisplayId(display_id)) {
-    ash::Shell::GetInstance()->resolution_notification_controller()->
-        PrepareNotification(
-            display_id, current_mode, mode, base::Bind(&StoreDisplayPrefs));
+  if (!display_manager->SetDisplayMode(display_id, mode)) {
+    LOG(ERROR) << "Unable to set display mode for: " << display_id
+               << " Mode: " << *mode_data;
+    return;
   }
+  if (gfx::Display::IsInternalDisplayId(display_id))
+    return;
+  // For external displays, show a notification confirming the resolution
+  // change.
+  ash::Shell::GetInstance()
+      ->resolution_notification_controller()
+      ->PrepareNotification(display_id, current_mode, mode,
+                            base::Bind(&chromeos::StoreDisplayPrefs));
 }
 
 void DisplayOptionsHandler::HandleSetOrientation(const base::ListValue* args) {
   DCHECK(!args->empty());
 
   int64_t display_id = GetDisplayId(args);
   if (display_id == gfx::Display::kInvalidDisplayID)
     return;
 
   std::string rotation_value;
   gfx::Display::Rotation new_rotation = gfx::Display::ROTATE_0;
   if (!args->GetString(1, &rotation_value)) {
     LOG(ERROR) << "Can't find new orientation";
     return;
   }
   if (rotation_value == "90")
     new_rotation = gfx::Display::ROTATE_90;
   else if (rotation_value == "180")
     new_rotation = gfx::Display::ROTATE_180;
   else if (rotation_value == "270")
     new_rotation = gfx::Display::ROTATE_270;
   else if (rotation_value != "0")
     LOG(ERROR) << "Invalid rotation: " << rotation_value << " Falls back to 0";
 
   content::RecordAction(
       base::UserMetricsAction("Options_DisplaySetOrientation"));
-  ash::ScreenRotationAnimator(display_id)
-      .Rotate(new_rotation, gfx::Display::ROTATION_SOURCE_USER);
+  GetDisplayConfigurationController()->SetDisplayRotation(
+      display_id, new_rotation, gfx::Display::ROTATION_SOURCE_USER,
+      true /* user_action */);
 }
 
 void DisplayOptionsHandler::HandleSetColorProfile(const base::ListValue* args) {
   DCHECK(!args->empty());
   int64_t display_id = GetDisplayId(args);
   if (display_id == gfx::Display::kInvalidDisplayID)
     return;
 
   std::string profile_value;
   if (!args->GetString(1, &profile_value)) {
     LOG(ERROR) << "Invalid profile_value";
     return;
   }
 
   int profile_id;
   if (!base::StringToInt(profile_value, &profile_id)) {
     LOG(ERROR) << "Invalid profile: " << profile_value;
     return;
   }
 
   if (profile_id < ui::COLOR_PROFILE_STANDARD ||
       profile_id > ui::COLOR_PROFILE_READING) {
     LOG(ERROR) << "Invalid profile_id: " << profile_id;
     return;
   }
 
+  content::RecordAction(
+      base::UserMetricsAction("Options_DisplaySetColorProfile"));
   GetDisplayManager()->SetColorCalibrationProfile(
       display_id, static_cast<ui::ColorCalibrationProfile>(profile_id));
+
   SendAllDisplayInfo();
 }
 
 void DisplayOptionsHandler::HandleSetUnifiedDesktopEnabled(
     const base::ListValue* args) {
   DCHECK(GetDisplayManager()->unified_desktop_enabled());
   bool enable = false;
-  if (args->GetBoolean(0, &enable)) {
-    GetDisplayManager()->SetDefaultMultiDisplayModeForCurrentDisplays(
-        enable ? DisplayManager::UNIFIED : DisplayManager::EXTENDED);
-    GetDisplayManager()->ReconfigureDisplays();
-  }
+  if (!args->GetBoolean(0, &enable))
+    NOTREACHED();
+
+  GetDisplayManager()->SetDefaultMultiDisplayModeForCurrentDisplays(
+      enable ? ash::DisplayManager::UNIFIED : ash::DisplayManager::EXTENDED);
 }
 
 }  // namespace options
 }  // namespace chromeos