Supports changing resolutions from options UI page.

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/display_manager.h"
 #include "ash/display/output_configurator_animation.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "chromeos/display/output_configurator.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
-#include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/size_conversions.h"
 
 using ash::internal::DisplayManager;
 
 namespace chromeos {
 namespace options {
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return ash::Shell::GetInstance()->display_manager();
 }
 
 int64 GetDisplayId(const base::ListValue* args) {
   // Assumes the display ID is specified as the first argument.
   std::string id_value;
   if (!args->GetString(0, &id_value)) {
     LOG(ERROR) << "Can't find ID";
     return gfx::Display::kInvalidDisplayID;
   }
 
   int64 display_id = gfx::Display::kInvalidDisplayID;
   if (!base::StringToInt64(id_value, &display_id)) {
     LOG(ERROR) << "Invalid display id: " << id_value;
     return gfx::Display::kInvalidDisplayID;
   }
 
   return display_id;
 }
 
+bool CompareResolution(ash::internal::Resolution r1,
+                       ash::internal::Resolution r2) {
+  return r1.size.GetArea() < r2.size.GetArea();
+}
+
 }  // namespace
 
 DisplayOptionsHandler::DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DisplayOptionsHandler::~DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
@@ skipping 58 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setDisplayLayout",
       base::Bind(&DisplayOptionsHandler::HandleDisplayLayout,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setUIScale",
       base::Bind(&DisplayOptionsHandler::HandleSetUIScale,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "setResolution",
+      base::Bind(&DisplayOptionsHandler::HandleSetResolution,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "setOrientation",
       base::Bind(&DisplayOptionsHandler::HandleSetOrientation,
                  base::Unretained(this)));
 }
 
 void DisplayOptionsHandler::OnDisplayConfigurationChanging() {
 }
 
 void DisplayOptionsHandler::OnDisplayConfigurationChanged() {
   SendAllDisplayInfo();
@@ skipping 28 matching lines @@
     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()));
     js_display->SetBoolean("isPrimary", display.id() == primary_id);
     js_display->SetBoolean("isInternal", display.IsInternal());
     js_display->SetInteger("orientation",
                            static_cast<int>(display_info.rotation()));
