MD Settings: Display: Add unified desktop control and modify api

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/resolution_notification_controller.h"
@@ skipping 221 matching lines @@
 // error message.
 bool ValidateParamsForDisplay(const system_display::DisplayProperties& info,
                               const display::Display& display,
                               display::DisplayManager* display_manager,
                               int64_t primary_display_id,
                               std::string* error) {
   int64_t id = display.id();
   bool is_primary =
       id == primary_display_id || (info.is_primary && *info.is_primary);
 
+  if (info.is_unified) {
+    if (!is_primary) {
+      *error = "Unified desktop mode can only be set for the primary display.";
+      return false;
+    }
+    if (info.mirroring_source_id) {
+      *error = "Unified desktop mode can not be set with mirroringSourceId.";
+      return false;
+    }
+    return true;
+  }
+
   // 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 = GetDisplay(*info.mirroring_source_id).id();
     if (mirroring_id == display::kInvalidDisplayId) {
       *error = "Display " + *info.mirroring_source_id + " not found.";
       return false;
     }
 
     if (*info.mirroring_source_id == base::Int64ToString(id)) {
@@ skipping 158 matching lines @@
 
 bool IsMaximizeModeWindowManagerEnabled() {
   return ash::Shell::Get()
       ->maximize_mode_controller()
       ->IsMaximizeModeWindowManagerEnabled();
 }
 
 }  // namespace
 
 // static
-const char DisplayInfoProviderChromeOS::
-    kCustomTouchCalibrationInProgressError[] =
+const char
+    DisplayInfoProviderChromeOS::kCustomTouchCalibrationInProgressError[] =
         "Another custom touch calibration already under progress.";
 
 // static
-const char DisplayInfoProviderChromeOS::
-    kCompleteCalibrationCalledBeforeStartError[] =
+const char
+    DisplayInfoProviderChromeOS::kCompleteCalibrationCalledBeforeStartError[] =
         "system.display.completeCustomTouchCalibration called before "
-             "system.display.startCustomTouchCalibration before.";
+        "system.display.startCustomTouchCalibration before.";
 
 // static
 const char DisplayInfoProviderChromeOS::kTouchBoundsNegativeError[] =
     "Bounds cannot have negative values.";
 
 // static
 const char DisplayInfoProviderChromeOS::kTouchCalibrationPointsNegativeError[] =
     "Display points and touch points cannot have negative coordinates";
 
 // static
@@ skipping 11 matching lines @@
 bool DisplayInfoProviderChromeOS::SetInfo(
     const std::string& display_id_str,
     const system_display::DisplayProperties& info,
     std::string* error) {
   if (ash_util::IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     *error = "Not implemented for mash.";
     return false;
   }
+
   display::DisplayManager* display_manager =
       ash::Shell::Get()->display_manager();
   ash::DisplayConfigurationController* display_configuration_controller =
       ash::Shell::Get()->display_configuration_controller();
 
   const display::Display target = GetDisplay(display_id_str);
 
   if (target.id() == display::kInvalidDisplayId) {
     *error = "Display not found:" + display_id_str;
     return false;
   }
 
   int64_t display_id = target.id();
   const display::Display& primary =
       display::Screen::GetScreen()->GetPrimaryDisplay();
 
   if (!ValidateParamsForDisplay(info, target, display_manager, primary.id(),
                                 error)) {
     return false;
   }
 
+  // Process 'isUnified' parameter if set.
+  if (info.is_unified) {
+    display_manager->SetDefaultMultiDisplayModeForCurrentDisplays(
+        *info.is_unified ? display::DisplayManager::UNIFIED
+                         : display::DisplayManager::EXTENDED);
+  }
+
   // Process 'isPrimary' parameter.
   if (info.is_primary && *info.is_primary && target.id() != primary.id())
     display_configuration_controller->SetPrimaryDisplayId(display_id);
 
   // Process 'mirroringSourceId' parameter.
   if (info.mirroring_source_id) {
     bool mirror = !info.mirroring_source_id->empty();
     display_configuration_controller->SetMirrorMode(mirror);
   }
 
@@ skipping 121 matching lines @@
 void DisplayInfoProviderChromeOS::EnableUnifiedDesktop(bool enable) {
   if (ash_util::IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return;
   }
   ash::Shell::Get()->display_manager()->SetUnifiedDesktopEnabled(enable);
 }
 
 DisplayInfoProvider::DisplayUnitInfoList
-DisplayInfoProviderChromeOS::GetAllDisplaysInfo() {
+DisplayInfoProviderChromeOS::GetAllDisplaysInfo(bool single_unified) {
   if (ash_util::IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return DisplayInfoProvider::DisplayUnitInfoList();
   }
   display::DisplayManager* display_manager =
       ash::Shell::Get()->display_manager();
+
   if (!display_manager->IsInUnifiedMode())
-    return DisplayInfoProvider::GetAllDisplaysInfo();
+    return DisplayInfoProvider::GetAllDisplaysInfo(single_unified);
 
-  std::vector<display::Display> displays =
-      display_manager->software_mirroring_display_list();
-  CHECK_GT(displays.size(), 0u);
+  // Chrome OS specific: get displays for unified mode.
+  std::vector<display::Display> displays;
+  int64_t primary_id;
+  if (single_unified) {
+    for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i)
+      displays.push_back(display_manager->GetDisplayAt(i));
+    primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
+  } else {
+    displays = display_manager->software_mirroring_display_list();
+    CHECK_GT(displays.size(), 0u);
+    // Use first display as primary.
+    primary_id = displays[0].id();
+  }
 
-  // Use first display as primary.
-  int64_t primary_id = displays[0].id();
   DisplayUnitInfoList all_displays;
   for (const display::Display& display : displays) {
-    system_display::DisplayUnitInfo unit =
+    system_display::DisplayUnitInfo unit_info =
         CreateDisplayUnitInfo(display, primary_id);
-    UpdateDisplayUnitInfoForPlatform(display, &unit);
-    all_displays.push_back(std::move(unit));
+    UpdateDisplayUnitInfoForPlatform(display, &unit_info);
+    unit_info.is_unified = true;
+    all_displays.push_back(std::move(unit_info));
   }
   return all_displays;
 }
 
 DisplayInfoProvider::DisplayLayoutList
 DisplayInfoProviderChromeOS::GetDisplayLayout() {
   if (ash_util::IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return DisplayInfoProvider::DisplayLayoutList();
@@ skipping 71 matching lines @@
   VLOG(1) << "OverscanCalibrationComplete: " << id;
   chromeos::OverscanCalibrator* calibrator = GetOverscanCalibrator(id);
   if (!calibrator)
     return false;
   calibrator->Commit();
   overscan_calibrators_[id].reset();
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::ShowNativeTouchCalibration(
-    const std::string& id, std::string* error,
+    const std::string& id,
+    std::string* error,
     const DisplayInfoProvider::TouchCalibrationCallback& callback) {
   if (ash_util::IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   VLOG(1) << "StartNativeTouchCalibration: " << id;
 
   // If a custom calibration is already running, then throw an error.
   if (custom_touch_calibration_active_) {
@@ skipping 51 matching lines @@
   touch_calibration_target_id_.clear();
 
   // If Complete() is called before calling Start(), throw an error.
   if (!custom_touch_calibration_active_) {
     *error = kCompleteCalibrationCalledBeforeStartError;
     return false;
   }
 
   custom_touch_calibration_active_ = false;
 
-  if (!ValidateParamsForTouchCalibration(
-      touch_calibration_target_id_, display, GetTouchCalibrator(), error)) {
+  if (!ValidateParamsForTouchCalibration(touch_calibration_target_id_, display,
+                                         GetTouchCalibrator(), error)) {
     return false;
   }
 
   display::TouchCalibrationData::CalibrationPointPairQuad calibration_points;
   calibration_points[0] = GetCalibrationPair(pairs.pair1);
   calibration_points[1] = GetCalibrationPair(pairs.pair2);
   calibration_points[2] = GetCalibrationPair(pairs.pair3);
   calibration_points[3] = GetCalibrationPair(pairs.pair4);
 
   // The display bounds cannot have negative values.
@@ skipping 68 matching lines @@
     touch_calibrator_.reset(new chromeos::TouchCalibratorController);
   return touch_calibrator_.get();
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions