Removed logic that was disabling other types of network connections during mobile activation.

chrome/browser/ui/webui/chromeos/mobile_setup_ui.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/ui/webui/chromeos/mobile_setup_ui.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 278 matching lines @@
                           std::string* error);
   // Sends status updates to WebUI page.
   void UpdatePage(chromeos::CellularNetwork* network,
                   const std::string& error_description);
   // Changes internal state.
   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);
-  // Disables ethernet and wifi newtorks since they interefere with
-  // detection of restricted pool on cellular side.
-  void DisableOtherNetworks();
   // 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();
+  // Disables SSL certificate revocation checking mechanism. In the case
+  // where captive portal connection is the only one present, such revocation
+  // checks could prevent payment portal page from loading.
+  void DisableCertRevocationChecking();
+  // Reenables SSL certificate revocation checking mechanism.
+  void ReEnableCertRevocationChecking();
   // Return error message for a given code.
   std::string GetErrorMessage(const std::string& code);
 
   // Converts the currently active CellularNetwork device into a JS object.
   static void GetDeviceInfo(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 Web UI.
   static bool EvaluateCellularDeviceState(bool* report_status,
                                           std::string* state,
                                           std::string* error);
 
   // Returns next reconnection state based on the current activation phase.
   static PlanActivationState GetNextReconnectState(PlanActivationState state);
   static const char* GetStateDescription(PlanActivationState state);
 
   scoped_refptr<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
+  // Flags that controls if cert_checks needs to be restored
   // after the activation of cellular network.
-  bool reenable_wifi_;
-  bool reenable_ethernet_;
   bool reenable_cert_check_;
   bool evaluating_;
   // True if we think that another tab is already running activation.
   bool already_running_;
   // Connection retry counter.
   int connection_retry_count_;
   // Post payment reconnect wait counters.
   int reconnect_wait_count_;
   // Payment portal reload/reconnect attempt count.
   int payment_reconnect_count_;
@@ skipping 139 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 //
 // MobileSetupHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 MobileSetupHandler::MobileSetupHandler(const std::string& service_path)
     : cellular_config_(new CellularConfigDocument()),
       tab_contents_(NULL),
       state_(PLAN_ACTIVATION_PAGE_LOADING),
       service_path_(service_path),
-      reenable_wifi_(false),
-      reenable_ethernet_(false),
       reenable_cert_check_(false),
       evaluating_(false),
       already_running_(false),
       connection_retry_count_(0),
       reconnect_wait_count_(0),
       payment_reconnect_count_(0),
       activation_attempt_(0) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   reconnect_timer_.Stop();
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   if (lib->IsLocked())
     lib->Unlock();
-  ReEnableOtherConnections();
+  ReEnableCertRevocationChecking();
 }
 
 WebUIMessageHandler* MobileSetupHandler::Attach(WebUI* web_ui) {
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void MobileSetupHandler::Init(TabContents* contents) {
   tab_contents_ = contents;
 }
 
@@ skipping 383 matching lines @@
           break;
         default:
           break;
       }
       break;
     }
     case PLAN_ACTIVATION_RECONNECTING_OTASP_TRY:
     case PLAN_ACTIVATION_RECONNECTING_PAYMENT:
     case PLAN_ACTIVATION_RECONNECTING: {
       if (network->connected()) {
-        // Make sure other networks are not interfering with our detection of
-        // restricted pool.
-        DisableOtherNetworks();
         // Wait until the service shows up and gets activated.
         switch (network->activation_state()) {
           case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
           case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->restricted_pool()) {
               if (network->error() == chromeos::ERROR_DNS_LOOKUP_FAILED) {
                 LOG(WARNING) << "No connectivity for device "
                              << network->service_path().c_str();
                 // If we are connected but there is no connectivity at all,
                 // restart the whole process again.
@@ skipping 24 matching lines @@
             break;
         }
       } else if (NeedsReconnecting(network, &new_state, &error_description)) {
         evaluating_ = false;
         return;
       }
       break;
     }
     case PLAN_ACTIVATION_RECONNECTING_OTASP: {
       if (network->connected()) {
-        // Make sure other networks are not interfering with our detection of
-        // restricted pool.
-        DisableOtherNetworks();
         // Wait until the service shows up and gets activated.
         switch (network->activation_state()) {
           case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
           case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->restricted_pool()) {
               LOG(WARNING) << "Still no connectivity after OTASP for device "
                            << network->service_path().c_str();
               // If we have already received payment, don't show the payment
               // page again. We should try to reconnect after some time instead.
               if (reconnect_wait_count_ < kMaxReconnectAttemptOTASP) {
@@ skipping 149 matching lines @@
       GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   if (lib->IsLocked())
     lib->Unlock();
   // If we have successfully activated the connection, set autoconnect flag.
   if (network)
     network->SetAutoConnect(true);
   // Reactivate other types of connections if we have
   // shut them down previously.
-  ReEnableOtherConnections();
+  ReEnableCertRevocationChecking();
 }
 
 void MobileSetupHandler::UpdatePage(
     chromeos::CellularNetwork* network,
     const std::string& error_description) {
   DictionaryValue device_dict;
   if (network)
     GetDeviceInfo(network, &device_dict);
   device_dict.SetInteger("state", state_);
   if (error_description.length())
@@ skipping 91 matching lines @@
       break;
     case PLAN_ACTIVATION_ERROR:
       CompleteActivation(NULL);
       UMA_HISTOGRAM_COUNTS("Cellular.PlanFailed", 1);
       break;
     default:
       break;
   }
 }
 
-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->EnableWifiNetworkDevice(true);
-  }
-
+void MobileSetupHandler::ReEnableCertRevocationChecking() {
   PrefService* prefs = g_browser_process->local_state();
   if (reenable_cert_check_) {
     prefs->SetBoolean(prefs::kCertRevocationCheckingEnabled,
                       true);
     reenable_cert_check_ = false;
   }
 }
 
-void MobileSetupHandler::SetupActivationProcess(
-    chromeos::CellularNetwork* network) {
-  if (!network)
-    return;
-
-  // Disable SSL cert checks since we will be doing this in
+void MobileSetupHandler::DisableCertRevocationChecking() {
+  // Disable SSL cert checks since we might be performin activation in the
   // restricted pool.
   PrefService* prefs = g_browser_process->local_state();
   if (!reenable_cert_check_ &&
       prefs->GetBoolean(
           prefs::kCertRevocationCheckingEnabled)) {
     reenable_cert_check_ = true;
     prefs->SetBoolean(prefs::kCertRevocationCheckingEnabled, false);
   }
+}
 
+void MobileSetupHandler::SetupActivationProcess(
+    chromeos::CellularNetwork* network) {
+  if (!network)
+    return;
+
+  DisableCertRevocationChecking();
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
   // Disable autoconnect to cellular network.
   network->SetAutoConnect(false);
 
-  // Prevent any other network interference.
-  DisableOtherNetworks();
   lib->Lock();
 }
 
-void MobileSetupHandler::DisableOtherNetworks() {
-  chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
-      GetNetworkLibrary();
-  // Disable ethernet and wifi.
-  if (lib->ethernet_enabled()) {
-    reenable_ethernet_ = true;
-    lib->EnableEthernetNetworkDevice(false);
-  }
-  if (lib->wifi_enabled()) {
-    reenable_wifi_ = true;
-    lib->EnableWifiNetworkDevice(false);
-  }
-}
-
 bool MobileSetupHandler::GotActivationError(
     chromeos::CellularNetwork* network, std::string* error) {
   DCHECK(network);
   bool got_error = false;
   const char* error_code = kErrorDefault;
 
   // This is the magic for detection of errors in during activation process.
   if (network->state() == chromeos::STATE_FAILURE &&
       network->error() == chromeos::ERROR_AAA_FAILED) {
     if (network->activation_state() ==
@@ skipping 88 matching lines @@
   // Set up the chrome://mobilesetup/ source.
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(html_source);
 }
 
 void MobileSetupUI::RenderViewCreated(RenderViewHost* host) {
   ChromeWebUI::RenderViewCreated(host);
   // Destroyed by the corresponding RenderViewHost.
   new PortalFrameLoadObserver(host, tab_contents()->web_ui());
 }