Introduce DisplayConfigurationController

chrome/browser/extensions/display_info_provider_chromeos.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/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
+#include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
-#include "ash/display/window_tree_host_manager.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
-using ash::DisplayManager;
-
 namespace extensions {
 
 using api::system_display::Bounds;
 using api::system_display::DisplayUnitInfo;
 using api::system_display::DisplayProperties;
 using api::system_display::Insets;
 
 namespace {
 
 // Maximum allowed bounds origin absolute value.
@@ skipping 129 matching lines @@
 }
 
 // Updates the display layout for the target display in reference to the primary
 // display.
 void UpdateDisplayLayout(const gfx::Rect& primary_display_bounds,
                          int primary_display_id,
                          const gfx::Rect& target_display_bounds,
                          int target_display_id) {
   ash::DisplayLayout layout =
       GetLayoutForRectangles(primary_display_bounds, target_display_bounds);
-  ash::Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
-      layout);
+  layout.primary_id = primary_display_id;
+  ash::Shell::GetInstance()
+      ->display_configuration_controller()
+      ->SetDisplayLayout(target_display_id, layout, false /* user_action */);
 }
 
 // Validates that parameters passed to the SetInfo function are valid for the
 // desired display and the current display manager state.
 // Returns whether the parameters are valid. On failure |error| is set to the
 // error message.
 bool ValidateParamsForDisplay(const DisplayProperties& info,
                               const gfx::Display& display,
-                              DisplayManager* display_manager,
+                              ash::DisplayManager* display_manager,
                               int64_t primary_display_id,
                               std::string* error) {
   bool is_primary = display.id() == primary_display_id ||
                     (info.is_primary && *info.is_primary);
 
   // If mirroring source id is set, a display with the given id should exist,
   // and if should not be the same as the target display's id.
   if (info.mirroring_source_id && !info.mirroring_source_id->empty()) {
     int64_t mirroring_id;
     if (!base::StringToInt64(*info.mirroring_source_id, &mirroring_id) ||
@@ skipping 72 matching lines @@
     if ((info.overscan->top + info.overscan->bottom) * 2 > screen_height) {
       *error = "Vertical overscan is more than half of the screen height.";
       return false;
     }
   }
   return true;
 }
 
 // Gets the display with the provided string id.
 gfx::Display GetTargetDisplay(const std::string& display_id_str,
-                              DisplayManager* manager) {
+                              ash::DisplayManager* manager) {
   int64_t display_id;
   if (!base::StringToInt64(display_id_str, &display_id)) {
     // This should return invalid display.
     return gfx::Display();
   }
   return manager->GetDisplayForId(display_id);
 }
 
 }  // namespace
 
 DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS() {
 }
 
 DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {
 }
 
 bool DisplayInfoProviderChromeOS::SetInfo(const std::string& display_id_str,
                                           const DisplayProperties& info,
                                           std::string* error) {
-  DisplayManager* display_manager =
+  ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
-  DCHECK(display_manager);
-  ash::WindowTreeHostManager* window_tree_host_manager =
-      ash::Shell::GetInstance()->window_tree_host_manager();
-  DCHECK(window_tree_host_manager);
+  ash::DisplayConfigurationController* display_configuration_controller =
+      ash::Shell::GetInstance()->display_configuration_controller();
 
   const gfx::Display target = GetTargetDisplay(display_id_str, display_manager);
 
   if (target.id() == gfx::Display::kInvalidDisplayID) {
     *error = "Display not found.";
     return false;
   }
 
   int64_t display_id = target.id();
   // TODO(scottmg): Native is wrong http://crbug.com/133312
   const gfx::Display& primary =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 
   if (!ValidateParamsForDisplay(
           info, target, display_manager, primary.id(), error)) {
     return false;
   }
 
   // Process 'isPrimary' parameter.
-  if (info.is_primary && *info.is_primary && target.id() != primary.id())
-    window_tree_host_manager->SetPrimaryDisplayId(display_id);
+  if (info.is_primary && *info.is_primary && target.id() != primary.id()) {
+    display_configuration_controller->SetPrimaryDisplayId(
+        display_id, false /* user_action */);
+  }
 
   // Process 'mirroringSourceId' parameter.
-  if (info.mirroring_source_id &&
-      info.mirroring_source_id->empty() == display_manager->IsInMirrorMode()) {
-    window_tree_host_manager->ToggleMirrorMode();
+  if (info.mirroring_source_id) {
+    bool mirror = !info.mirroring_source_id->empty();
+    display_configuration_controller->SetMirrorMode(mirror,
+                                                    false /* user_action */);
   }
 
   // Process 'overscan' parameter.
   if (info.overscan) {
     display_manager->SetOverscanInsets(display_id,
                                        gfx::Insets(info.overscan->top,
                                                    info.overscan->left,
                                                    info.overscan->bottom,
                                                    info.overscan->right));
   }
 
   // Process 'rotation' parameter.
   if (info.rotation) {
-    display_manager->SetDisplayRotation(display_id,
-                                        DegreesToRotation(*info.rotation),
-                                        gfx::Display::ROTATION_SOURCE_ACTIVE);
+    display_configuration_controller->SetDisplayRotation(
+        display_id, DegreesToRotation(*info.rotation),
+        gfx::Display::ROTATION_SOURCE_ACTIVE, false /* user_action */);
   }
 
   // Process new display origin parameters.
   gfx::Point new_bounds_origin = target.bounds().origin();
   if (info.bounds_origin_x)
     new_bounds_origin.set_x(*info.bounds_origin_x);
   if (info.bounds_origin_y)
     new_bounds_origin.set_y(*info.bounds_origin_y);
 
   if (new_bounds_origin != target.bounds().origin()) {
@@ skipping 64 matching lines @@
   }
   return all_displays;
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions