Add the ability to activate for carriers that need to be directly activated.

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 94 matching lines @@
 // Google public name servers (DNS).
 const char kGoogleNameServers[] = "8.8.4.4,8.8.8.8";
 
 // Functions we call in JavaScript.
 const char kRefreshNetworkDataFunction[] =
     "options.network.NetworkList.refreshNetworkData";
 const char kSetDefaultNetworkIconsFunction[] =
     "options.network.NetworkList.setDefaultNetworkIcons";
 const char kShowDetailedInfoFunction[] =
     "options.internet.DetailsInternetPage.showDetailedInfo";
+const char kUpdateConnectionDataFunction[] =
+    "options.internet.DetailsInternetPage.updateConnectionData";
 const char kUpdateCarrierFunction[] =
     "options.internet.DetailsInternetPage.updateCarrier";
 const char kUpdateSecurityTabFunction[] =
     "options.internet.DetailsInternetPage.updateSecurityTab";
 
 // These are used to register message handlers with JavaScript.
 const char kBuyDataPlanMessage[] = "buyDataPlan";
 const char kChangePinMessage[] = "changePin";
 const char kDisableCellularMessage[] = "disableCellular";
 const char kDisableWifiMessage[] = "disableWifi";
@@ skipping 29 matching lines @@
 const char kTagCellularBusy[] = "cellularBusy";
 const char kTagCellularEnabled[] = "cellularEnabled";
 const char kTagCellularSupportsScan[] = "cellularSupportsScan";
 const char kTagConnect[] = "connect";
 const char kTagConnected[] = "connected";
 const char kTagConnecting[] = "connecting";
 const char kTagConnectionState[] = "connectionState";
 const char kTagControlledBy[] = "controlledBy";
 const char kTagDataRemaining[] = "dataRemaining";
 const char kTagDeviceConnected[] = "deviceConnected";
+const char kTagDisableConnectButton[] = "disableConnectButton";
 const char kTagDisconnect[] = "disconnect";
 const char kTagEncryption[] = "encryption";
 const char kTagErrorState[] = "errorState";
 const char kTagEsn[] = "esn";
 const char kTagFirmwareRevision[] = "firmwareRevision";
 const char kTagForget[] = "forget";
 const char kTagFrequency[] = "frequency";
 const char kTagGsm[] = "gsm";
 const char kTagHardwareAddress[] = "hardwareAddress";
 const char kTagHardwareRevision[] = "hardwareRevision";
@@ skipping 344 matching lines @@
   hostname_ui_data.ParseOncProperty(
       vpn->ui_data(), &onc,
       base::StringPrintf("%s.%s",
                          chromeos::onc::kVPN,
                          chromeos::onc::vpn::kHost));
   SetValueDictionary(dictionary, kTagServerHostname,
                      new base::StringValue(vpn->server_hostname()),
                      hostname_ui_data);
 }
 
+// Activate the cellular device pointed to by the service path.
+void Activate(std::string service_path) {
+  chromeos::Network* network = NULL;
+  if (!service_path.empty()) {
+    network = chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
+        FindNetworkByPath(service_path);
+  } else {
+    NOTREACHED();
+    return;
+  }
+  if (network->type() != chromeos::TYPE_CELLULAR)
+    return;
+  static_cast<chromeos::CellularNetwork*>(network)->StartActivation();
+}
+
+// Check if the current cellular device can be activated by directly calling
+// it's activate function instead of going through the activation process.
+// Note: Currently Sprint is the only carrier that uses this.
+bool UseDirectActivation() {
+  const chromeos::NetworkDevice* device =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary()->FindCellularDevice();
+  return device && (device->carrier() == shill::kCarrierSprint);
+}
+
 // 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 chromeos::NetworkDevice* device) {
   DCHECK(carriers);
   DCHECK(device);
 
   bool gsm = (device->technology_family() == chromeos::TECHNOLOGY_FAMILY_GSM);
   int index = 0;
   for (base::ListValue::const_iterator it = carriers->begin();
@@ skipping 446 matching lines @@
   return web_ui_util::GetBitmapDataUrl(image_rep.sk_bitmap());
 }
 
 void InternetOptionsHandler::RefreshNetworkData() {
   DictionaryValue dictionary;
   FillNetworkInfo(&dictionary);
   web_ui()->CallJavascriptFunction(
       kRefreshNetworkDataFunction, dictionary);
 }
 
+void InternetOptionsHandler::UpdateConnectionData(
+    const chromeos::Network* network) {
+  DictionaryValue dictionary;
+  PopulateConnectionDetails(network, &dictionary);
+  web_ui()->CallJavascriptFunction(
+      kUpdateConnectionDataFunction, dictionary);
+}
+
 void InternetOptionsHandler::UpdateCarrier(bool success) {
   base::FundamentalValue success_value(success);
   web_ui()->CallJavascriptFunction(kUpdateCarrierFunction, success_value);
 }
 
 void InternetOptionsHandler::OnNetworkManagerChanged(
     chromeos::NetworkLibrary* cros) {
   if (!web_ui())
     return;
   MonitorNetworks();
   RefreshNetworkData();
 }
 
 void InternetOptionsHandler::OnNetworkChanged(
     chromeos::NetworkLibrary* cros,
     const chromeos::Network* network) {
-  if (web_ui())
+  if (web_ui()) {
     RefreshNetworkData();
+    UpdateConnectionData(network);
+  }
 }
 
 // Monitor wireless networks for changes. It is only necessary
 // to set up individual observers for the cellular networks
 // (if any) and for the connected Wi-Fi network (if any). The
 // only change we are interested in for Wi-Fi networks is signal
 // strength. For non-connected Wi-Fi networks, all information is
 // reported via scan results, which trigger network manager
 // updates. Only the connected Wi-Fi network has changes reported
 // via service property updates.
@@ skipping 253 matching lines @@
     // then just go with some defaults.
     dictionary.SetBoolean(kIpConfigAutoConfig, false);
     dictionary.Set(kDictionarySavedIp, new DictionaryValue);
     SetValueDictionary(&dictionary, kDictionaryStaticIp, new DictionaryValue,
                        property_ui_data);
   }
 
   chromeos::ConnectionType type = network->type();
   dictionary.SetInteger(kTagType, type);
   dictionary.SetString(kTagServicePath, network->service_path());
-  dictionary.SetBoolean(kTagConnecting, network->connecting());
-  dictionary.SetBoolean(kTagConnected, network->connected());
-  dictionary.SetString(kTagConnectionState, network->GetStateString());
-  dictionary.SetString(kTagNetworkName, network->name());
   dictionary.SetString(kTagNameServerType, name_server_type);
   dictionary.SetString(kTagNameServersGoogle, kGoogleNameServers);
 
   // Only show proxy for remembered networks.
   chromeos::NetworkProfileType network_profile = network->profile_type();
   dictionary.SetBoolean(kTagShowProxy,
                         network_profile != chromeos::PROFILE_NONE);
 
   // Enable static ip config for ethernet. For wifi, enable if flag is set.
   bool staticIPConfig = type == chromeos::TYPE_ETHERNET ||
@@ skipping 13 matching lines @@
     auto_connect_ui_data.ParseOncProperty(
         ui_data, onc,
         base::StringPrintf("%s.%s",
                            chromeos::onc::kWiFi,
                            chromeos::onc::wifi::kAutoConnect));
   }
   SetValueDictionary(&dictionary, kTagAutoConnect,
                      new base::FundamentalValue(network->auto_connect()),
                      auto_connect_ui_data);
 
-  if (type == chromeos::TYPE_WIFI) {
-    dictionary.SetBoolean(kTagDeviceConnected, cros_->wifi_connected());
-    PopulateWifiDetails(static_cast<const chromeos::WifiNetwork*>(network),
-                        &dictionary);
-  } else if (type == chromeos::TYPE_WIMAX) {
-    dictionary.SetBoolean(kTagDeviceConnected, cros_->wimax_connected());
-    PopulateWimaxDetails(static_cast<const chromeos::WimaxNetwork*>(network),
-                         &dictionary);
-  } else if (type == chromeos::TYPE_CELLULAR) {
-    dictionary.SetBoolean(kTagDeviceConnected, cros_->cellular_connected());
-    PopulateCellularDetails(
-        static_cast<const chromeos::CellularNetwork*>(network),
-        &dictionary);
-  } else if (type == chromeos::TYPE_VPN) {
-    dictionary.SetBoolean(kTagDeviceConnected,
-                          cros_->virtual_network_connected());
-    PopulateVPNDetails(static_cast<const chromeos::VirtualNetwork*>(network),
-                       *onc,
-                       &dictionary);
-  } else if (type == chromeos::TYPE_ETHERNET) {
-    dictionary.SetBoolean(kTagDeviceConnected, cros_->ethernet_connected());
-  }
-
+  PopulateConnectionDetails(network, &dictionary);
   web_ui()->CallJavascriptFunction(
       kShowDetailedInfoFunction, dictionary);
 }
 
