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 26 matching lines @@
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
+#include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_resources.h"
 #include "grit/ui_chromeos_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/chromeos/network/network_icon.h"
@@ skipping 62 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 and adds it to |settings|.
+// Note(stevenjb): This is bridge code until we use GetManagedProperties to
+// retrieve Shill properties.
+void SetManagedValueDictionary(const char* key,
+                               const base::Value* value,
+                               ::onc::ONCSource onc_source,
+                               bool recommended,
+                               const base::Value* default_value,

[pneubeck2, 2014/08/06 07:13:07]

nit: drop a comment that this 'default_value' can either be a recommended or
mandatory value from policy.

[stevenjb, 2014/08/06 16:29:44]

Done.

+                               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->DeepCopy());
+
+  if (onc_source == ::onc::ONC_SOURCE_NONE)
+    return;
+
+  if (recommended) {
+    // If an ONC property is 'Recommended' it can be edited by the user.
+    std::string editable = onc_source == ::onc::ONC_SOURCE_DEVICE_POLICY
+                               ? ::onc::kAugmentationDeviceEditable
+                               : ::onc::kAugmentationUserEditable;
+    dict->Set(editable, new base::FundamentalValue(true));
   }
-  DecorateValueDictionary(ui_data, *value, dict);
+  if (default_value) {
+    std::string effective = GetOncSourceString(onc_source);
+    dict->SetString(::onc::kAugmentationEffectiveSetting, effective);

[pneubeck2, 2014/08/06 07:13:08]

Please consider the following case:

Policy recommends autoconnect to 'true'.
User overwrites it to 'false'.

|recommend| will be 'true'.
|default_value| will be 'true'
|value| will be 'false'.

The dictionary entry "Effective" should be "UserSetting" in this case and not
"UserPolicy" (or DevicePolicy).

[stevenjb, 2014/08/06 16:29:43]

Could you add this as an example to the ONC doc when you have a chance? Thanks!

[stevenjb, 2014/08/06 16:29:43]

Done.

+    dict->Set(effective, default_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"));
     }
     onc_path_to_auto_connect =
         ::onc::network_config::WifiProperty(::onc::wifi::kAutoConnect);
   } else if (network->Matches(NetworkTypePattern::VPN())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsVPN"));
     if (network->IsConnectedState()) {
       content::RecordAction(
           base::UserMetricsAction("Options_NetworkShowDetailsVPNConnected"));
     }
     onc_path_to_auto_connect = ::onc::network_config::VpnProperty(
         ::onc::vpn::kAutoConnect);
   } else if (network->Matches(NetworkTypePattern::Cellular())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsCellular"));
     if (network->IsConnectedState()) {
       content::RecordAction(base::UserMetricsAction(
           "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);
+
+    scoped_ptr<base::Value> auto_connect_value(
+        new base::FundamentalValue(auto_connect));
+    ::onc::ONCSource auto_connect_onc_source = onc_source;
+    bool auto_connect_recommended =
+        auto_connect_onc_source != ::onc::ONC_SOURCE_NONE &&
+        onc::IsRecommendedValue(onc, onc_path_to_auto_connect);
+    const base::Value* auto_connect_default_value = NULL;

[pneubeck2, 2014/08/06 07:13:08]

nit: drop a comment that this 'default_value' can either be a recommended or
mandatory value from policy.

[stevenjb, 2014/08/06 16:29:43]

Done.

+    onc->Get(onc_path_to_auto_connect, &auto_connect_default_value);
+
+    // Autoconnect can be controlled by the GlobalNetworkConfiguration of the
+    // ONC policy.
+    if (auto_connect_onc_source != ::onc::ONC_SOURCE_NONE &&

[pneubeck2, 2014/08/06 07:13:08]

This policy applies to all unmanaged networks (networks that are not configured
by policy). Therefore the '!=' must be changed to '=='.

The meaning of the policy is as user (device) policy:
Disable the Autoconnect of all private (shared) user created network
configurations.

The purpose of this is, that networks from policy are the only autoconnecting
networks which is what some admins want for e.g. public sessions.

[stevenjb, 2014/08/06 16:29:43]

Done.

[stevenjb, 2014/08/06 16:29:44]

This took me a while to parse. By "this policy" I think you mean
"onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect", correct?

We really need to move this logic to MNCH so we can eliminate this from here
when we switch to calling GetManagedNetworks.

+        onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(
+            network->IsPrivate())) {
+      auto_connect_recommended = false;
+      auto_connect_onc_source = network->IsPrivate()
+                                    ? ::onc::ONC_SOURCE_USER_POLICY
+                                    : ::onc::ONC_SOURCE_DEVICE_POLICY;
+      if (auto_connect) {
+        LOG(WARNING) << "Policy prevents autoconnect, but value is True.";
+        auto_connect_value.reset(new base::FundamentalValue(false));
+      }
+    }
+    SetManagedValueDictionary(shill::kAutoConnectProperty,
+                              auto_connect_value.get(),
+                              auto_connect_onc_source,
+                              auto_connect_recommended,
+                              auto_connect_default_value,
+                              dictionary.get());
   }
-  bool auto_connect = false;
-  shill_properties.GetBooleanWithoutPathExpansion(
-      shill::kAutoConnectProperty, &auto_connect);
-  SetAutoconnectValueDictionary(network->IsPrivate(),
-                                onc_source,
-                                auto_connect,
-                                auto_connect_ui_data,
-                                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