Overscan calibration UI.

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 <string>
 
 #include "ash/display/display_controller.h"
 #include "ash/display/output_configurator_animation.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "base/bind.h"
-#include "base/json/json_value_converter.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
+#include "chrome/browser/chromeos/display/overscan_calibrator.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/display/output_configurator.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "ui/aura/env.h"
 #include "ui/aura/display_manager.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
@@ skipping 18 matching lines @@
   localized_strings->SetString("startMirroring", l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_START_MIRRORING));
   localized_strings->SetString("stopMirroring", l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_STOP_MIRRORING));
   localized_strings->SetString("setPrimary", l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_SET_PRIMARY));
   localized_strings->SetString("applyResult", l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_APPLY_RESULT));
   localized_strings->SetString("resolution", l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_RESOLUTION));
+  localized_strings->SetString(
+      "startCalibratingOverscan", l10n_util::GetStringUTF16(
+          IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_START_CALIBRATING_OVERSCAN));
+  localized_strings->SetString(
+      "finishCalibratingOverscan", l10n_util::GetStringUTF16(
+          IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_FINISH_CALIBRATING_OVERSCAN));
+  localized_strings->SetString(
+      "clearCalibratingOverscan", l10n_util::GetStringUTF16(
+          IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_CLEAR_CALIBRATING_OVERSCAN));
 }
 
 void DisplayOptionsHandler::InitializePage() {
   DCHECK(web_ui());
   UpdateDisplaySectionVisibility();
 }
 
 void DisplayOptionsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "getDisplayInfo",
       base::Bind(&DisplayOptionsHandler::HandleDisplayInfo,
                  base::Unretained(this)));
   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::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "startOverscanCalibration",
+      base::Bind(&DisplayOptionsHandler::HandleStartOverscanCalibration,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "finishOverscanCalibration",
+      base::Bind(&DisplayOptionsHandler::HandleFinishOverscanCalibration,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "clearOverscanCalibration",
+      base::Bind(&DisplayOptionsHandler::HandleClearOverscanCalibration,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "updateOverscanCalibration",
+      base::Bind(&DisplayOptionsHandler::HandleUpdateOverscanCalibration,
+                 base::Unretained(this)));
 }
 
 void DisplayOptionsHandler::OnDisplayBoundsChanged(
     const gfx::Display& display) {
   SendDisplayInfo();
 }
 
 void DisplayOptionsHandler::OnDisplayAdded(const gfx::Display& new_display) {
   UpdateDisplaySectionVisibility();
   SendDisplayInfo();
@@ skipping 32 matching lines @@
     const gfx::Rect& bounds = display->bounds();
     base::DictionaryValue* js_display = new base::DictionaryValue();
     js_display->SetString("id", base::Int64ToString(display->id()));
     js_display->SetDouble("x", bounds.x());
     js_display->SetDouble("y", bounds.y());
     js_display->SetDouble("width", bounds.width());
     js_display->SetDouble("height", bounds.height());
     js_display->SetString("name",
                           display_manager->GetDisplayNameFor(*display));
     js_display->SetBoolean("isPrimary", display->id() == primary_id);
+    base::DictionaryValue* js_insets = new base::DictionaryValue();
+    const gfx::Insets& insets =
+        display_controller->GetOverscanInsets(display->id());
+    js_insets->SetInteger("top", insets.top());
+    js_insets->SetInteger("left", insets.left());
+    js_insets->SetInteger("bottom", insets.bottom());
+    js_insets->SetInteger("right", insets.right());
+    js_display->Set("overscan", js_insets);
     displays.Set(i, js_display);
   }
 
   scoped_ptr<base::Value> layout_value(base::Value::CreateNullValue());
   scoped_ptr<base::Value> offset_value(base::Value::CreateNullValue());
   if (display_manager->GetNumDisplays() > 1) {
     const gfx::Display secondary_display =
         ash::ScreenAsh::GetSecondaryDisplay();
     const ash::DisplayLayout& layout =
         display_controller->GetLayoutForDisplay(secondary_display);
@@ skipping 80 matching lines @@
   DCHECK_LE(ash::DisplayLayout::TOP, layout);
   DCHECK_GE(ash::DisplayLayout::LEFT, layout);
   ash::Shell::GetInstance()->output_configurator_animation()->
       StartFadeOutAnimation(base::Bind(
           &DisplayOptionsHandler::OnFadeOutForDisplayLayoutFinished,
           base::Unretained(this),
           static_cast<int>(layout),
           static_cast<int>(offset)));
 }
 
+void DisplayOptionsHandler::HandleStartOverscanCalibration(
+    const base::ListValue* args) {
+  int64 display_id = gfx::Display::kInvalidDisplayID;
+  std::string id_value;
+  if (!args->GetString(0, &id_value)) {
+    LOG(ERROR) << "Can't find ID";
+    return;
+  }
+  if (!base::StringToInt64(id_value, &display_id) ||
+      display_id == gfx::Display::kInvalidDisplayID) {
+    LOG(ERROR) << "Invalid parameter: " << id_value;
+    return;
+  }
+
+  const gfx::Display& display = ash::ScreenAsh::GetDisplayForId(display_id);
+  DCHECK(display.is_valid());
+  ash::DisplayController* display_controller =
+      ash::Shell::GetInstance()->display_controller();
+  overscan_calibrator_.reset(new OverscanCalibrator(
+      display,
+      display_controller->GetOverscanInsets(display_id)));
+}
+
+void DisplayOptionsHandler::HandleFinishOverscanCalibration(
+    const base::ListValue* args) {
+  DCHECK(overscan_calibrator_.get());
+  overscan_calibrator_->Commit();
+  overscan_calibrator_.reset();
+  SendDisplayInfo();
+}
+
+void DisplayOptionsHandler::HandleClearOverscanCalibration(
+    const base::ListValue* args) {
+  DCHECK(overscan_calibrator_.get());
+  overscan_calibrator_->UpdateInsets(gfx::Insets());
+  overscan_calibrator_->Commit();
+  SendDisplayInfo();
+}
+
+void DisplayOptionsHandler::HandleUpdateOverscanCalibration(
+    const base::ListValue* args) {
+  DCHECK(overscan_calibrator_.get());
+  double top = 0, left = 0, bottom = 0, right = 0;
+  if (!args->GetDouble(0, &top) || !args->GetDouble(1, &left) ||
+      !args->GetDouble(2, &bottom) || !args->GetDouble(3, &right)) {
+    LOG(ERROR) << "Can't find overscan insets data.";
+    return;
+  }
+
+  overscan_calibrator_->UpdateInsets(gfx::Insets(top, left, bottom, right));
+}
+
 }  // namespace options
 }  // namespace chromeos