Replace additional network properties with ONC values

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 127 matching lines @@
 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 kTagEsn[] = "esn";
-const char kTagFirmwareRevision[] = "firmwareRevision";
 const char kTagForget[] = "forget";
-const char kTagGsm[] = "gsm";
-const char kTagHardwareRevision[] = "hardwareRevision";
 const char kTagIdentity[] = "identity";
-const char kTagIccid[] = "iccid";
-const char kTagImei[] = "imei";
-const char kTagImsi[] = "imsi";
 const char kTagLanguage[] = "language";
 const char kTagLastGoodApn[] = "lastGoodApn";
 const char kTagLocalizedName[] = "localizedName";
-const char kTagCellularManufacturer[] = "cellularManufacturer";
-const char kTagMdn[] = "mdn";
-const char kTagMeid[] = "meid";
-const char kTagMin[] = "min";
-const char kTagModelId[] = "modelId";
 const char kTagName[] = "name";
 const char kTagNameServersGoogle[] = "nameServersGoogle";
 const char kTagNameServerType[] = "nameServerType";
 const char kTagNetworkId[] = "networkId";
-const char kTagNetworkTechnology[] = "networkTechnology";
-const char kTagOperatorCode[] = "operatorCode";
-const char kTagOperatorName[] = "operatorName";
 const char kTagOptions[] = "options";
 const char kTagPassword[] = "password";
 const char kTagPolicy[] = "policy";
 const char kTagPreferred[] = "preferred";
-const char kTagPrlVersion[] = "prlVersion";
 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";
@@ skipping 155 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();
 }
 
-bool CanForgetNetworkType(const std::string& type) {
-  return type == shill::kTypeWifi ||
-         type == shill::kTypeWimax ||
-         type == shill::kTypeVPN;
-}
-
-bool CanAddNetworkType(const std::string& type) {
-  return type == shill::kTypeWifi ||
-         type == shill::kTypeVPN ||
-         type == shill::kTypeCellular;
-}
-
 // 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);
 
@@ skipping 43 matching lines @@
 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;
 }
 
-void CopyIntegerFromDictionary(const base::DictionaryValue& source,
-                               const std::string& src_key,
-                               const std::string& dest_key,
-                               bool as_string,
-                               base::DictionaryValue* dest) {
-  int int_value;
-  if (!source.GetIntegerWithoutPathExpansion(src_key, &int_value))
-    return;
-  if (as_string) {
-    dest->SetStringWithoutPathExpansion(dest_key, base::IntToString(int_value));
-  } else {
-    dest->SetIntegerWithoutPathExpansion(dest_key, int_value);
-  }
-}
-
 // Fills |dictionary| with the configuration details of |vpn|. |onc| is required
 // for augmenting the policy-managed information.
 void PopulateVPNDetails(const NetworkState* vpn,
                         const base::DictionaryValue& shill_properties,
                         base::DictionaryValue* dictionary) {
   // Name and Remembered are set in PopulateConnectionDetails().
   // Provider properties are stored in the "Provider" dictionary.
   const base::DictionaryValue* provider_properties = NULL;
   if (!shill_properties.GetDictionaryWithoutPathExpansion(
           shill::kProviderProperty, &provider_properties)) {
@@ skipping 82 matching lines @@
       *apn, shill::kApnLanguageProperty, kTagLanguage, dictionary);
 }
 
 void PopulateCellularDetails(const NetworkState* cellular,
                              const base::DictionaryValue& shill_properties,
                              base::DictionaryValue* dictionary) {
   dictionary->SetBoolean(kTagCarrierSelectFlag,
                          CommandLine::ForCurrentProcess()->HasSwitch(
                              chromeos::switches::kEnableCarrierSwitching));
   // Cellular network / connection settings.
-  dictionary->SetString(kTagNetworkTechnology, cellular->network_technology());
   dictionary->SetString(kTagActivationState,
                         internet_options_strings::ActivationStateString(
                             cellular->activation_state()));
   dictionary->SetString(kTagRoamingState,
                         internet_options_strings::RoamingStateString(
                             cellular->roaming()));
-  dictionary->SetString(
-      kTagRestrictedPool,
-      internet_options_strings::RestrictedStateString(
-          cellular->connection_state()));
-
-  const base::DictionaryValue* serving_operator = NULL;
-  if (shill_properties.GetDictionaryWithoutPathExpansion(
-          shill::kServingOperatorProperty, &serving_operator)) {
-    CopyStringFromDictionary(*serving_operator,
-                             shill::kOperatorNameKey,
-                             kTagOperatorName,
-                             dictionary);
-    CopyStringFromDictionary(*serving_operator,
-                             shill::kOperatorCodeKey,
-                             kTagOperatorCode,
-                             dictionary);
-  }
+  dictionary->SetString(kTagRestrictedPool,
+                        internet_options_strings::RestrictedStateString(
+                            cellular->connection_state()));
 
   const base::DictionaryValue* olp = NULL;
   if (shill_properties.GetDictionaryWithoutPathExpansion(
           shill::kPaymentPortalProperty, &olp)) {
     std::string url;
     olp->GetStringWithoutPathExpansion(shill::kPaymentPortalURL, &url);
     dictionary->SetString(kTagSupportUrl, url);
   }
 
   base::DictionaryValue* apn = new base::DictionaryValue;
@@ skipping 13 matching lines @@
 
   // These default to empty and are only set if device != NULL.
   std::string carrier_id;
   std::string mdn;
 
   // Device settings.
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
-    // TODO(stevenjb): Add NetworkDeviceHandler::GetProperties() and use that
-    // to retrieve the complete dictionary of device properties, instead of
-    // caching them (will be done for the new UI).
     const base::DictionaryValue& device_properties = device->properties();
     const NetworkPropertyUIData cellular_property_ui_data(
         cellular->ui_data().onc_source());
-    CopyStringFromDictionary(device_properties,
-                             shill::kManufacturerProperty,
-                             kTagCellularManufacturer,
-                             dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kModelIDProperty, kTagModelId, dictionary);
-    CopyStringFromDictionary(device_properties,
-                             shill::kFirmwareRevisionProperty,
-                             kTagFirmwareRevision,
-                             dictionary);
-    CopyStringFromDictionary(device_properties,
-                             shill::kHardwareRevisionProperty,
-                             kTagHardwareRevision,
-                             dictionary);
-    CopyIntegerFromDictionary(device_properties,
-                              shill::kPRLVersionProperty,
-                              kTagPrlVersion,
-                              true,
-                              dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kMeidProperty, kTagMeid, dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kIccidProperty, kTagIccid, dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kImeiProperty, kTagImei, dictionary);
-    mdn = CopyStringFromDictionary(
-        device_properties, shill::kMdnProperty, kTagMdn, dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kImsiProperty, kTagImsi, dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kEsnProperty, kTagEsn, dictionary);
-    CopyStringFromDictionary(
-        device_properties, shill::kMinProperty, kTagMin, dictionary);
-    std::string family;
-    device_properties.GetStringWithoutPathExpansion(
-        shill::kTechnologyFamilyProperty, &family);
-    dictionary->SetBoolean(kTagGsm, family == shill::kNetworkTechnologyGsm);
-
     SetValueDictionary(dictionary,
                        kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
                        cellular_property_ui_data);
 
     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;
@@ skipping 79 matching lines @@
       // carrier specific portal.
       if (cellular->IsConnectedState() || force_show_view_account_button)
         dictionary->SetBoolean(kTagShowViewAccountButton, true);
     }
   }
 }
 
 scoped_ptr<base::DictionaryValue> PopulateConnectionDetails(
     const NetworkState* network,
     const base::DictionaryValue& shill_properties) {
+  // 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());
+  }
   scoped_ptr<base::DictionaryValue> dictionary =
       onc::TranslateShillServiceToONCPart(
-          shill_properties, &onc::kNetworkWithStateSignature);
+          *shill_properties_with_device, &onc::kNetworkWithStateSignature);
 
   dictionary->SetString(kNetworkInfoKeyServicePath, network->path());
   dictionary->SetString(
       kTagErrorState,
       ash::network_connect::ErrorString(network->error(), network->path()));
 
   dictionary->SetBoolean(kTagRemembered, !network->profile_path().empty());
   bool shared = !network->IsPrivate();
   dictionary->SetBoolean(kTagShared, shared);
 
