Improved activation logic to cover few more edge cases. Removed button that w...

chrome/browser/chromeos/dom_ui/mobile_setup_ui.cc

 // Copyright (c) 2006-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 <algorithm>
 #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/metrics/histogram.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"
 
 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";
 
 // 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";
@@ skipping 117 matching lines @@
       if (handler_)
         handler_->SetTransactionStatus(status_);
     }
    private:
     base::WeakPtr<MobileSetupHandler> handler_;
     std::string status_;
     DISALLOW_COPY_AND_ASSIGN(TaskProxy);
   };
 
   // Handlers for JS DOMUI messages.
-  void HandleCloseTab(const ListValue* args);
   void HandleSetTransactionStatus(const ListValue* args);
   void HandleStartActivation(const ListValue* args);
   void SetTransactionStatus(const std::string& status);
   void StartActivation();
 
   // 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(chromeos::CellularNetwork* network);
   // Check the current cellular network for error conditions.
   bool GotActivationError(const chromeos::CellularNetwork* network,
                           std::string* error);
+  // Sends status updates to DOMUI 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);
   // 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.
@@ skipping 23 matching lines @@
   // 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_;
   bool transaction_complete_signalled_;
   bool activation_status_test_;
+  bool evaluating_;
   DISALLOW_COPY_AND_ASSIGN(MobileSetupHandler);
 };
 
 scoped_ptr<CellularConfigDocument> MobileSetupHandler::cellular_config_;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // CellularConfigDocument
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 93 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 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_cert_check_(false),
       transaction_complete_signalled_(false),
-      activation_status_test_(false) {
+      activation_status_test_(false),
+      evaluating_(false) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   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));
 }
 
 void MobileSetupHandler::OnNetworkManagerChanged(
     chromeos::NetworkLibrary* cros) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
   // Note that even though we get here when the service has
   // reappeared after disappearing earlier in the activation
   // process, there's no need to re-establish the NetworkObserver,
   // because the service path remains the same.
   EvaluateCellularNetwork(GetCellularNetwork(service_path_));
 }
 
 void MobileSetupHandler::OnNetworkChanged(chromeos::NetworkLibrary* cros,
                                           const chromeos::Network* network) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
   DCHECK(network && network->type() == chromeos::TYPE_CELLULAR);
   EvaluateCellularNetwork(
       static_cast<chromeos::CellularNetwork*>(
           const_cast<chromeos::Network*>(network)));
 }
 
-void MobileSetupHandler::HandleCloseTab(const ListValue* args) {
-  if (!dom_ui_)
-    return;
-  Browser* browser = BrowserList::FindBrowserWithFeature(
-      dom_ui_->GetProfile(), Browser::FEATURE_TABSTRIP);
-  if (browser)
-    browser->CloseTabContents(tab_contents_);
-}
-
 void MobileSetupHandler::HandleStartActivation(const ListValue* args) {
   scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr());
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(task.get(), &TaskProxy::HandleStartActivation));
+  UMA_HISTOGRAM_COUNTS("Cellular.MobileSetupStart", 1);
 }
 
 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;
@@ skipping 18 matching lines @@
   state_ = PLAN_ACTIVATION_START;
   EvaluateCellularNetwork(network);
 }
 
 void MobileSetupHandler::SetTransactionStatus(const std::string& status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // The payment is received, try to reconnect and check the status all over
   // again.
   if (LowerCaseEqualsASCII(status, "ok") &&
       state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
+    UMA_HISTOGRAM_COUNTS("Cellular.PaymentReceived", 1);
     if (transaction_complete_signalled_) {
       LOG(WARNING) << "Transaction completion signaled more than once!?";
       return;
     }
     transaction_complete_signalled_ = true;
     activation_status_test_ = false;
     state_ = PLAN_ACTIVATION_START;
     chromeos::CellularNetwork* network = GetCellularNetwork();
     if (network &&
         network->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATED) {
       chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
           DisconnectFromWirelessNetwork(network);
     } else {
       EvaluateCellularNetwork(network);
     }
+  } else {
+    UMA_HISTOGRAM_COUNTS("Cellular.PaymentFailed", 1);
   }
 }
 
 void MobileSetupHandler::EvaluateCellularNetwork(
     chromeos::CellularNetwork* network) {
   if (!dom_ui_)
     return;
 
   PlanActivationState new_state = state_;
   if (!network) {
     LOG(WARNING) << "Cellular service lost";
     return;
   }
 
+  // Prevent this method from being called if it is already on the stack.
+  // This might happen on some state transitions (ie. connect, disconnect).
+  if (evaluating_)
+    return;
+  evaluating_ = true;
+
   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();
   switch (state_) {
     case PLAN_ACTIVATION_START: {
       switch (network->activation_state()) {
         case chromeos::ACTIVATION_STATE_ACTIVATED: {
           if (network->failed_or_disconnected()) {
             new_state = PLAN_ACTIVATION_RECONNECTING;
-          } else if (network->connection_state() == chromeos::STATE_READY) {
+          } else if (network->connected()) {
             if (network->restricted_pool()) {
               new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
             } else {
               new_state = PLAN_ACTIVATION_DONE;
             }
           }
           break;
         }
         case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED: {
           if (!activation_status_test_) {
             if (network->failed_or_disconnected()) {
               activation_status_test_ = true;
               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);
               // Disconnect will force networks to be reevaluated, so
               // we don't want to continue processing on this path anymore.
+              evaluating_ = false;
               return;
             }
           } else {
-            if (network->connected())
-              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
-            else
+            if (network->connected()) {
+              if (network->restricted_pool())
+                new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+            } else {
               new_state = PLAN_ACTIVATION_RECONNECTING;
+            }
             break;
           }
           break;
         }
         case chromeos::ACTIVATION_STATE_UNKNOWN:
         case chromeos::ACTIVATION_STATE_NOT_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);
             // Disconnect will force networks to be reevaluated, so
             // we don't want to continue processing on this path anymore.
+            evaluating_ = false;
             return;
           }
           break;
         }
