Add WebUI::GetDeviceScale

chrome/browser/ui/webui/options2/chromeos/internet_options_handler2.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/options2/chromeos/internet_options_handler2.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 1117 matching lines @@
   Browser* browser =
       browser::FindBrowserWithProfile(Profile::FromWebUI(web_ui()));
   return browser->window()->GetNativeWindow();
 }
 
 Browser* InternetOptionsHandler::GetAppropriateBrowser() {
   return browser::FindOrCreateTabbedBrowser(
       ProfileManager::GetDefaultProfileOrOffTheRecord());
 }
 
-float InternetOptionsHandler::GetIconScaleFactor() {
-  gfx::NativeWindow window = GetNativeWindow();
-  gfx::Display display = gfx::Screen::GetMonitorNearestWindow(window);
-  return display.device_scale_factor();
-}
-
 void InternetOptionsHandler::NetworkCommandCallback(const ListValue* args) {
   std::string str_type;
   std::string service_path;
   std::string command;
   if (args->GetSize() != 3 ||
       !args->GetString(0, &str_type) ||
       !args->GetString(1, &service_path) ||
       !args->GetString(2, &command)) {
     NOTREACHED();
     return;
@@ skipping 171 matching lines @@
 
 ListValue* InternetOptionsHandler::GetWiredList() {
   ListValue* list = new ListValue();
 
   // If ethernet is not enabled, then don't add anything.
   if (cros_->ethernet_enabled()) {
     const chromeos::EthernetNetwork* ethernet_network =
         cros_->ethernet_network();
     if (ethernet_network) {
       NetworkInfoDictionary network_dict(ethernet_network,
-                                         GetIconScaleFactor());
+                                         web_ui()->GetDeviceScale());
       network_dict.set_name(
           l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET)),
       list->Append(network_dict.BuildDictionary());
     }
   }
   return list;
 }
 
 ListValue* InternetOptionsHandler::GetWirelessList() {
   ListValue* list = new ListValue();
 
   const chromeos::WifiNetworkVector& wifi_networks = cros_->wifi_networks();
   for (chromeos::WifiNetworkVector::const_iterator it =
       wifi_networks.begin(); it != wifi_networks.end(); ++it) {
-    NetworkInfoDictionary network_dict(*it, GetIconScaleFactor());
+    NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
     network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
     list->Append(network_dict.BuildDictionary());
   }
 
   const chromeos::WimaxNetworkVector& wimax_networks = cros_->wimax_networks();
   for (chromeos::WimaxNetworkVector::const_iterator it =
       wimax_networks.begin(); it != wimax_networks.end(); ++it) {
-    NetworkInfoDictionary network_dict(*it, GetIconScaleFactor());
+    NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
     network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
     list->Append(network_dict.BuildDictionary());
   }
 
   const chromeos::CellularNetworkVector cellular_networks =
       cros_->cellular_networks();
   for (chromeos::CellularNetworkVector::const_iterator it =
       cellular_networks.begin(); it != cellular_networks.end(); ++it) {
-    NetworkInfoDictionary network_dict(*it, GetIconScaleFactor());
+    NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
     network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
     network_dict.set_activation_state((*it)->activation_state());
     network_dict.set_needs_new_plan(
         (*it)->SupportsDataPlan() && (*it)->restricted_pool());
     list->Append(network_dict.BuildDictionary());
   }
 
   const chromeos::NetworkDevice* cellular_device = cros_->FindCellularDevice();
   if (cellular_device && cellular_device->support_network_scan() &&
       cros_->cellular_enabled()) {
-    NetworkInfoDictionary network_dict(GetIconScaleFactor());
+    NetworkInfoDictionary network_dict(web_ui()->GetDeviceScale());
     network_dict.set_service_path(kOtherNetworksFakePath);
     network_dict.set_icon(
         chromeos::NetworkMenuIcon::GetDisconnectedImage(
             chromeos::NetworkMenuIcon::BARS,
             chromeos::NetworkMenuIcon::COLOR_DARK));
     network_dict.set_name(
         l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS));
     network_dict.set_connectable(true);
     network_dict.set_connection_type(chromeos::TYPE_CELLULAR);
     network_dict.set_activation_state(chromeos::ACTIVATION_STATE_ACTIVATED);
     list->Append(network_dict.BuildDictionary());
   }
 
   return list;
 }
 
 ListValue* InternetOptionsHandler::GetVPNList() {
   ListValue* list = new ListValue();
 
   const chromeos::VirtualNetworkVector& virtual_networks =
       cros_->virtual_networks();
   for (chromeos::VirtualNetworkVector::const_iterator it =
       virtual_networks.begin(); it != virtual_networks.end(); ++it) {
-    NetworkInfoDictionary network_dict(*it, GetIconScaleFactor());
+    NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
     network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
     list->Append(network_dict.BuildDictionary());
   }
 
   return list;
 }
 
 ListValue* InternetOptionsHandler::GetRememberedList() {
   ListValue* list = new ListValue();
 
   for (chromeos::WifiNetworkVector::const_iterator rit =
            cros_->remembered_wifi_networks().begin();
        rit != cros_->remembered_wifi_networks().end(); ++rit) {
     chromeos::WifiNetwork* remembered = *rit;
     chromeos::WifiNetwork* wifi = static_cast<chromeos::WifiNetwork*>(
         cros_->FindNetworkByUniqueId(remembered->unique_id()));
 
     NetworkInfoDictionary network_dict(wifi,
                                        remembered,
-                                       GetIconScaleFactor());
+                                       web_ui()->GetDeviceScale());
     list->Append(network_dict.BuildDictionary());
   }
 
   for (chromeos::VirtualNetworkVector::const_iterator rit =
            cros_->remembered_virtual_networks().begin();
        rit != cros_->remembered_virtual_networks().end(); ++rit) {
     chromeos::VirtualNetwork* remembered = *rit;
     chromeos::VirtualNetwork* vpn = static_cast<chromeos::VirtualNetwork*>(
         cros_->FindNetworkByUniqueId(remembered->unique_id()));
 
     NetworkInfoDictionary network_dict(vpn,
                                        remembered,
-                                       GetIconScaleFactor());
+                                       web_ui()->GetDeviceScale());
     list->Append(network_dict.BuildDictionary());
   }
 
   return list;
 }
 
 void InternetOptionsHandler::FillNetworkInfo(DictionaryValue* dictionary) {
   dictionary->SetBoolean("accessLocked", cros_->IsLocked());
   dictionary->Set("wiredList", GetWiredList());
   dictionary->Set("wirelessList", GetWirelessList());
@@ skipping 26 matching lines @@
   if (default_value)
     value_dict->Set("default", default_value->DeepCopy());
   if (ui_data.managed())
     value_dict->SetString("controlledBy", "policy");
   else if (ui_data.recommended())
     value_dict->SetString("controlledBy", "recommended");
   settings->Set(key, value_dict);
 }
 
 }  // namespace options2