-    std::vector<float> ui_scales = DisplayManager::GetScalesForDisplay(
-        display_info);
-    base::ListValue* js_scales = new base::ListValue();
-    gfx::SizeF base_size = display_info.bounds_in_pixel().size();
-    base_size.Scale(1.0f / display.device_scale_factor());
-    if (display_info.rotation() == gfx::Display::ROTATE_90 ||
-        display_info.rotation() == gfx::Display::ROTATE_270) {
-      float tmp = base_size.width();
-      base_size.set_width(base_size.height());
-      base_size.set_height(tmp);
+    std::vector<ash::internal::Resolution> resolutions;
+    std::vector<float> ui_scales;
+    if (display.IsInternal()) {
+      ui_scales = DisplayManager::GetScalesForDisplay(display_info);
+      gfx::SizeF base_size = display_info.bounds_in_pixel().size();
+      base_size.Scale(1.0f / display.device_scale_factor());
+      if (display_info.rotation() == gfx::Display::ROTATE_90 ||
+          display_info.rotation() == gfx::Display::ROTATE_270) {
+        float tmp = base_size.width();
+        base_size.set_width(base_size.height());
+        base_size.set_height(tmp);
+      }
+      for (size_t i = 0; i < ui_scales.size(); ++i) {
+        gfx::SizeF new_size = base_size;
+        new_size.Scale(ui_scales[i]);
+        resolutions.push_back(ash::internal::Resolution(
+            gfx::ToFlooredSize(new_size), false /* interlaced */));
+      }
+    } else {
+      for (size_t i = 0; i < display_info.resolutions().size(); ++i)
+        resolutions.push_back(display_info.resolutions()[i]);
     }
+    std::sort(resolutions.begin(), resolutions.end(), CompareResolution);
 
-    for (size_t i = 0; i < ui_scales.size(); ++i) {
-      base::DictionaryValue* scale_info = new base::DictionaryValue();
-      scale_info->SetDouble("scale", ui_scales[i]);
-      scale_info->SetInteger(
-          "width", gfx::ToFlooredInt(base_size.width() * ui_scales[i]));
-      scale_info->SetInteger(
-          "height", gfx::ToFlooredInt(base_size.height() * ui_scales[i]));
-      scale_info->SetBoolean("selected",
-                             display_info.ui_scale() == ui_scales[i]);
-      js_scales->Append(scale_info);
+    base::ListValue* js_resolutions = new base::ListValue();
+    gfx::Size current_size(bounds.width() * display.device_scale_factor(),
+                           bounds.height() * display.device_scale_factor());
+    for (size_t i = 0; i < resolutions.size(); ++i) {
+      base::DictionaryValue* resolution_info = new base::DictionaryValue();
+      if (!ui_scales.empty()) {
+        resolution_info->SetDouble("scale", ui_scales[i]);
+        if (ui_scales[i] == 1.0f)
+          resolution_info->SetBoolean("isBest", true);
+        resolution_info->SetBoolean(
+            "selected", display_info.ui_scale() == ui_scales[i]);
+      } else {
+        // Picks the largest one as the "best", which is the last element
+        // because |resolutions| is sorted by its area.
+        if (i == resolutions.size() - 1)
+          resolution_info->SetBoolean("isBest", true);
+        resolution_info->SetBoolean(
+            "selected", (resolutions[i].size == current_size));
+      }
+      resolution_info->SetInteger("width", resolutions[i].size.width());
+      resolution_info->SetInteger("height",resolutions[i].size.height());
+      js_resolutions->Append(resolution_info);
     }
-    js_display->Set("uiScales", js_scales);
+    js_display->Set("resolutions", js_resolutions);
     js_displays.Append(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 ash::DisplayLayout layout =
         display_controller->GetCurrentDisplayLayout();
     layout_value.reset(new base::FundamentalValue(layout.position));
     offset_value.reset(new base::FundamentalValue(layout.offset));
@@ skipping 61 matching lines @@
           static_cast<int>(offset)));
 }
 
 void DisplayOptionsHandler::HandleSetUIScale(const base::ListValue* args) {
   DCHECK(!args->empty());
 
   int64 display_id = GetDisplayId(args);
   if (display_id == gfx::Display::kInvalidDisplayID)
     return;
 
-  std::string ui_scale_value;
   double ui_scale = 0.0f;
-  if (!args->GetString(1, &ui_scale_value)) {
-    LOG(ERROR) << "Ca't find new ui_scale";
-    return;
-  }
-  if (!base::StringToDouble(ui_scale_value, &ui_scale)) {
-    LOG(ERROR) << "Invalid ui_scale: " << ui_scale_value;
+  if (!args->GetDouble(1, &ui_scale) || ui_scale == 0.0f) {
+    LOG(ERROR) << "Can't find new ui_scale";
     return;
   }
 
   GetDisplayManager()->SetDisplayUIScale(display_id, ui_scale);
 }
 
+void DisplayOptionsHandler::HandleSetResolution(const base::ListValue* args) {
+  DCHECK(!args->empty());
+  int64 display_id = GetDisplayId(args);
+  if (display_id == gfx::Display::kInvalidDisplayID)
+    return;
+  LOG(ERROR) << display_id;

[oshima, 2013/08/01 22:50:44]

remove this?

[Jun Mukai, 2013/08/02 01:35:18]

Done.

+
+  double width = 0.0f;
+  double height = 0.0f;
+  if (!args->GetDouble(1, &width) || width == 0.0f) {
+    LOG(ERROR) << "Can't find new width";
+    return;
+  }
+  if (!args->GetDouble(2, &height) || height == 0.0f) {
+    LOG(ERROR) << "Can't find new height";
+    return;
+  }
+
+  // TODO(mukai): creates a confirmation dialog.
+  GetDisplayManager()->SetDisplayResolution(
+      display_id, gfx::ToFlooredSize(gfx::SizeF(width, height)));
+}
+
 void DisplayOptionsHandler::HandleSetOrientation(const base::ListValue* args) {
   DCHECK(!args->empty());
 
   int64 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";
     return;
   }
   if (rotation_value == "90")
     new_rotation = gfx::Display::ROTATE_90;
   else if (rotation_value == "180")
     new_rotation = gfx::Display::ROTATE_180;
   else if (rotation_value == "270")
     new_rotation = gfx::Display::ROTATE_270;
   else if (rotation_value != "0")
     LOG(ERROR) << "Invalid rotation: " << rotation_value << " Falls back to 0";
 
   GetDisplayManager()->SetDisplayRotation(display_id, new_rotation);
 }
 
 }  // namespace options
 }  // namespace chromeos