-        default: {
-          new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
+        default:
           break;
-        }
       }
       break;
     }
     case PLAN_ACTIVATION_INITIATING_ACTIVATION: {
       switch (network->activation_state()) {
         case chromeos::ACTIVATION_STATE_ACTIVATED:
           if (network->failed_or_disconnected()) {
             new_state = PLAN_ACTIVATION_RECONNECTING;
-          } else if (network->connection_state() == chromeos::STATE_READY) {
+          } else if (network->connected()) {
             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
+          if (network->connected()) {
+            if (network->restricted_pool())
+              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+          } else {
             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_RECONNECTING: {
       // Wait until the service shows up and gets activated.
       switch (network->activation_state()) {
         case chromeos::ACTIVATION_STATE_ACTIVATED:
-          if (network->connection_state() == chromeos::STATE_READY) {
+          if (network->connected()) {
             if (network->restricted_pool()) {
               new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
             } else {
               new_state = PLAN_ACTIVATION_DONE;
             }
+          } else if (network->failed()) {
+            chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
+                ConnectToCellularNetwork(network);
+            evaluating_ = false;
+            return;
           }
           break;
         case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
           if (network->connected()) {
             if (network->restricted_pool())
               new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
           }
           break;
         default:
           break;
@@ skipping 11 matching lines @@
   }
 
   std::string error_description;
   if (GotActivationError(network, &error_description)) {
     // Check for this special case when we try to do activate partially
     // activated device. If that attempt failed, try to disconnect to clear the
     // state and reconnect again.
     if ((network->activation_state() ==
             chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED ||
         network->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATING) &&
-        network->error() == chromeos::ERROR_UNKNOWN &&
+        (network->error() == chromeos::ERROR_UNKNOWN ||
+            network->error() == chromeos::ERROR_OTASP_FAILED)&&
         (state_ == PLAN_ACTIVATION_INITIATING_ACTIVATION ||
             state_ == PLAN_ACTIVATION_RECONNECTING) &&
         activation_status_test_ &&
         network->connection_state() == chromeos::STATE_ACTIVATION_FAILURE) {
       new_state = PLAN_ACTIVATION_RECONNECTING;
     } else {
       new_state = PLAN_ACTIVATION_ERROR;
     }
   }
   ChangeState(network, new_state, error_description);
+  evaluating_ = false;
 }
 
 // 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";
@@ skipping 22 matching lines @@
     network->set_auto_connect(true);
     lib->SaveCellularNetwork(network);
   }
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   // Reactivate other types of connections if we have
   // shut them down previously.
   ReEnableOtherConnections();
 }
 
+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())
+    device_dict.SetString("error", error_description);
+  dom_ui_->CallJavascriptFunction(
+      kJsDeviceStatusChangedHandler, device_dict);
+}
 
 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;
-  DictionaryValue device_dict;
 
   // Signal to JS layer that the state is changing.
-  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);
+  UpdatePage(network, error_description);
 
   // Decide what to do with network object as a result of the new state.
   switch (new_state) {
     case PLAN_ACTIVATION_START:
       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;
+      UMA_HISTOGRAM_COUNTS("Cellular.ActivationTry", 1);
+      if (!network->StartActivation()) {
+        UMA_HISTOGRAM_COUNTS("Cellular.ActivationFailure", 1);
+        ChangeState(network, PLAN_ACTIVATION_ERROR, std::string());
+      }
       break;
     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.
       break;
     case PLAN_ACTIVATION_DONE:
       DCHECK(network);
       CompleteActivation(network);
+      UMA_HISTOGRAM_COUNTS("Cellular.MobileSetupSucceeded", 1);
       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();
@@ skipping 146 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)));
 }