Made activate/buy button show consistently on network list and details pages....

chrome/browser/chromeos/webui/internet_options_handler.cc

 // Copyright (c) 2011 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/chromeos/webui/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 382 matching lines @@
 }
 
 // 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.
-void InternetOptionsHandler::MonitorNetworks( chromeos::NetworkLibrary* cros) {
+void InternetOptionsHandler::MonitorNetworks(chromeos::NetworkLibrary* cros) {
   cros->RemoveObserverForAllNetworks(this);
   const chromeos::WifiNetwork* wifi_network = cros->wifi_network();
   if (wifi_network != NULL)
     cros->AddNetworkObserver(wifi_network->service_path(), this);
   // Always monitor the cellular networks, if any, so that changes
   // in network technology, roaming status, and signal strength
   // will be shown.
   const chromeos::CellularNetworkVector& cell_networks =
       cros->cellular_networks();
   for (size_t i = 0; i < cell_networks.size(); ++i) {
@@ skipping 15 matching lines @@
   for (chromeos::CellularDataPlanVector::const_iterator iter = plans.begin();
        iter != plans.end();
        ++iter) {
     plan_list->Append(CellularDataPlanToDictionary(*iter));
   }
   connection_plans.SetString("servicePath", cellular->service_path());
   connection_plans.SetBoolean("needsPlan", cellular->needs_new_plan());
   connection_plans.SetBoolean("activated",
       cellular->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATED);
   connection_plans.Set("plans", plan_list);
+  SetActivationButtonVisibility(cellular, &connection_plans);
   web_ui_->CallJavascriptFunction(
       L"options.InternetOptions.updateCellularPlans", connection_plans);
 }
 
 DictionaryValue* InternetOptionsHandler::CellularDataPlanToDictionary(
     const chromeos::CellularDataPlan* plan) {
   DictionaryValue* plan_dict = new DictionaryValue();
   plan_dict->SetInteger("planType", plan->plan_type);
   plan_dict->SetString("name", plan->plan_name);
   plan_dict->SetString("planSummary", plan->GetPlanDesciption());
@@ skipping 104 matching lines @@
   dictionary.SetBoolean("connecting", net->connecting());
   dictionary.SetBoolean("connected", net->connected());
   dictionary.SetString("connectionState", net->GetStateString());
 
   if (type == chromeos::TYPE_WIFI) {
     chromeos::WifiNetwork* wifi =
         cros->FindWifiNetworkByPath(net->service_path());
     if (!wifi) {
       LOG(WARNING) << "Cannot find network " << net->service_path();
     } else {
-      PopulateWifiDetails(&dictionary, wifi);
+      PopulateWifiDetails(wifi, &dictionary);
     }
   } else if (type == chromeos::TYPE_CELLULAR) {
     chromeos::CellularNetwork* cellular =
         cros->FindCellularNetworkByPath(net->service_path());
     if (!cellular) {
       LOG(WARNING) << "Cannot find network " << net->service_path();
     } else {
-      PopulateCellularDetails(&dictionary, cellular);
+      PopulateCellularDetails(cellular, &dictionary);
     }
   }
 
   web_ui_->CallJavascriptFunction(
       L"options.InternetOptions.showDetailedInfo", dictionary);
 }
 
 void InternetOptionsHandler::PopulateWifiDetails(
-    DictionaryValue* dictionary,
-    const chromeos::WifiNetwork* wifi) {
+    const chromeos::WifiNetwork* wifi,
+    DictionaryValue* dictionary) {
   dictionary->SetString("ssid", wifi->name());
   dictionary->SetBoolean("autoConnect", wifi->auto_connect());
   if (wifi->encrypted()) {
     dictionary->SetBoolean("encrypted", true);
     if (wifi->encryption() == chromeos::SECURITY_8021X) {
       bool certificate_in_pkcs11 =
           IsCertificateInPkcs11(wifi->cert_path());
       if (certificate_in_pkcs11) {
         dictionary->SetBoolean("certInPkcs", true);
       } else {
         dictionary->SetBoolean("certInPkcs", false);
       }
       dictionary->SetString("certPath", wifi->cert_path());
       dictionary->SetString("ident", wifi->identity());
       dictionary->SetBoolean("certNeeded", true);
       dictionary->SetString("certPass", wifi->passphrase());
     } else {
       dictionary->SetBoolean("certNeeded", false);
     }
   } else {
     dictionary->SetBoolean("encrypted", false);
   }
 }
 
 void InternetOptionsHandler::PopulateCellularDetails(
-    DictionaryValue* dictionary,
-    const chromeos::CellularNetwork* cellular) {
+    const chromeos::CellularNetwork* cellular,
+    DictionaryValue* dictionary) {
   // Cellular network / connection settings.
   dictionary->SetString("serviceName", cellular->service_name());
   dictionary->SetString("networkTechnology",
                         cellular->GetNetworkTechnologyString());
   dictionary->SetString("operatorName", cellular->operator_name());
   dictionary->SetString("operatorCode", cellular->operator_code());
   dictionary->SetString("activationState",
                         cellular->GetActivationStateString());
   dictionary->SetString("roamingState",
                         cellular->GetRoamingStateString());
   dictionary->SetString("restrictedPool",
                         cellular->restricted_pool() ?
                         l10n_util::GetStringUTF8(
                             IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL) :
                         l10n_util::GetStringUTF8(
                             IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL));
   dictionary->SetString("errorState", cellular->GetErrorString());
   dictionary->SetString("supportUrl", cellular->payment_url());
+  dictionary->SetBoolean("needsPlan", cellular->needs_new_plan());
 
   // Device settings.
   dictionary->SetString("manufacturer", cellular->manufacturer());
   dictionary->SetString("modelId", cellular->model_id());
   dictionary->SetString("firmwareRevision", cellular->firmware_revision());
   dictionary->SetString("hardwareRevision", cellular->hardware_revision());
   dictionary->SetString("lastUpdate", cellular->last_update());
   dictionary->SetString("prlVersion", StringPrintf("%u",
                                                    cellular->prl_version()));
   dictionary->SetString("meid", cellular->meid());
   dictionary->SetString("imei", cellular->imei());
   dictionary->SetString("mdn", cellular->mdn());
   dictionary->SetString("imsi", cellular->imsi());
   dictionary->SetString("esn", cellular->esn());
   dictionary->SetString("min", cellular->min());
 
   dictionary->SetBoolean("gsm", cellular->is_gsm());
+
+  SetActivationButtonVisibility(cellular, dictionary);
+}
+
+void InternetOptionsHandler::SetActivationButtonVisibility(
+    const chromeos::CellularNetwork* cellular,
+    DictionaryValue* dictionary) {
+  if (cellular->needs_new_plan()) {
+    dictionary->SetBoolean("showBuyButton", true);
+  } else if (cellular->activation_state() !=
+                 chromeos::ACTIVATION_STATE_ACTIVATING &&
+             cellular->activation_state() !=
+                 chromeos::ACTIVATION_STATE_ACTIVATED) {
+    dictionary->SetBoolean("showActivateButton", true);
+  }
 }
 
 void InternetOptionsHandler::LoginCallback(const ListValue* args) {
   std::string service_path;
   std::string password;
 
   if (args->GetSize() != 2 ||
       !args->GetString(0, &service_path) ||
       !args->GetString(1, &password)) {
     NOTREACHED();
@@ skipping 417 matching lines @@
     DictionaryValue* dictionary, chromeos::NetworkLibrary* cros) {
   dictionary->SetBoolean("accessLocked", cros->IsLocked());
   dictionary->Set("wiredList", GetWiredList());
   dictionary->Set("wirelessList", GetWirelessList());
   dictionary->Set("rememberedList", GetRememberedList());
   dictionary->SetBoolean("wifiAvailable", cros->wifi_available());
   dictionary->SetBoolean("wifiEnabled", cros->wifi_enabled());
   dictionary->SetBoolean("cellularAvailable", cros->cellular_available());
   dictionary->SetBoolean("cellularEnabled", cros->cellular_enabled());
 }