Support Managed NetworkState format dictionaries for controlled settings.

chrome/browser/ui/webui/options/chromeos/internet_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/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 108 matching lines @@
 const char kSetPreferNetworkMessage[] = "setPreferNetwork";
 const char kSetServerHostname[] = "setServerHostname";
 const char kSetSimCardLockMessage[] = "setSimCardLock";
 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo";
 
 // These are strings used to communicate with JavaScript.
 const char kTagActivate[] = "activate";
 const char kTagActivationState[] = "activationState";
 const char kTagAddConnection[] = "add";
 const char kTagApn[] = "apn";
-const char kTagAutoConnect[] = "autoConnect";
 const char kTagCarrierSelectFlag[] = "showCarrierSelect";
 const char kTagCarrierUrl[] = "carrierUrl";
 const char kTagCellularAvailable[] = "cellularAvailable";
 const char kTagCellularEnabled[] = "cellularEnabled";
 const char kTagCellularSupportsScan[] = "cellularSupportsScan";
 const char kTagConfigure[] = "configure";
 const char kTagConnect[] = "connect";
 const char kTagControlledBy[] = "controlledBy";
 const char kTagDeviceConnected[] = "deviceConnected";
 const char kTagDisconnect[] = "disconnect";
-const char kTagErrorState[] = "errorState";
+const char kTagErrorMessage[] = "errorMessage";
 const char kTagForget[] = "forget";
-const char kTagIdentity[] = "identity";
 const char kTagLanguage[] = "language";
 const char kTagLastGoodApn[] = "lastGoodApn";
 const char kTagLocalizedName[] = "localizedName";
 const char kTagName[] = "name";
 const char kTagNameServersGoogle[] = "nameServersGoogle";
 const char kTagNameServerType[] = "nameServerType";
 const char kTagNetworkId[] = "networkId";
 const char kTagOptions[] = "options";
 const char kTagPassword[] = "password";
 const char kTagPolicy[] = "policy";
 const char kTagPreferred[] = "preferred";
 const char kTagProviderType[] = "providerType";
 const char kTagProviderApnList[] = "providerApnList";
 const char kTagRecommended[] = "recommended";
 const char kTagRecommendedValue[] = "recommendedValue";
 const char kTagRemembered[] = "remembered";
 const char kTagRememberedList[] = "rememberedList";
 const char kTagRestrictedPool[] = "restrictedPool";
 const char kTagRoamingState[] = "roamingState";
 const char kTagServerHostname[] = "serverHostname";
 const char kTagCarriers[] = "carriers";
 const char kTagCurrentCarrierIndex[] = "currentCarrierIndex";
 const char kTagShared[] = "shared";
 const char kTagShowActivateButton[] = "showActivateButton";
-const char kTagShowStaticIPConfig[] = "showStaticIPConfig";
 const char kTagShowViewAccountButton[] = "showViewAccountButton";
 const char kTagSimCardLockEnabled[] = "simCardLockEnabled";
 const char kTagSupportUrl[] = "supportUrl";
 const char kTagTrue[] = "true";
 const char kTagUsername[] = "username";
 const char kTagValue[] = "value";
 const char kTagVpnList[] = "vpnList";
 const char kTagWifiAvailable[] = "wifiAvailable";
 const char kTagWifiEnabled[] = "wifiEnabled";
 const char kTagWimaxAvailable[] = "wimaxAvailable";
@@ skipping 110 matching lines @@
   std::string name_servers;
   if (shill_properties.GetStringWithoutPathExpansion(
       name_servers_key, &name_servers)) {
     ip_info_dict->SetString(kIpConfigNameServers, name_servers);
     VLOG(2) << "Found " << name_servers_key << ": " << name_servers;
   }
 
   return ip_info_dict.release();
 }
 
-// Decorate dictionary |value_dict| with policy information from |ui_data|.
-void DecorateValueDictionary(const NetworkPropertyUIData& ui_data,
-                             const base::Value& value,
-                             base::DictionaryValue* value_dict) {
-  const base::Value* recommended_value = ui_data.default_value();
-  if (ui_data.IsManaged())
-    value_dict->SetString(kTagControlledBy, kTagPolicy);
-  else if (recommended_value && recommended_value->Equals(&value))
-    value_dict->SetString(kTagControlledBy, kTagRecommended);
-
-  if (recommended_value)
-    value_dict->Set(kTagRecommendedValue, recommended_value->DeepCopy());
-}
-
 // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does and
 // store it under |key| in |settings|. Takes ownership of |value|.
-void SetValueDictionary(base::DictionaryValue* settings,
-                        const char* key,
+void SetValueDictionary(const char* key,
                         base::Value* value,
-                        const NetworkPropertyUIData& ui_data) {
+                        const NetworkPropertyUIData& ui_data,
+                        base::DictionaryValue* settings) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   // DictionaryValue::Set() takes ownership of |value|.
   dict->Set(kTagValue, value);
   settings->Set(key, dict);
-  DecorateValueDictionary(ui_data, *value, dict);
+
+  const base::Value* recommended_value = ui_data.default_value();
+  if (ui_data.IsManaged())
+    dict->SetString(kTagControlledBy, kTagPolicy);
+  else if (recommended_value && recommended_value->Equals(value))
+    dict->SetString(kTagControlledBy, kTagRecommended);
+
+  if (recommended_value)
+    dict->Set(kTagRecommendedValue, recommended_value->DeepCopy());
 }
 
-// Creates a decorated dictionary like SetValueDictionary does, but extended for
-// the Autoconnect property, which respects additionally global network policy.
-void SetAutoconnectValueDictionary(bool network_is_private,
-                                   ::onc::ONCSource onc_source,
-                                   bool current_autoconnect,
-                                   const NetworkPropertyUIData& ui_data,
-                                   base::DictionaryValue* settings) {
+const char* GetOncSourceString(::onc::ONCSource onc_source) {
+  if (onc_source == ::onc::ONC_SOURCE_DEVICE_POLICY)
+    return ::onc::kAugmentationDevicePolicy;
+  return ::onc::kAugmentationUserPolicy;
+}
+
+// Creates a GetManagedProperties style dictionary. Takes ownership of |value|.
+// |recommended_source| tracks the source for recommened ONC properties.
+// Note(stevenjb): This is bridge code until we use GetManagedProperties to
+// retrieve Shill properties.
+void SetManagedValueDictionary(const char* key,
+                               base::Value* value,
+                               const NetworkPropertyUIData& ui_data,
+                               ::onc::ONCSource recommended_source,

[pneubeck (no reviews), 2014/08/01 16:09:08]

optional suggestion:

I find the name 'recommended_source' irritating.
In the current implementation of policy, there is always at most one source of
policy, either user or device policy.
This naming suggests that there could be another source.

This also implies that if ui_data.onc_source is != NONE,
then ui_data.onc_source() == recommended_source.

I would suggest just calling it onc_source and documenting it as 'source of the
policy of the network, if present'

[stevenjb, 2014/08/01 17:07:35]

I am trying to differentiate it from ui_data.onc_source. I really didn't want to
change too much in this CL, but maybe I need to just not use
NetworkPropertyUIData here?

[pneubeck (no reviews), 2014/08/01 17:18:48]

If you look into NetowrkProperytUIData, the only functionality that you need is
where it looks for the property in the next Recommended array. Maybe you can
instead extract that function and use it directly: IsRecommended(property,
onc_dict) or something like that.
?

+                               base::DictionaryValue* settings) {
   base::DictionaryValue* dict = new base::DictionaryValue();
-  base::Value* value = new base::FundamentalValue(current_autoconnect);
-  // DictionaryValue::Set() takes ownership of |value|.
-  dict->Set(kTagValue, value);
-  settings->Set(kTagAutoConnect, dict);
-  if (onc_source != ::onc::ONC_SOURCE_USER_POLICY &&
-      onc_source != ::onc::ONC_SOURCE_DEVICE_POLICY) {
-    // Autoconnect can be controlled by the GlobalNetworkConfiguration of the
-    // ONC policy.
-    bool only_policy_autoconnect =
-        onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(network_is_private);
-    if (only_policy_autoconnect) {
-      dict->SetString(kTagControlledBy, kTagPolicy);
-      return;
-    }
+  settings->Set(key, dict);
+  dict->Set(::onc::kAugmentationActiveSetting, value);  // owns |value|
+
+  if (ui_data.onc_source() == ::onc::ONC_SOURCE_NONE) {
+    if (!ui_data.default_value())
+      return;  // Unmanaged

[pneubeck (no reviews), 2014/08/01 16:09:08]

The comment is inaccurate. This case only means that there is no recommended
value, but the property is still user editable. Thus the early return is wrong
and should instead also set the Editable=true.

[stevenjb, 2014/08/01 17:07:35]

Bah. Right. OK, I'm going to try do do this without NetworkPropertyUIData then,
it's a disaster.

+    // Recommended. Use |recommended_source| of the onc source.
+    dict->Set(::onc::kAugmentationUserEditable,

[pneubeck (no reviews), 2014/08/01 16:09:08]

optional nit:
Using UserEditable will have the same effect (for now) as DeviceEditable.

The originally intended semantics however were, that UserEditable means that the
user policy allows the user to edit.

DeviceEditable means that the device policy allows users to edit.

Thus the field would depend on the onc_source or is_private of the whole
network.

[stevenjb, 2014/08/01 17:07:35]

Uh... yeah.... OK? Not sure I followed all that, see my previous comment about
documenting the behavior :)

+              new base::FundamentalValue(true));
+    std::string effective = GetOncSourceString(recommended_source);
+    dict->SetString(::onc::kAugmentationEffectiveSetting, effective);
+    dict->Set(effective, ui_data.default_value()->DeepCopy());
+    return;
   }
-  DecorateValueDictionary(ui_data, *value, dict);
+  std::string effective = GetOncSourceString(ui_data.onc_source());
+  dict->SetString(::onc::kAugmentationEffectiveSetting, effective);
+  // This is currently unused and redundant, but set for consistency with the
+  // results of GetManagedProperties.
+  dict->Set(effective, value->DeepCopy());
 }
 
 std::string CopyStringFromDictionary(const base::DictionaryValue& source,
                                      const std::string& src_key,
                                      const std::string& dest_key,
                                      base::DictionaryValue* dest) {
   std::string string_value;
   if (source.GetStringWithoutPathExpansion(src_key, &string_value))
     dest->SetStringWithoutPathExpansion(dest_key, string_value);
   return string_value;
@@ skipping 35 matching lines @@
       onc::FindPolicyForActiveUser(vpn->guid(), &onc_source);
 
   NetworkPropertyUIData hostname_ui_data;
   hostname_ui_data.ParseOncProperty(
       onc_source,
       onc,
       ::onc::network_config::VpnProperty(::onc::vpn::kHost));
   std::string provider_host;
   provider_properties->GetStringWithoutPathExpansion(
       shill::kHostProperty, &provider_host);
-  SetValueDictionary(dictionary, kTagServerHostname,
+  SetValueDictionary(kTagServerHostname,
                      new base::StringValue(provider_host),
-                     hostname_ui_data);
+                     hostname_ui_data,
+                     dictionary);
 }
 
 // Given a list of supported carrier's by the device, return the index of
 // the carrier the device is currently using.
 int FindCurrentCarrierIndex(const base::ListValue* carriers,
                             const DeviceState* device) {
   DCHECK(carriers);
   DCHECK(device);
   bool gsm = (device->technology_family() == shill::kTechnologyFamilyGsm);
   int index = 0;
   for (base::ListValue::const_iterator it = carriers->begin();
        it != carriers->end(); ++it, ++index) {
     std::string value;
     if (!(*it)->GetAsString(&value))
       continue;
     // For GSM devices the device name will be empty, so simply select
     // the Generic UMTS carrier option if present.
     if (gsm && (value == shill::kCarrierGenericUMTS))
       return index;
     // For other carriers, the service name will match the carrier name.
     if (value == device->carrier())
       return index;
   }
   return -1;
 }
 
-void PopulateWimaxDetails(const NetworkState* wimax,
-                          const base::DictionaryValue& shill_properties,
-                          base::DictionaryValue* dictionary) {
-  CopyStringFromDictionary(
-      shill_properties, shill::kEapIdentityProperty, kTagIdentity, dictionary);
-}
-
 void CreateDictionaryFromCellularApn(const base::DictionaryValue* apn,
                                      base::DictionaryValue* dictionary) {
   CopyStringFromDictionary(*apn, shill::kApnProperty, kTagApn, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnNetworkIdProperty, kTagNetworkId, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnUsernameProperty, kTagUsername, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnPasswordProperty, kTagPassword, dictionary);
   CopyStringFromDictionary(*apn, shill::kApnNameProperty, kTagName, dictionary);
@@ skipping 51 matching lines @@
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
     const base::DictionaryValue& device_properties = device->properties();
     ::onc::ONCSource onc_source;
     NetworkHandler::Get()->managed_network_configuration_handler()->
         FindPolicyByGUID(LoginState::Get()->primary_user_hash(),
                          cellular->guid(), &onc_source);
     const NetworkPropertyUIData cellular_property_ui_data(onc_source);
-    SetValueDictionary(dictionary,
-                       kTagSimCardLockEnabled,
+    SetValueDictionary(kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
-                       cellular_property_ui_data);
+                       cellular_property_ui_data,
+                       dictionary);
 
     carrier_id = device->home_provider_id();
     device_properties.GetStringWithoutPathExpansion(shill::kMdnProperty, &mdn);
 
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
       const MobileConfig::Carrier* carrier = config->GetCarrier(carrier_id);
       if (carrier && !carrier->top_up_url().empty())
         dictionary->SetString(kTagCarrierUrl, carrier->top_up_url());
     }
 
     base::ListValue* apn_list_value = new base::ListValue();
     const base::ListValue* apn_list;
     if (device_properties.GetListWithoutPathExpansion(
             shill::kCellularApnListProperty, &apn_list)) {
       for (base::ListValue::const_iterator iter = apn_list->begin();
            iter != apn_list->end();
            ++iter) {
         const base::DictionaryValue* dict;
         if ((*iter)->GetAsDictionary(&dict)) {
           base::DictionaryValue* apn = new base::DictionaryValue;
           CreateDictionaryFromCellularApn(dict, apn);
           apn_list_value->Append(apn);
         }
       }
     }
-    SetValueDictionary(dictionary,
-                       kTagProviderApnList,
+    SetValueDictionary(kTagProviderApnList,
                        apn_list_value,
-                       cellular_property_ui_data);
+                       cellular_property_ui_data,
+                       dictionary);
     const base::ListValue* supported_carriers;
     if (device_properties.GetListWithoutPathExpansion(
             shill::kSupportedCarriersProperty, &supported_carriers)) {
       dictionary->Set(kTagCarriers, supported_carriers->DeepCopy());
       dictionary->SetInteger(
           kTagCurrentCarrierIndex,
           FindCurrentCarrierIndex(supported_carriers, device));
     } else {
       // In case of any error, set the current carrier tag to -1 indicating
       // to the JS code to fallback to a single carrier.
@@ skipping 59 matching lines @@
   // TODO(stevenjb): Once we eliminate all references to Shill properties,
   // we can switch to using managed_network_configuration_handler which
   // includes Device properties for Cellular (and skip the call to
   // onc::TranslateShillServiceToONCPart). For now we copy them over here.
   scoped_ptr<base::DictionaryValue> shill_properties_with_device(
       shill_properties.DeepCopy());
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           network->device_path());
   if (device) {
-    shill_properties_with_device->Set(shill::kDeviceProperty,
-                                      device->properties().DeepCopy());
+    shill_properties_with_device->SetWithoutPathExpansion(
+        shill::kDeviceProperty, device->properties().DeepCopy());
+    // Get the hardware MAC address from the DeviceState.
+    // (Note: this is done in ManagedNetworkConfigurationHandler but not
+    //  in NetworkConfigurationHandler).
+    if (!device->mac_address().empty()) {
+      shill_properties_with_device->SetStringWithoutPathExpansion(
+          shill::kAddressProperty, device->mac_address());
+    }
   }
   scoped_ptr<base::DictionaryValue> dictionary =
       onc::TranslateShillServiceToONCPart(
           *shill_properties_with_device, &onc::kNetworkWithStateSignature);
 
   dictionary->SetString(kNetworkInfoKeyServicePath, network->path());
   dictionary->SetString(
-      kTagErrorState,
+      kTagErrorMessage,
       ash::network_connect::ErrorString(network->error(), network->path()));
 
   dictionary->SetBoolean(kTagRemembered, !network->profile_path().empty());
   bool shared = !network->IsPrivate();
   dictionary->SetBoolean(kTagShared, shared);
 
   const std::string& type = network->type();
 
   const NetworkState* connected_network =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
           NetworkTypePattern::Primitive(type));
   dictionary->SetBoolean(kTagDeviceConnected, connected_network != NULL);
 
-  if (type == shill::kTypeWimax)
-    PopulateWimaxDetails(network, shill_properties, dictionary.get());
-  else if (type == shill::kTypeCellular)
+  if (type == shill::kTypeCellular)
     PopulateCellularDetails(network, shill_properties, dictionary.get());
   else if (type == shill::kTypeVPN)
     PopulateVPNDetails(network, shill_properties, dictionary.get());
 
   return dictionary.Pass();
 }
 
 // Helper methods for SetIPConfigProperties
 bool AppendPropertyKeyIfPresent(const std::string& key,
                                 const base::DictionaryValue& old_properties,
@@ skipping 605 matching lines @@
 
   // IP config
   scoped_ptr<base::DictionaryValue> ipconfig_dhcp(new base::DictionaryValue);
   ipconfig_dhcp->SetString(kIpConfigAddress, network->ip_address());
   ipconfig_dhcp->SetString(kIpConfigNetmask, network->GetNetmask());
   ipconfig_dhcp->SetString(kIpConfigGateway, network->gateway());
   std::string ipconfig_name_servers = network->GetDnsServersAsString();
   ipconfig_dhcp->SetString(kIpConfigNameServers, ipconfig_name_servers);
   ipconfig_dhcp->SetString(kIpConfigWebProxyAutoDiscoveryUrl,
                            network->web_proxy_auto_discovery_url().spec());
-  SetValueDictionary(dictionary.get(),
-                     kDictionaryIpConfig,
+  SetValueDictionary(kDictionaryIpConfig,
                      ipconfig_dhcp.release(),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
   std::string name_server_type = kNameServerTypeAutomatic;
   int automatic_ip_config = 0;
   scoped_ptr<base::DictionaryValue> static_ip_dict(
       BuildIPInfoDictionary(shill_properties, true, &automatic_ip_config));
   dictionary->SetBoolean(kIpConfigAutoConfig, automatic_ip_config == 0);
   DCHECK(automatic_ip_config == 3 || automatic_ip_config == 0)
       << "UI doesn't support automatic specification of individual "
       << "static IP parameters.";
   scoped_ptr<base::DictionaryValue> saved_ip_dict(
       BuildIPInfoDictionary(shill_properties, false, NULL));
   dictionary->Set(kDictionarySavedIp, saved_ip_dict.release());
 
   // Determine what kind of name server setting we have by comparing the
   // StaticIP and Google values with the ipconfig values.
   std::string static_ip_nameservers;
   static_ip_dict->GetString(kIpConfigNameServers, &static_ip_nameservers);
   if (!static_ip_nameservers.empty() &&
       static_ip_nameservers == ipconfig_name_servers) {
     name_server_type = kNameServerTypeUser;
   }
   if (ipconfig_name_servers == kGoogleNameServers) {
     name_server_type = kNameServerTypeGoogle;
   }
-  SetValueDictionary(dictionary.get(),
-                     kDictionaryStaticIp,
+  SetValueDictionary(kDictionaryStaticIp,
                      static_ip_dict.release(),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
   dictionary->SetString(kTagNameServerType, name_server_type);
   dictionary->SetString(kTagNameServersGoogle, kGoogleNameServers);
 
-  // Enable static ip config for Ethernet or WiFi.
-  bool staticIPConfig = network->Matches(NetworkTypePattern::Ethernet()) ||
-                        network->Matches(NetworkTypePattern::WiFi());
-  dictionary->SetBoolean(kTagShowStaticIPConfig, staticIPConfig);
-
   int priority = 0;
   shill_properties.GetIntegerWithoutPathExpansion(
       shill::kPriorityProperty, &priority);
   bool preferred = priority > 0;
-  SetValueDictionary(dictionary.get(), kTagPreferred,
+  SetValueDictionary(kTagPreferred,
                      new base::FundamentalValue(preferred),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
   NetworkPropertyUIData auto_connect_ui_data(onc_source);
   std::string onc_path_to_auto_connect;
   if (network->Matches(NetworkTypePattern::WiFi())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsWifi"));
     if (network->IsConnectedState()) {
       content::RecordAction(
           base::UserMetricsAction("Options_NetworkShowDetailsWifiConnected"));
     }
@@ skipping 16 matching lines @@
           "Options_NetworkShowDetailsCellularConnected"));
     }
   }
   if (!onc_path_to_auto_connect.empty()) {
     auto_connect_ui_data.ParseOncProperty(
         onc_source, onc, onc_path_to_auto_connect);
   }
   bool auto_connect = false;
   shill_properties.GetBooleanWithoutPathExpansion(
       shill::kAutoConnectProperty, &auto_connect);
-  SetAutoconnectValueDictionary(network->IsPrivate(),
-                                onc_source,
-                                auto_connect,
-                                auto_connect_ui_data,
-                                dictionary.get());
+
+  // Autoconnect can be controlled by the GlobalNetworkConfiguration of the
+  // ONC policy.
+  scoped_ptr<base::Value> auto_connect_value(
+      new base::FundamentalValue(auto_connect));
+  if (auto_connect_ui_data.onc_source() != ::onc::ONC_SOURCE_NONE &&

[pneubeck (no reviews), 2014/08/01 16:09:08]

This still has to be changed.
Exact syntactic replacement in this line should be:

s/auto_connect_ui_data.onc_source() !=/onc_source ==/

(note the negation from != to ==)

[stevenjb, 2014/08/01 17:07:35]

I -really- don't understand this. Let's see how this looks when I remove
NetworkPropertyUIData here.

+      onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(network->IsPrivate())) {
+    ::onc::ONCSource source = network->IsPrivate()
+        ? ::onc::ONC_SOURCE_USER_POLICY : ::onc::ONC_SOURCE_DEVICE_POLICY;
+    // This modifies auto_connect_ui_data, so that the autoconnect value
+    // appears to be set to 'false' by policy and not editable by the user.
+    if (auto_connect) {
+      LOG(WARNING) << "Policy prevents autoconnect, but values is True.";
+      auto_connect_value.reset(new base::FundamentalValue(false));
+    }
+    auto_connect_ui_data.SetOncSourceAndValue(source, auto_connect_value.get());
+  }
+  SetManagedValueDictionary(shill::kAutoConnectProperty,
+                            auto_connect_value.release(),
+                            auto_connect_ui_data,
+                            onc_source,  // For recommended values.
+                            dictionary.get());
 
   // Show details dialog
   web_ui()->CallJavascriptFunction(kShowDetailedInfoFunction, *dictionary);
 }
 
 gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 float InternetOptionsHandler::GetScaleFactor() const {
@@ skipping 180 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos