Add overscanCalibration methods to system_display.idl

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/resolution_notification_controller.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
+#include "chrome/browser/chromeos/display/overscan_calibrator.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 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.
 const int kMaxBoundsOrigin = 200 * 1000;
 
+// Gets the display with the provided string id.
+display::Display GetDisplay(const std::string& display_id_str) {
+  int64_t display_id;
+  if (!base::StringToInt64(display_id_str, &display_id))
+    return display::Display();
+  return ash::Shell::GetInstance()->display_manager()->GetDisplayForId(
+      display_id);
+}
+
 // Checks if the given integer value is valid display rotation in degrees.
 bool IsValidRotationValue(int rotation) {
   return rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270;
 }
 
 // Converts integer integer value in degrees to Rotation enum value.
 display::Display::Rotation DegreesToRotation(int degrees) {
   DCHECK(IsValidRotationValue(degrees));
   switch (degrees) {
     case 0:
@@ skipping 145 matching lines @@
                               ash::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 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) ||
-        display_manager->GetDisplayForId(mirroring_id).id() ==
-            display::Display::kInvalidDisplayID) {
+    int64_t mirroring_id = GetDisplay(*info.mirroring_source_id).id();
+    if (mirroring_id == display::Display::kInvalidDisplayID) {
       *error = "Display " + *info.mirroring_source_id + " not found.";
       return false;
     }
 
     if (*info.mirroring_source_id == base::Int64ToString(id)) {
       *error = "Not allowed to mirror self.";
       return false;
     }
   }
 
@@ skipping 92 matching lines @@
       // change.
       ash::Shell::GetInstance()
           ->resolution_notification_controller()
           ->PrepareNotification(id, current_mode, new_mode,
                                 base::Bind(&chromeos::StoreDisplayPrefs));
     }
   }
   return true;
 }
 
-// Gets the display with the provided string id.
-display::Display GetTargetDisplay(const std::string& display_id_str,
-                                  ash::DisplayManager* manager) {
-  int64_t display_id;
-  if (!base::StringToInt64(display_id_str, &display_id)) {
-    // This should return invalid display.
-    return display::Display();
-  }
-  return manager->GetDisplayForId(display_id);
-}
-
 extensions::api::system_display::DisplayMode GetDisplayMode(
     ash::DisplayManager* display_manager,
     const ash::DisplayInfo& display_info,
     const ash::DisplayMode& display_mode) {
   extensions::api::system_display::DisplayMode result;
 
   bool is_internal = display::Display::HasInternalDisplay() &&
                      display::Display::InternalDisplayId() == display_info.id();
   gfx::Size size_dip = display_mode.GetSizeInDIP(is_internal);
   result.width = size_dip.width();
@@ skipping 17 matching lines @@
 }
 
 bool DisplayInfoProviderChromeOS::SetInfo(const std::string& display_id_str,
                                           const DisplayProperties& info,
                                           std::string* error) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ash::DisplayConfigurationController* display_configuration_controller =
       ash::Shell::GetInstance()->display_configuration_controller();
 
-  const display::Display target =
-      GetTargetDisplay(display_id_str, display_manager);
+  const display::Display target = GetDisplay(display_id_str);
 
   if (target.id() == display::Display::kInvalidDisplayID) {
     *error = "Display not found.";
     return false;
   }
 
   int64_t display_id = target.id();
   const display::Display& primary =
       display::Screen::GetScreen()->GetPrimaryDisplay();
 
@@ skipping 101 matching lines @@
   DisplayUnitInfoList all_displays;
   for (const display::Display& display : displays) {
     api::system_display::DisplayUnitInfo unit =
         CreateDisplayUnitInfo(display, primary_id);
     UpdateDisplayUnitInfoForPlatform(display, &unit);
     all_displays.push_back(std::move(unit));
   }
   return all_displays;
 }
 
+bool DisplayInfoProviderChromeOS::OverscanCalibrationStart(
+    const std::string& id) {
+  VLOG(1) << "OverscanCalibrationStart: " << id;
+  const display::Display display = GetDisplay(id);
+  if (display.id() == display::Display::kInvalidDisplayID)
+    return false;
+  auto insets =
+      ash::Shell::GetInstance()->window_tree_host_manager()->GetOverscanInsets(
+          display.id());
+  overscan_calibrators_[id].reset(
+      new chromeos::OverscanCalibrator(display, insets));
+  return true;
+}
+
+bool DisplayInfoProviderChromeOS::OverscanCalibrationAdjust(
+    const std::string& id,
+    const api::system_display::Insets& delta) {
+  VLOG(1) << "OverscanCalibrationAdjust: " << id;
+  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  if (!calibrator)
+    return false;
+  gfx::Insets insets = calibrator->insets();
+  insets += gfx::Insets(delta.top, delta.left, delta.bottom, delta.right);
+  calibrator->UpdateInsets(insets);
+  return true;
+}
+
+bool DisplayInfoProviderChromeOS::OverscanCalibrationReset(
+    const std::string& id) {
+  VLOG(1) << "OverscanCalibrationReset: " << id;
+  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  if (!calibrator)
+    return false;
+  calibrator->Reset();
+  return true;
+}
+
+bool DisplayInfoProviderChromeOS::OverscanCalibrationComplete(
+    const std::string& id) {
+  VLOG(1) << "OverscanCalibrationComplete: " << id;
+  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  if (!calibrator)
+    return false;
+  calibrator->Commit();
+  overscan_calibrators_[id].reset();
+  return true;
+}
+
+chromeos::OverscanCalibrator* DisplayInfoProviderChromeOS::GetCalibrator(
+    const std::string& id) {
+  auto iter = overscan_calibrators_.find(id);
+  if (iter == overscan_calibrators_.end())
+    return nullptr;
+  return iter->second.get();
+}
+
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions