Use ONC for Cellular APN and SimLock in 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 10 matching lines @@
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/webui/chromeos/mobile_setup_dialog.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #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"
@@ skipping 83 matching lines @@
 const char kSetIPConfigMessage[] = "setIPConfig";
 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 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 kTagErrorMessage[] = "errorMessage";
 const char kTagForget[] = "forget";
-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 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 kTagCarriers[] = "carriers";
 const char kTagCurrentCarrierIndex[] = "currentCarrierIndex";
 const char kTagShared[] = "shared";
 const char kTagShowActivateButton[] = "showActivateButton";
 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";
 const char kTagWimaxEnabled[] = "wimaxEnabled";
 const char kTagWiredList[] = "wiredList";
 const char kTagWirelessList[] = "wirelessList";
 
 const int kPreferredPriority = 1;
@@ skipping 224 matching lines @@
 void SetTranslatedDictionary(const char* settings_dict_key,
                              const std::string& value,
                              const std::string& translated_value,
                              base::DictionaryValue* settings_dict) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   settings_dict->Set(settings_dict_key, dict);
   dict->SetString(::onc::kAugmentationActiveSetting, value);
   dict->SetString(kTranslatedKey, translated_value);
 }
 
-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;
-}
-
 // 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* shill_provider_properties = NULL;
   if (!shill_properties.GetDictionaryWithoutPathExpansion(
           shill::kProviderProperty, &shill_provider_properties)) {
@@ skipping 62 matching lines @@
     // 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 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);
-  CopyStringFromDictionary(
-      *apn, shill::kApnLocalizedNameProperty, kTagLocalizedName, dictionary);
-  CopyStringFromDictionary(
-      *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(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* 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;
-  const base::DictionaryValue* source_apn = NULL;
-  if (shill_properties.GetDictionaryWithoutPathExpansion(
-          shill::kCellularApnProperty, &source_apn)) {
-    CreateDictionaryFromCellularApn(source_apn, apn);
-  }
-  dictionary->Set(kTagApn, apn);
-
-  base::DictionaryValue* last_good_apn = new base::DictionaryValue;
-  if (shill_properties.GetDictionaryWithoutPathExpansion(
-          shill::kCellularLastGoodApnProperty, &source_apn)) {
-    CreateDictionaryFromCellularApn(source_apn, last_good_apn);
-  }
-  dictionary->Set(kTagLastGoodApn, last_good_apn);
-
   // 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) {
     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(kTagSimCardLockEnabled,
-                       new base::FundamentalValue(device->sim_lock_enabled()),
-                       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(kTagProviderApnList,
-                       apn_list_value,
-                       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.
       dictionary->SetInteger(kTagCurrentCarrierIndex, -1);
     }
   }
 
   // Don't show any account management related buttons if the activation
-  // state is unknown or no payment portal URL is available.
-  std::string support_url;
-  if (cellular->activation_state() == shill::kActivationStateUnknown ||
-      !dictionary->GetString(kTagSupportUrl, &support_url) ||
-      support_url.empty()) {
-    VLOG(2) << "No support URL is available. Don't display buttons.";
+  // state is unknown.
+  if (cellular->activation_state() == shill::kActivationStateUnknown) {
+    VLOG(2) << "Activation state unknown. Don't display buttons.";
     return;
   }
 
   if (cellular->activation_state() != shill::kActivationStateActivating &&
       cellular->activation_state() != shill::kActivationStateActivated) {
     dictionary->SetBoolean(kTagShowActivateButton, true);
   } else {
-    bool may_show_portal_button = false;
+    // TODO(stevenjb): Determine if we actually need this check. The payment url
+    // property is commented as 'Deprecated' in service_constants.h and appears
+    // to be unset in Shill, but we still reference it in mobile_setup.cc.
+    bool may_show_portal_button = !cellular->payment_url().empty();
 
-    // If an online payment URL was provided by shill, then this means that the
-    // "View Account" button should be shown for the current carrier.
-    if (olp) {
-      std::string url;
-      olp->GetStringWithoutPathExpansion(shill::kPaymentPortalURL, &url);
-      may_show_portal_button = !url.empty();
-    }
     // If no online payment URL was provided by shill, fall back to
     // MobileConfig to determine if the "View Account" should be shown.
     if (!may_show_portal_button && MobileConfig::GetInstance()->IsReady()) {
       const MobileConfig::Carrier* carrier =
           MobileConfig::GetInstance()->GetCarrier(carrier_id);
       may_show_portal_button = carrier && carrier->show_portal_button();
     }
     if (may_show_portal_button) {
       // The button should be shown for a LTE network even when the LTE network
       // is not connected, but CrOS is online. This is done to enable users to
@@ skipping 53 matching lines @@
   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::kTypeCellular)
-    PopulateCellularDetails(network, shill_properties, dictionary.get());
+    PopulateCellularDetails(network, 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,
                                 std::vector<std::string>* property_keys) {
@@ skipping 917 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos