Added [Close] button on completed activation overlay div....

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>
 
@@ skipping 51 matching lines @@
 const char kFailedPaymentError[] = "failed_payment";
 
 // Cellular configuration file path.
 const char kCellularConfigPath[] =
     "/usr/share/chromeos-assets/mobile/mobile_config.json";
 
 // Cellular config file field names.
 const char kVersionField[] = "version";
 const char kErrorsField[] = "errors";
 
+// Number of times we will retry to reconnect if connection fails.
+const int kMaxConnectionRetry = 10;
+// Connection timeout in seconds.
+const int kConnectionTimeoutSeconds = 30;
+
 chromeos::CellularNetwork* GetCellularNetwork() {
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
   if (lib->cellular_networks().begin() != lib->cellular_networks().end()) {
     return *(lib->cellular_networks().begin());
   }
   return NULL;
 }
 
 chromeos::CellularNetwork* GetCellularNetwork(const std::string& service_path) {
@@ skipping 101 matching lines @@
 
   // Handlers for JS DOMUI messages.
   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();
 
+  // Connects to cellular network, resets connection timer.
+  void ConnectToNetwork(chromeos::CellularNetwork* network);
+  // Reports connection timeout.
+  bool ConnectionTimeout();
   // 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,
@@ skipping 33 matching lines @@
   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_;
+  // Connection retry counter.
+  int connection_retry_count_;
+  // Connection start time.
+  base::Time connection_start_time_;
   DISALLOW_COPY_AND_ASSIGN(MobileSetupHandler);
 };
 
 scoped_ptr<CellularConfigDocument> MobileSetupHandler::cellular_config_;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // CellularConfigDocument
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 65 matching lines @@
                     l10n_util::GetStringFUTF16(IDS_MOBILE_CONNECTING_HEADER,
                         network ? UTF8ToUTF16(network->name()) : string16()));
   strings.SetString("error_header",
                     l10n_util::GetStringUTF16(IDS_MOBILE_ERROR_HEADER));
   strings.SetString("activating_header",
                     l10n_util::GetStringUTF16(IDS_MOBILE_ACTIVATING_HEADER));
   strings.SetString("completed_header",
                     l10n_util::GetStringUTF16(IDS_MOBILE_COMPLETED_HEADER));
   strings.SetString("completed_text",
                     l10n_util::GetStringUTF16(IDS_MOBILE_COMPLETED_TEXT));
+  strings.SetString("close_button",
+                    l10n_util::GetStringUTF16(IDS_CLOSE));
   SetFontAndTextDirection(&strings);
 
   static const base::StringPiece html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_MOBILE_SETUP_PAGE_HTML));
   const std::string full_html = jstemplate_builder::GetTemplatesHtml(
       html, &strings, "t" /* template root node id */);
 
   scoped_refptr<RefCountedBytes> html_bytes(new RefCountedBytes);
   html_bytes->data.resize(full_html.size());
   std::copy(full_html.begin(), full_html.end(), html_bytes->data.begin());
 
   SendResponse(request_id, html_bytes);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // 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_cert_check_(false),
       transaction_complete_signalled_(false),
       activation_status_test_(false),
-      evaluating_(false) {
+      evaluating_(false),
+      connection_retry_count_(0) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   ReEnableOtherConnections();
 }
 
@@ skipping 92 matching lines @@
       chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
           DisconnectFromWirelessNetwork(network);
     } else {
       EvaluateCellularNetwork(network);
     }
   } else {
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentFailed", 1);
   }
 }
 
+
+void MobileSetupHandler::ConnectToNetwork(chromeos::CellularNetwork* network) {
+  connection_retry_count_++;
+  connection_start_time_ = base::Time::Now();
+  chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
+      ConnectToCellularNetwork(network);
+}
+
+bool MobileSetupHandler::ConnectionTimeout() {
+  return (base::Time::Now() -
+            connection_start_time_).InSeconds() > kConnectionTimeoutSeconds;
+}
+
 void MobileSetupHandler::EvaluateCellularNetwork(
     chromeos::CellularNetwork* network) {
   if (!dom_ui_)
     return;
 
   PlanActivationState new_state = state_;
   if (!network) {
     LOG(WARNING) << "Cellular service lost";
     return;
   }
@@ skipping 97 matching lines @@
           // 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->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->connected()) {
+        // Wait until the service shows up and gets activated.
+        switch (network->activation_state()) {
+          case chromeos::ACTIVATION_STATE_ACTIVATED:
             if (network->restricted_pool())
               new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
-          }
-          break;
-        default:
-          break;
+            else
+              new_state = PLAN_ACTIVATION_DONE;
+            break;
+          case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
+            if (network->restricted_pool())
+              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+            break;
+          default:
+            break;
+        }
+      } else if (network->failed() || ConnectionTimeout()) {
+        // Try to reconnect again if reconnect failed, or if for some
+        // reasons we are still not connected after 30 seconds.
+        if (connection_retry_count_ < kMaxConnectionRetry) {
+          UMA_HISTOGRAM_COUNTS("Cellular.ConnectionRetry", 1);
+          ConnectToNetwork(network);
+          evaluating_ = false;
+          return;
+        } else {
+          // We simply can't connect anymore after all these tries.
+          UMA_HISTOGRAM_COUNTS("Cellular.ConnectionFailed", 1);
+          new_state = PLAN_ACTIVATION_ERROR;
+        }
       }
       break;
     }
     case PLAN_ACTIVATION_PAGE_LOADING:
       break;
     // Just ignore all signals until the site confirms payment.
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
       // Activation completed/failed, ignore network changes.
     case PLAN_ACTIVATION_DONE:
     case PLAN_ACTIVATION_ERROR:
       break;
   }
 
   std::string error_description;
-  if (GotActivationError(network, &error_description)) {
+  if (new_state != PLAN_ACTIVATION_ERROR &&
+      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_OTASP_FAILED)&&
         (state_ == PLAN_ACTIVATION_INITIATING_ACTIVATION ||
             state_ == PLAN_ACTIVATION_RECONNECTING) &&
@@ skipping 82 matching lines @@
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
       DCHECK(network);
       LOG(INFO) << "Activating service " << network->service_path().c_str();
       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);
-      }
+      // Reset connection metrics and try to connect.
+      connection_retry_count_ = 0;
+      connection_start_time_ = base::Time::Now();
+      ConnectToNetwork(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);
@@ skipping 162 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)));
 }