Update display_options.js to better match chrome.system.display

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>
@@ skipping 130 matching lines @@
   result->SetDouble("refreshRate", mode.refresh_rate);
   result->SetBoolean(
       "isBest", is_internal ? (mode.ui_scale == 1.0f) : mode.native);
   result->SetBoolean("isNative", mode.native);
   result->SetBoolean(
       "selected", mode.IsEquivalent(
           GetDisplayManager()->GetActiveModeForDisplayId(display_id)));
   return result;
 }
 
+base::DictionaryValue* ConvertBoundsToValue(const gfx::Rect& bounds) {
+  base::DictionaryValue* result = new base::DictionaryValue();
+  result->SetInteger("left", bounds.x());
+  result->SetInteger("top", bounds.y());
+  result->SetInteger("width", bounds.width());
+  result->SetInteger("height", bounds.height());
+  return result;
+}
+
 }  // namespace
 
 DisplayOptionsHandler::DisplayOptionsHandler() {
   // ash::Shell doesn't exist in Athena.
   // See: http://crbug.com/416961
   ash::Shell::GetInstance()->window_tree_host_manager()->AddObserver(this);
 }
 
 DisplayOptionsHandler::~DisplayOptionsHandler() {
   // ash::Shell doesn't exist in Athena.
@@ skipping 71 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setDisplayLayout",
       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,
+      "setRotation",
+      base::Bind(&DisplayOptionsHandler::HandleSetRotation,
                  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)));
 }
@@ skipping 24 matching lines @@
   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());
-    js_display->SetInteger("width", bounds.width());
-    js_display->SetInteger("height", bounds.height());
     js_display->SetString("name",
                           display_manager->GetDisplayNameForId(display.id()));
+    base::DictionaryValue* display_bounds =
+        ConvertBoundsToValue(display.bounds());
+    js_display->Set("bounds", display_bounds);
     js_display->SetBoolean("isPrimary", display.id() == primary_id);
     js_display->SetBoolean("isInternal", display.IsInternal());
-    js_display->SetInteger("orientation",
-                           static_cast<int>(display_info.GetActiveRotation()));
+    js_display->SetInteger("rotation", display.RotationAsDegree());
 
     base::ListValue* js_resolutions = new base::ListValue();
     for (const ash::DisplayMode& display_mode : display_info.display_modes()) {
       js_resolutions->Append(
           ConvertDisplayModeToValue(display.id(), display_mode));
     }
     js_display->Set("resolutions", js_resolutions);
 
-    js_display->SetInteger("colorProfile", display_info.color_profile());
+    js_display->SetInteger("colorProfileId", display_info.color_profile());
     base::ListValue* available_color_profiles = new base::ListValue();
     for (const auto& color_profile : display_info.available_color_profiles()) {
       const base::string16 profile_name = GetColorProfileName(color_profile);
       if (profile_name.empty())
         continue;
       base::DictionaryValue* color_profile_dict = new base::DictionaryValue();
       color_profile_dict->SetInteger("profileId", color_profile);
       color_profile_dict->SetString("name", profile_name);
       available_color_profiles->Append(color_profile_dict);
     }
@@ skipping 98 matching lines @@
   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) {
+void DisplayOptionsHandler::HandleSetRotation(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";
+  int rotation_value = 0;
+  if (!args->GetInteger(1, &rotation_value)) {
+    LOG(ERROR) << "Can't parse rotation: " << args;
     return;
   }
-  if (rotation_value == "90")
+  gfx::Display::Rotation new_rotation = gfx::Display::ROTATE_0;
+  if (rotation_value == 90)
     new_rotation = gfx::Display::ROTATE_90;
-  else if (rotation_value == "180")
+  else if (rotation_value == 180)
     new_rotation = gfx::Display::ROTATE_180;
-  else if (rotation_value == "270")
+  else if (rotation_value == 270)
     new_rotation = gfx::Display::ROTATE_270;
-  else if (rotation_value != "0")
+  else if (rotation_value != 0)
     LOG(ERROR) << "Invalid rotation: " << rotation_value << " Falls back to 0";
 
   content::RecordAction(
       base::UserMetricsAction("Options_DisplaySetOrientation"));
   GetDisplayConfigurationController()->SetDisplayRotation(
       display_id, new_rotation, gfx::Display::ROTATION_SOURCE_USER,
       true /* user_action */);
 }
 
 void DisplayOptionsHandler::HandleSetColorProfile(const base::ListValue* args) {
@@ skipping 34 matching lines @@
   bool enable = false;
   if (!args->GetBoolean(0, &enable))
     NOTREACHED();
 
   GetDisplayManager()->SetDefaultMultiDisplayModeForCurrentDisplays(
       enable ? ash::DisplayManager::UNIFIED : ash::DisplayManager::EXTENDED);
 }
 
 }  // namespace options
 }  // namespace chromeos