Fixed activation process....

chrome/browser/chromeos/dom_ui/mobile_setup_ui.cc

 // Copyright (c) 2010 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/dom_ui/mobile_setup_ui.h"
 
 #include <map>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/weak_ptr.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/system_library.h"
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/jstemplate_builder.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
-#include "net/base/ssl_config_service.h"
 
 namespace {
 
 // Host page JS API function names.
 const char kJsApiStartActivation[] = "startActivation";
 const char kJsApiCloseTab[] = "closeTab";
 const char kJsApiSetTransactionStatus[] = "setTransactionStatus";
 
 const wchar_t kJsDeviceStatusChangedHandler[] =
     L"mobile.MobileSetup.deviceStateChanged";
 
-// Collular device states that are reported to DOM UI layer.
-const char kStateUnknown[] = "unknown";
-const char kStateConnecting[] = "connecting";
-const char kStateError[] = "error";
-const char kStateNeedsPayment[] = "payment";
-const char kStateActivating[] = "activating";
-const char kStateDisconnected[] = "disconnected";
-const char kStateConnected[] = "connected";
-const char kFailedPayment[] = "failed_payment";
-
 // Error codes matching codes defined in the cellular config file.
 const char kErrorDefault[] = "default";
 const char kErrorBadConnectionPartial[] = "bad_connection_partial";
 const char kErrorBadConnectionActivated[] = "bad_connection_activated";
 const char kErrorRoamingOnConnection[] = "roaming_connection";
 const char kErrorNoEVDO[] = "no_evdo";
 const char kErrorRoamingActivation[] = "roaming_activation";
 const char kErrorRoamingPartiallyActivated[] = "roaming_partially_activated";
 const char kErrorNoService[] = "no_service";
 const char kFailedPaymentError[] = "failed_payment";
@@ skipping 82 matching lines @@
   // NetworkLibrary::PropertyObserver implementation.
   virtual void PropertyChanged(const char* service_path,
                                const char* key,
                                const Value* value);
 
  private:
   typedef enum PlanActivationState {
     PLAN_ACTIVATION_PAGE_LOADING = -1,
     PLAN_ACTIVATION_START = 0,
     PLAN_ACTIVATION_INITIATING_ACTIVATION = 1,
-    PLAN_ACTIVATION_ACTIVATING = 2,
+    PLAN_ACTIVATION_RECONNECTING = 2,
     PLAN_ACTIVATION_SHOWING_PAYMENT = 3,
     PLAN_ACTIVATION_DONE = 4,
     PLAN_ACTIVATION_ERROR = 5,
   } PlanActivationState;
 
   // Handlers for JS DOMUI messages.
   void HandleStartActivation(const ListValue* args);
   void HandleCloseTab(const ListValue* args);
   void HandleSetTransactionStatus(const ListValue* args);
 
   // Sends message to host registration page with system/user info data.
   void SendDeviceInfo();
 
   // Verify the state of cellular network and modify internal state.
-  void EvaluateCellularNetwork(const chromeos::CellularNetwork* network);
+  void EvaluateCellularNetwork(chromeos::CellularNetwork* network);
   // Check the current cellular network for error conditions.
   bool GotActivationError(const chromeos::CellularNetwork* network,
                           std::string* error);
-  void ChangeState(const chromeos::CellularNetwork* network,
+  void ChangeState(chromeos::CellularNetwork* network,
                    PlanActivationState new_state,
                    const std::string& error_description);
-
+  // Prepares network devices for cellular activation process.
+  void SetupActivationProcess(chromeos::CellularNetwork* network);
+  // Resets network devices after cellular activation process.
+  // |network| should be NULL if the activation process failed.
+  void CompleteActivation(chromeos::CellularNetwork* network);
   // Control routines for handling other types of connections during
   // cellular activation.
   void ReEnableOtherConnections();
-  void DisableOtherConnections();
 
   // Converts the currently active CellularNetwork device into a JS object.
   static void GetDeviceInfo(const chromeos::CellularNetwork* network,
                             DictionaryValue* value);
   static bool ShouldReportDeviceState(std::string* state, std::string* error);
 
   // Performs activation state cellular device evaluation.
   // Returns false if device activation failed. In this case |error|
   // will contain error message to be reported to DOM UI.
   static bool EvaluateCellularDeviceState(bool* report_status,
                                           std::string* state,
                                           std::string* error);
 
   // Return error message for a given code.
   static std::string GetErrorMessage(const std::string& code);
   static void LoadCellularConfig();
 
   static const char* GetStateDescription(PlanActivationState state);
 
   static scoped_ptr<CellularConfigDocument> cellular_config_;
 
   TabContents* tab_contents_;
   // Internal handler state.
   PlanActivationState state_;
   std::string service_path_;
   // Flags that control if wifi and ethernet connection needs to be restored
   // after the activation of cellular network.
   bool reenable_wifi_;
   bool reenable_ethernet_;
+  bool reenable_cert_check_;
   DISALLOW_COPY_AND_ASSIGN(MobileSetupHandler);
 };
 
 scoped_ptr<CellularConfigDocument> MobileSetupHandler::cellular_config_;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // CellularConfigDocument
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 90 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 //
 // MobileSetupHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 MobileSetupHandler::MobileSetupHandler(const std::string& service_path)
     : tab_contents_(NULL),
       state_(PLAN_ACTIVATION_PAGE_LOADING),
       service_path_(service_path),
       reenable_wifi_(false),
-      reenable_ethernet_(false) {
+      reenable_ethernet_(false),
+      reenable_cert_check_(false) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   lib->RemoveObserver(this);
   lib->RemoveProperyObserver(this);
-  // net::SSLConfigService::AllowRevChecking();
   ReEnableOtherConnections();
 }
 
 DOMMessageHandler* MobileSetupHandler::Attach(DOMUI* dom_ui) {
   return DOMMessageHandler::Attach(dom_ui);
 }
 
 void MobileSetupHandler::Init(TabContents* contents) {
   tab_contents_ = contents;
   LoadCellularConfig();
+  SetupActivationProcess(GetCellularNetwork(service_path_));
 }
 
 void MobileSetupHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback(kJsApiStartActivation,
       NewCallback(this, &MobileSetupHandler::HandleStartActivation));
   dom_ui_->RegisterMessageCallback(kJsApiCloseTab,
       NewCallback(this, &MobileSetupHandler::HandleCloseTab));
   dom_ui_->RegisterMessageCallback(kJsApiSetTransactionStatus,
       NewCallback(this, &MobileSetupHandler::HandleSetTransactionStatus));
 }
@@ skipping 44 matching lines @@
     return;
   }
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
   lib->RemoveObserver(this);
   lib->RemoveProperyObserver(this);
   // Start monitoring network and service property changes.
   lib->AddObserver(this);
   lib->AddProperyObserver(network->service_path().c_str(),
                           this);
-  state_ = PLAN_ACTIVATION_START;
+  ChangeState(network, PLAN_ACTIVATION_START, std::string());
   EvaluateCellularNetwork(network);
 }
 
 void MobileSetupHandler::HandleSetTransactionStatus(const ListValue* args) {
   const size_t kSetTransactionStatusParamCount = 1;
   if (args->GetSize() != kSetTransactionStatusParamCount)
     return;
 
   // Get change callback function name.
   std::string status;
   if (!args->GetString(0, &status))
     return;
 
   // The payment is received, try to reconnect and check the status all over
   // again.
-  if (LowerCaseEqualsASCII(status, "OK")) {
-    chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
-        GetNetworkLibrary();
-    ChangeState(
-        lib->cellular_network(),
-        PLAN_ACTIVATION_START, std::string());
+  if (LowerCaseEqualsASCII(status, "ok")) {
+    ChangeState(GetCellularNetwork(), PLAN_ACTIVATION_START, std::string());
+    EvaluateCellularNetwork(GetCellularNetwork());
   }
 }
 
 
 void MobileSetupHandler::EvaluateCellularNetwork(
-    const chromeos::CellularNetwork* network) {
+    chromeos::CellularNetwork* network) {
   if (!dom_ui_)
     return;
 
   PlanActivationState new_state = state_;
   if (network) {
     LOG(INFO) << "Cellular:\n  service=" << network->GetStateString().c_str()
             << "\n  ui=" << GetStateDescription(state_)
             << "\n  activation=" << network->GetActivationStateString().c_str()
             << "\n  restricted=" << (network->restricted_pool() ? "yes" : "no")
             << "\n  error=" << network->GetErrorString().c_str()
             << "\n  setvice_path=" << network->service_path().c_str();
   } else {
     LOG(WARNING) << "Cellular service lost";
   }
   switch (state_) {
     case PLAN_ACTIVATION_START:
       if (network) {
         switch (network->activation_state()) {
-          case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
           case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->failed_or_disconnected()) {
-              new_state = PLAN_ACTIVATION_ACTIVATING;
+              new_state = PLAN_ACTIVATION_RECONNECTING;
             } else if (network->connection_state() == chromeos::STATE_READY) {
-              new_state = network->restricted_pool() ?
-                  PLAN_ACTIVATION_SHOWING_PAYMENT : PLAN_ACTIVATION_DONE;
+              if (network->restricted_pool()) {
+                new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+              } else {
+                new_state = PLAN_ACTIVATION_DONE;
+              }
             }
             break;
           case chromeos::ACTIVATION_STATE_UNKNOWN:
           case chromeos::ACTIVATION_STATE_NOT_ACTIVATED:
+          case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
             if (network->failed_or_disconnected()) {
               new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
             } else if (network->connected()) {
               LOG(INFO) << "Disconnecting from " <<
                   network->service_path().c_str();
               chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
                   DisconnectFromWirelessNetwork(network);
             }
             break;
           default:
             new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
             break;
         }
       }
       break;
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
       if (network) {
         switch (network->activation_state()) {
           case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->failed_or_disconnected()) {
-              new_state = PLAN_ACTIVATION_ACTIVATING;
+              new_state = PLAN_ACTIVATION_RECONNECTING;
             } else if (network->connection_state() == chromeos::STATE_READY) {
               if (network->restricted_pool()) {
                 new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
               } else {
                 new_state = PLAN_ACTIVATION_DONE;
               }
             }
             break;
           case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
             if (network->connected())
               new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
             else
-              new_state = PLAN_ACTIVATION_ACTIVATING;
+              new_state = PLAN_ACTIVATION_RECONNECTING;
             break;
           case chromeos::ACTIVATION_STATE_NOT_ACTIVATED:
             // Wait in this state until activation state changes.
             break;
           case chromeos::ACTIVATION_STATE_ACTIVATING:
             break;
           default:
             break;
         }
       }
       break;
-    case PLAN_ACTIVATION_ACTIVATING:
+    case PLAN_ACTIVATION_RECONNECTING:
       // Wait until the service shows up and gets activated.
       if (network) {
         switch (network->activation_state()) {
           case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->connection_state() == chromeos::STATE_READY) {
               if (network->restricted_pool()) {
                 new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
               } else {
                 new_state = PLAN_ACTIVATION_DONE;
               }
@@ skipping 30 matching lines @@
 // Debugging helper function, will take it out at the end.
 const char* MobileSetupHandler::GetStateDescription(
     PlanActivationState state) {
   switch (state) {
     case PLAN_ACTIVATION_PAGE_LOADING:
       return "PAGE_LOADING";
     case PLAN_ACTIVATION_START:
       return "ACTIVATION_START";
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
       return "INITIATING_ACTIVATION";
-    case PLAN_ACTIVATION_ACTIVATING :
-      return "ACTIVATING";
+    case PLAN_ACTIVATION_RECONNECTING:
+      return "RECONNECTING";
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
       return "SHOWING_PAYMENT";
     case PLAN_ACTIVATION_DONE:
       return "DONE";
     case PLAN_ACTIVATION_ERROR:
       return "ERROR";
   }
   return "UNKNOWN";
 }
 
-void MobileSetupHandler::ChangeState(const chromeos::CellularNetwork* network,
+
+void MobileSetupHandler::CompleteActivation(
+    chromeos::CellularNetwork* network) {
+  // Remove observers, we are done with this page.
+  chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
+      GetNetworkLibrary();
+  // If we have successfully activated the connection, set autoconnect flag.
+  if (network) {
+    network->set_auto_connect(true);
+    lib->SaveCellularNetwork(network);
+  }
+  lib->RemoveObserver(this);
+  lib->RemoveProperyObserver(this);
+  // Reactivate other types of connections if we have
+  // shut them down previously.
+  ReEnableOtherConnections();
+}
+
+
+void MobileSetupHandler::ChangeState(chromeos::CellularNetwork* network,
                                      PlanActivationState new_state,
                                      const std::string& error_description) {
   static bool first_time = true;
   if (state_ == new_state && !first_time)
     return;
   LOG(INFO) << "Activation state flip old = " <<
           GetStateDescription(state_) << ", new = " <<
           GetStateDescription(new_state);
   first_time = false;
   state_ = new_state;
   switch (new_state) {
     case PLAN_ACTIVATION_START:
-      DisableOtherConnections();
       break;
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
       DCHECK(network);
       LOG(INFO) << "Activating service " << network->service_path().c_str();
       if (!network->StartActivation())
         new_state = PLAN_ACTIVATION_ERROR;
       break;
-    case PLAN_ACTIVATION_ACTIVATING: {
+    case PLAN_ACTIVATION_RECONNECTING: {
       DCHECK(network);
       if (network) {
         chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
             ConnectToCellularNetwork(network);
       }
       break;
     }
     case PLAN_ACTIVATION_PAGE_LOADING:
       return;
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
       // Fix for fix SSL for the walled gardens where cert chain verification
       // might not work.
-      // net::SSLConfigService::DisallowRevChecking();
       break;
     case PLAN_ACTIVATION_DONE:
+      DCHECK(network);
+      CompleteActivation(network);
+      break;
     case PLAN_ACTIVATION_ERROR: {
-      // net::SSLConfigService::AllowRevChecking();
-      // Remove observers, we are done with this page.
-      chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
-          GetNetworkLibrary();
-      lib->RemoveObserver(this);
-      lib->RemoveProperyObserver(this);
-      // Reactivate other types of connections if we have
-      // shut them down previously.
-      ReEnableOtherConnections();
+      CompleteActivation(NULL);
       break;
     }
     default:
       break;
   }
   DictionaryValue device_dict;
   if (network)
     GetDeviceInfo(network, &device_dict);
   device_dict.SetInteger("state", new_state);
   if (error_description.length())
     device_dict.SetString("error", error_description);
   dom_ui_->CallJavascriptFunction(
       kJsDeviceStatusChangedHandler, device_dict);
 }
 
 void MobileSetupHandler::ReEnableOtherConnections() {
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
   if (reenable_ethernet_) {
     reenable_ethernet_ = false;
     lib->EnableEthernetNetworkDevice(true);
   }
   if (reenable_wifi_) {
     reenable_wifi_ = false;
     lib->EnableCellularNetworkDevice(true);
   }
+
+  PrefService* prefs = dom_ui_->GetProfile()->GetPrefs();
+  if (reenable_cert_check_) {
+    reenable_cert_check_ = false;
+    prefs->SetBoolean(prefs::kCertRevocationCheckingEnabled,
+                      reenable_cert_check_);
+  }
 }
 
-void MobileSetupHandler::DisableOtherConnections() {
+
+void MobileSetupHandler::SetupActivationProcess(
+    chromeos::CellularNetwork* network) {
+  if (!network)
+    return;
+
+  // Disable SSL cert checks since we will be doing this in
+  // restricted pool.
+  PrefService* prefs = dom_ui_->GetProfile()->GetPrefs();
+  if (!reenable_cert_check_ &&
+      prefs->GetBoolean(
+          prefs::kCertRevocationCheckingEnabled)) {
+    reenable_cert_check_ = true;
+    prefs->SetBoolean(prefs::kCertRevocationCheckingEnabled, false);
+  }
+
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
+  // Disable autoconnect to cellular network.
+  network->set_auto_connect(false);
+  lib->SaveCellularNetwork(network);
+
+  // Disable ethernet and wifi.
   if (!reenable_ethernet_ && lib->ethernet_enabled()) {
     reenable_ethernet_ = true;
     lib->EnableEthernetNetworkDevice(false);
   }
   if (!reenable_wifi_ && lib->wifi_enabled()) {
     reenable_wifi_ = true;
     lib->EnableCellularNetworkDevice(false);
   }
 }
 
+
 bool MobileSetupHandler::GotActivationError(
     const chromeos::CellularNetwork* network, std::string* error) {
   if (!network)
     return false;
   bool got_error = false;
   const char* error_code = kErrorDefault;
 
   // This is the magic for detection of errors in during activation process.
   if (network->connection_state() == chromeos::STATE_FAILURE &&
       network->error() == chromeos::ERROR_AAA_FAILED ) {
@@ skipping 86 matching lines @@
       new MobileSetupUIHTMLSource(service_path);
 
   // Set up the chrome://mobilesetup/ source.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           Singleton<ChromeURLDataManager>::get(),
           &ChromeURLDataManager::AddDataSource,
           make_scoped_refptr(html_source)));
 }