@@ skipping 382 matching lines @@
   gfx::ImageSkia* icon =
       ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
   gfx::ImageSkiaRep image_rep = icon->GetRepresentation(
       web_ui()->GetDeviceScaleFactor());
   return webui::GetBitmapDataUrl(image_rep.sk_bitmap());
 }
 
 void InternetOptionsHandler::RefreshNetworkData() {
   base::DictionaryValue dictionary;
   FillNetworkInfo(&dictionary);
-  web_ui()->CallJavascriptFunction(
-      kRefreshNetworkDataFunction, dictionary);
+  web_ui()->CallJavascriptFunction(kRefreshNetworkDataFunction, dictionary);
 }
 
 void InternetOptionsHandler::UpdateConnectionData(
     const std::string& service_path) {
   NetworkHandler::Get()->network_configuration_handler()->GetProperties(
       service_path,
       base::Bind(&InternetOptionsHandler::UpdateConnectionDataCallback,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ShillError, "UpdateConnectionData"));
 }
@@ skipping 366 matching lines @@
     return;
   }
   std::string type;  // Shill type
   if (!onc_type.empty()) {
     type = network_util::TranslateONCTypeToShill(onc_type);
     if (type.empty())
       LOG(ERROR) << "Unable to translate ONC type: " << onc_type;
   }
   // Process commands that do not require an existing network.
   if (command == kTagAddConnection) {
-    if (CanAddNetworkType(type))
-      AddConnection(type);
+    AddConnection(type);
   } else if (command == kTagForget) {
-    if (CanForgetNetworkType(type)) {
-      NetworkHandler::Get()->network_configuration_handler()->
-          RemoveConfiguration(
-              service_path,
-              base::Bind(&base::DoNothing),
-              base::Bind(&ShillError, "NetworkCommand: " + command));
-    }
+    NetworkHandler::Get()->network_configuration_handler()->
+        RemoveConfiguration(
+            service_path,
+            base::Bind(&base::DoNothing),
+            base::Bind(&ShillError, "NetworkCommand: " + command));
   } else if (command == kTagOptions) {
     NetworkHandler::Get()->network_configuration_handler()->GetProperties(
         service_path,
         base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback,
                    weak_factory_.GetWeakPtr()),
         base::Bind(&ShillError, "NetworkCommand: " + command));
   } else if (command == kTagConnect) {
     const NetworkState* network = GetNetworkState(service_path);
     if (network && network->type() == shill::kTypeWifi)
       content::RecordAction(
@@ skipping 32 matching lines @@
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkJoinOtherWifi"));
     NetworkConfigView::ShowForType(shill::kTypeWifi, GetNativeWindow());
   } else if (type == shill::kTypeVPN) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkJoinOtherVPN"));
     NetworkConfigView::ShowForType(shill::kTypeVPN, GetNativeWindow());
   } else if (type == shill::kTypeCellular) {
     ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
   } else {
-    NOTREACHED();
+    LOG(ERROR) << "Unsupported type for AddConnection";
   }
 }
 
 base::ListValue* InternetOptionsHandler::GetWiredList() {
   base::ListValue* list = new base::ListValue();
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       FirstNetworkByType(NetworkTypePattern::Ethernet());
   if (!network)
     return list;
   list->Append(BuildNetworkDictionary(network, GetScaleFactor(), GetPrefs()));
@@ skipping 83 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos