Modifies the threshold for hidpi displays.

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"
@@ skipping 36 matching lines @@
 
   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 CompareDisplayMode(ash::DisplayMode d1, ash::DisplayMode d2) {
-  if (d1.size.GetArea() == d2.size.GetArea())
-    return d1.refresh_rate < d2.refresh_rate;
-  return d1.size.GetArea() < d2.size.GetArea();
+bool CompareResolution(base::Value* display1, base::Value* display2) {
+  base::DictionaryValue* d1 = NULL;
+  base::DictionaryValue* d2 = NULL;
+  CHECK(display1->GetAsDictionary(&d1) && display2->GetAsDictionary(&d2));
+  int width1 = 0, height1 = 0, width2 = 0, height2 = 0;
+  CHECK(d1->GetInteger("width", &width1) && d1->GetInteger("height", &height1));
+  CHECK(d2->GetInteger("width", &width2) && d2->GetInteger("height", &height2));
+  double scale_factor1 = 0, scale_factor2 = 0;
+  if (d1->GetDouble("scaleFactor", &scale_factor1)) {
+    width1 /= scale_factor1;
+    height1 /= scale_factor1;
+  }
+  if (d2->GetDouble("scaleFactor", &scale_factor2)) {
+    width2 /= scale_factor2;
+    height2 /= scale_factor2;
+  }
+
+  if (width1 * height1 == width2 * height2) {
+    if (scale_factor1 != scale_factor2)
+      return scale_factor1 < scale_factor2;
+
+    int refresh_rate1 = 0, refresh_rate2 = 0;
+    CHECK(d1->GetInteger("refreshRate", &refresh_rate1) ==
+          d2->GetInteger("refreshRate", &refresh_rate2));
+    return refresh_rate1 < refresh_rate2;
+  }
+  return width1 * height1 < width2 * height2;
 }
 
 base::string16 GetColorProfileName(ui::ColorCalibrationProfile profile) {
   switch (profile) {
     case ui::COLOR_PROFILE_STANDARD:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_STANDARD);
     case ui::COLOR_PROFILE_DYNAMIC:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_DYNAMIC);
     case ui::COLOR_PROFILE_MOVIE:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_MOVIE);
     case ui::COLOR_PROFILE_READING:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_READING);
     case ui::NUM_COLOR_PROFILES:
       break;
   }
 
   NOTREACHED();
   return base::string16();
 }
 
+scoped_ptr<base::ListValue> GetResolutionsForInternalDisplay(
+    const ash::DisplayInfo& display_info) {
+  scoped_ptr<base::ListValue> js_resolutions(new base::ListValue);
+  const std::vector<float> ui_scales =
+      DisplayManager::GetScalesForDisplay(display_info);
+  gfx::SizeF base_size = display_info.bounds_in_native().size();
+  base_size.Scale(1.0f / display_info.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) {
+    base::DictionaryValue* resolution_info = new base::DictionaryValue();
+    gfx::SizeF new_size = base_size;
+    new_size.Scale(ui_scales[i]);
+    gfx::Size resolution = gfx::ToFlooredSize(new_size);
+    resolution_info->SetDouble("scale", ui_scales[i]);
+    if (ui_scales[i] == 1.0f)
+      resolution_info->SetBoolean("isBest", true);
+    resolution_info->SetBoolean(
+        "selected", display_info.configured_ui_scale() == ui_scales[i]);
+    resolution_info->SetInteger("width", resolution.width());
+    resolution_info->SetInteger("height", resolution.height());
+    js_resolutions->Append(resolution_info);
+  }
+
+  return js_resolutions.Pass();
+}
+
+scoped_ptr<base::ListValue> GetResolutionsForExternalDisplay(
+    const ash::DisplayInfo& display_info) {
+  scoped_ptr<base::ListValue> js_resolutions(new base::ListValue);
+
+  gfx::Size current_size = display_info.bounds_in_native().size();
+  gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
+  int largest_index = -1;
+  int largest_area = -1;
+
+  for (size_t i = 0; i < display_info.display_modes().size(); ++i) {
+    base::DictionaryValue* resolution_info = new base::DictionaryValue();
+    const ash::DisplayMode& display_mode = display_info.display_modes()[i];
+    gfx::Size resolution = display_mode.size;
+
+    if (resolution.GetArea() > largest_area) {
+      resolution_info->SetBoolean("isBest", true);
+      largest_area = resolution.GetArea();
+      if (largest_index >= 0) {
+        base::DictionaryValue* prev_largest = NULL;
+        CHECK(js_resolutions->GetDictionary(largest_index, &prev_largest));
+        prev_largest->SetBoolean("isBest", false);
+      }
+      largest_index = i;
+    }
+
+    if (resolution == current_size) {
+      // Right now, the scale factor for unselected resolutions is unknown.
+      // TODO(mukai): Set the scale factor for unselected ones.
+      resolution_info->SetDouble(
+          "scaleFactor", display_info.device_scale_factor());
+      resolution_info->SetBoolean("selected", true);
+    }
+
+    resolution.Enlarge(
+        -current_overscan.width(), -current_overscan.height());
+    resolution_info->SetInteger("width", resolution.width());
+    resolution_info->SetInteger("height", resolution.height());
+    resolution_info->SetDouble("refreshRate", display_mode.refresh_rate);
+    js_resolutions->Append(resolution_info);
+  }
+
+  return js_resolutions.Pass();
+}
+
 }  // namespace
 
 DisplayOptionsHandler::DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DisplayOptionsHandler::~DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
@@ skipping 115 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<ash::DisplayMode> display_modes;
-    std::vector<float> ui_scales;
-    if (display.IsInternal()) {
-      ui_scales = DisplayManager::GetScalesForDisplay(display_info);
-      gfx::SizeF base_size = display_info.bounds_in_native().size();
-      base_size.Scale(1.0f / display_info.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]);
-        display_modes.push_back(ash::DisplayMode(
-            gfx::ToFlooredSize(new_size), -1.0f, false, false));
-      }
-    } else {
-      for (size_t i = 0; i < display_info.display_modes().size(); ++i)
-        display_modes.push_back(display_info.display_modes()[i]);
-    }
-    std::sort(display_modes.begin(), display_modes.end(), CompareDisplayMode);
 
-    base::ListValue* js_resolutions = new base::ListValue();
-    gfx::Size current_size = display_info.bounds_in_native().size();
-    gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
-    for (size_t i = 0; i < display_modes.size(); ++i) {
-      base::DictionaryValue* resolution_info = new base::DictionaryValue();
-      gfx::Size resolution = display_modes[i].size;
-      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.configured_ui_scale() == ui_scales[i]);
-      } else {
-        // Picks the largest one as the "best", which is the last element
-        // because |display_modes| is sorted by its area.
-        if (i == display_modes.size() - 1)
-          resolution_info->SetBoolean("isBest", true);
-        resolution_info->SetBoolean("selected", (resolution == current_size));
-        resolution.Enlarge(
-            -current_overscan.width(), -current_overscan.height());
-      }
-      resolution_info->SetInteger("width", resolution.width());
-      resolution_info->SetInteger("height", resolution.height());
-      if (display_modes[i].refresh_rate > 0.0f) {
-        resolution_info->SetDouble("refreshRate",
-                                   display_modes[i].refresh_rate);
-      }
-      js_resolutions->Append(resolution_info);
-    }
-    js_display->Set("resolutions", js_resolutions);
+    scoped_ptr<base::ListValue> js_resolutions = display.IsInternal() ?
+        GetResolutionsForInternalDisplay(display_info) :
+        GetResolutionsForExternalDisplay(display_info);
+    std::sort(
+        js_resolutions->begin(), js_resolutions->end(), CompareResolution);
+    js_display->Set("resolutions", js_resolutions.release());
 
     js_display->SetInteger("colorProfile", display_info.color_profile());
     base::ListValue* available_color_profiles = new base::ListValue();
     for (size_t i = 0;
          i < display_info.available_color_profiles().size(); ++i) {
       base::DictionaryValue* color_profile_dict = new base::DictionaryValue();
       ui::ColorCalibrationProfile color_profile =
           display_info.available_color_profiles()[i];
       color_profile_dict->SetInteger("profileId", color_profile);
       color_profile_dict->SetString("name", GetColorProfileName(color_profile));
@@ skipping 196 matching lines @@
     return;
   }
 
   GetDisplayManager()->SetColorCalibrationProfile(
       display_id, static_cast<ui::ColorCalibrationProfile>(profile_id));
   SendAllDisplayInfo();
 }
 
 }  // namespace options
 }  // namespace chromeos