+void InternetOptionsHandler::PopulateConnectionDetails(
+    const chromeos::Network* network, DictionaryValue* dictionary) {
+  chromeos::ConnectionType type = network->type();
+  dictionary->SetBoolean(kTagConnecting, network->connecting());
+  dictionary->SetBoolean(kTagConnected, network->connected());
+  dictionary->SetString(kTagConnectionState, network->GetStateString());
+  dictionary->SetString(kTagNetworkName, network->name());
+
+  if (type == chromeos::TYPE_WIFI) {
+    dictionary->SetBoolean(kTagDeviceConnected, cros_->wifi_connected());
+    PopulateWifiDetails(static_cast<const chromeos::WifiNetwork*>(network),
+                        dictionary);
+  } else if (type == chromeos::TYPE_WIMAX) {
+    dictionary->SetBoolean(kTagDeviceConnected, cros_->wimax_connected());
+    PopulateWimaxDetails(static_cast<const chromeos::WimaxNetwork*>(network),
+                         dictionary);
+  } else if (type == chromeos::TYPE_CELLULAR) {
+    dictionary->SetBoolean(kTagDeviceConnected, cros_->cellular_connected());
+    PopulateCellularDetails(
+        static_cast<const chromeos::CellularNetwork*>(network),
+        dictionary);
+  } else if (type == chromeos::TYPE_VPN) {
+    dictionary->SetBoolean(kTagDeviceConnected,
+                           cros_->virtual_network_connected());
+    const base::DictionaryValue* onc =
+        cros_->FindOncForNetwork(network->unique_id());
+    PopulateVPNDetails(static_cast<const chromeos::VirtualNetwork*>(network),
+                       *onc,
+                       dictionary);
+  } else if (type == chromeos::TYPE_ETHERNET) {
+    dictionary->SetBoolean(kTagDeviceConnected, cros_->ethernet_connected());
+  }
+}
+
 void InternetOptionsHandler::PopulateWifiDetails(
     const chromeos::WifiNetwork* wifi,
     DictionaryValue* dictionary) {
   dictionary->SetString(kTagSsid, wifi->name());
   bool remembered = (wifi->profile_type() != chromeos::PROFILE_NONE);
   dictionary->SetBoolean(kTagRemembered, remembered);
   bool shared = wifi->profile_type() == chromeos::PROFILE_SHARED;
   dictionary->SetBoolean(kTagShared, shared);
   dictionary->SetString(kTagEncryption, wifi->GetEncryptionString());
   dictionary->SetString(kTagBssid, wifi->bssid());
@@ skipping 109 matching lines @@
                                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);
       }
     }
   }
 
-  SetActivationButtonVisibility(cellular,
+  SetCellularButtonsVisibility(cellular,
                                 dictionary,
                                 cros_->GetCellularHomeCarrierId());
 }
 
-void InternetOptionsHandler::SetActivationButtonVisibility(
+void InternetOptionsHandler::SetCellularButtonsVisibility(
     const chromeos::CellularNetwork* cellular,
     DictionaryValue* dictionary,
     const std::string& carrier_id) {
+  dictionary->SetBoolean(
+      kTagDisableConnectButton,
+      cellular->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATING ||
+          cellular->connecting());
+
   if (cellular->activation_state() != chromeos::ACTIVATION_STATE_ACTIVATING &&
       cellular->activation_state() != chromeos::ACTIVATION_STATE_ACTIVATED) {
     dictionary->SetBoolean(kTagShowActivateButton, true);
   } else {
     const chromeos::MobileConfig::Carrier* carrier =
         chromeos::MobileConfig::GetInstance()->GetCarrier(carrier_id);
     if (carrier && carrier->show_portal_button()) {
       // This will trigger BuyDataPlanCallback() so that
       // chrome://mobilesetup/ will open carrier specific portal.
       dictionary->SetBoolean(kTagShowViewAccountButton, true);
@@ skipping 58 matching lines @@
   if (command == kTagOptions) {
     cros_->RequestNetworkServiceProperties(
         service_path,
         base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback,
                    weak_factory_.GetWeakPtr()));
   } else if (command == kTagConnect) {
     ConnectToNetwork(network);
   } else if (command == kTagDisconnect && type != chromeos::TYPE_ETHERNET) {
     cros_->DisconnectFromNetwork(network);
   } else if (command == kTagActivate && type == chromeos::TYPE_CELLULAR) {
-    ash::Shell::GetInstance()->delegate()->OpenMobileSetup(
-        network->service_path());
+    if (!UseDirectActivation()) {
+      ash::Shell::GetInstance()->delegate()->OpenMobileSetup(
+          network->service_path());
+    } else {
+      Activate(service_path);
+      // Update network properties after we start activation. The Activate
+      // call is a blocking call, which blocks on finishing the "start" of
+      // the activation, hence when we query for network properties after
+      // this call is done, we will have the "activating" activation state.
+      UpdateConnectionData(network);
+    }
   } else {
     VLOG(1) << "Unknown command: " << command;
     NOTREACHED();
   }
 }
 
 void InternetOptionsHandler::ToggleAirplaneModeCallback(const ListValue* args) {
   // TODO(kevers): The use of 'offline_mode' is not quite correct.  Update once
   // we have proper back-end support.
   cros_->EnableOfflineMode(!cros_->offline_mode());
@@ skipping 183 matching lines @@
 
   dictionary->SetBoolean(kTagWimaxEnabled, cros_->wimax_enabled());
   dictionary->SetBoolean(kTagWimaxAvailable, cros_->wimax_available());
   dictionary->SetBoolean(kTagWimaxBusy, cros_->wimax_busy());
   // TODO(kevers): The use of 'offline_mode' is not quite correct.  Update once
   // we have proper back-end support.
   dictionary->SetBoolean(kTagAirplaneMode, cros_->offline_mode());
 }
 
 }  // namespace options