Update activation flow for lte devices not to show 3G loading page.

chrome/browser/chromeos/mobile/mobile_activator.cc

 // Copyright (c) 2012 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/mobile/mobile_activator.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 171 matching lines @@
   iccid_.clear();
   service_path_.clear();
   state_ = PLAN_ACTIVATION_PAGE_LOADING;
   reenable_cert_check_ = false;
   terminated_ = true;
   // Release the previous cellular config and setup a new empty one.
   cellular_config_ = new CellularConfigDocument();
 }
 
 void MobileActivator::OnNetworkManagerChanged(NetworkLibrary* cros) {
-  if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
+  if (state_ == PLAN_ACTIVATION_PAGE_LOADING ||
+      state_ == PLAN_ACTIVATION_DONE ||
+      state_ == PLAN_ACTIVATION_ERROR) {
     return;
-  EvaluateCellularNetwork(FindMatchingCellularNetwork(true));
+  }
+
+  CellularNetwork* network = FindMatchingCellularNetwork(true);
+  if (network->activate_over_non_cellular_network()) {
+    bool waiting = (state_ == PLAN_ACTIVATION_WAITING_FOR_CONNECTION);
+    bool is_online =
+        cros->connected_network() && cros->connected_network()->online();
+    if (waiting && is_online) {
+      ChangeState(network, post_reconnect_state_, "");
+    } else if (!waiting && !is_online) {
+      ChangeState(network, PLAN_ACTIVATION_WAITING_FOR_CONNECTION, "");
+    }
+  }
+
+  EvaluateCellularNetwork(network);
 }
 
 void MobileActivator::OnNetworkChanged(NetworkLibrary* cros,
                                        const Network* network) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
 
   if (!network || network->type() != TYPE_CELLULAR) {
     NOTREACHED();
     return;
@@ skipping 26 matching lines @@
       lib->FindNetworkDeviceByPath(network->device_path());
   if (!device) {
     LOG(ERROR) << "Cellular device can't be found: " << network->device_path();
     return;
   }
 
   terminated_ = false;
   meid_ = device->meid();
   iccid_ = device->iccid();
   service_path_ = service_path;
+
+  ChangeState(network, PLAN_ACTIVATION_PAGE_LOADING, "");
+
   BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE,
       base::Bind(&CellularConfigDocument::LoadCellularConfigFile,
                  cellular_config_.get()),
       base::Bind(&MobileActivator::ContinueActivation, AsWeakPtr()));
 }
 
 void MobileActivator::ContinueActivation() {
   CellularNetwork* network = FindMatchingCellularNetwork(false);
   if (!network || !network->SupportsActivation())
     return;
@@ skipping 20 matching lines @@
   // The payment is received, try to reconnect and check the status all over
   // again.
   if (success && state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
     NetworkLibrary* lib = GetNetworkLibrary();
     lib->SignalCellularPlanPayment();
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentReceived", 1);
     CellularNetwork* network = FindMatchingCellularNetwork(true);
     if (network && network->activate_over_non_cellular_network()) {
       state_ = PLAN_ACTIVATION_DONE;
       network->CompleteActivation();
-      EvaluateCellularNetwork(network);
     } else {
       StartOTASP();
     }
   } else {
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentFailed", 1);
   }
 }
 
 void MobileActivator::OnPortalLoaded(bool success) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&MobileActivator::HandlePortalLoaded,
                  AsWeakPtr(), success));
 }
 
 void MobileActivator::HandlePortalLoaded(bool success) {
   CellularNetwork* network = FindMatchingCellularNetwork(true);
   if (!network) {
     ChangeState(NULL, PLAN_ACTIVATION_ERROR,
                 GetErrorMessage(kErrorNoService));
     return;
   }
   if (state_ == PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING ||
       state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
     if (success) {
       payment_reconnect_count_ = 0;
       ChangeState(network, PLAN_ACTIVATION_SHOWING_PAYMENT, std::string());
     } else {
+      // There is no point in forcing reconnecting the cellular network if the
+      // activation should not be done over it.
+      if (network->activate_over_non_cellular_network())
+        return;
+
       payment_reconnect_count_++;
       if (payment_reconnect_count_ > kMaxPortalReconnectCount) {
         ChangeState(NULL, PLAN_ACTIVATION_ERROR,
                     GetErrorMessage(kErrorNoService));
         return;
       }
 
       // Reconnect and try and load the frame again.
       ChangeState(network,
                   PLAN_ACTIVATION_RECONNECTING,
@@ skipping 56 matching lines @@
   // Start monitoring network property changes.
   lib->AddNetworkManagerObserver(this);
   if (network->activate_over_non_cellular_network()) {
     // Fast forward to payment portal loading if the activation is performed
     // over a non-cellular network.
     ChangeState(network,
                 (network->activation_state() == ACTIVATION_STATE_ACTIVATED) ?
                 PLAN_ACTIVATION_DONE :
                 PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING,
                 "");
-  } else if (lib->HasRecentCellularPlanPayment() &&
-             network->activation_state() ==
-                 ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
+    // Verify that there is no need to wait for the connection. This will also
+    // evaluate the network.
+    OnNetworkManagerChanged(lib);
+    return;
+  }
+
+  if (lib->HasRecentCellularPlanPayment() &&
+      network->activation_state() == ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
     // Try to start with OTASP immediately if we have received payment recently.
     state_ = PLAN_ACTIVATION_START_OTASP;
   } else {
     state_ =  PLAN_ACTIVATION_START;
   }
 
   EvaluateCellularNetwork(network);
 }
 
 void MobileActivator::RetryOTASP() {
@@ skipping 114 matching lines @@
     return;
   }
 
   LOG(WARNING) << "Cellular:\n  service=" << network->GetStateString()
       << "\n  ui=" << GetStateDescription(state_)
       << "\n  activation=" << network->GetActivationStateString()
       << "\n  error=" << network->GetErrorString()
       << "\n  setvice_path=" << network->service_path()
       << "\n  connected=" << network->connected();
 
+  // If the network is activated over non cellular network, the activator state
+  // does not depend on the network's own state.
+  if (network->activate_over_non_cellular_network())
+    return;
+
   std::string error_description;
   PlanActivationState new_state = PickNextState(network, &error_description);
 
   ChangeState(network, new_state, error_description);
 }
 
 MobileActivator::PlanActivationState MobileActivator::PickNextState(
     CellularNetwork* network, std::string* error_description) const {
   PlanActivationState new_state = state_;
   if (!network->connected())
@@ skipping 150 matching lines @@
         new_state = PLAN_ACTIVATION_DONE;
       else
         new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
       break;
     // Initial state
     case PLAN_ACTIVATION_PAGE_LOADING:
       break;
     // Just ignore all signals until the site confirms payment.
     case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
+    case PLAN_ACTIVATION_WAITING_FOR_CONNECTION:
       break;
     // Go where we decided earlier.
     case PLAN_ACTIVATION_RECONNECTING:
       new_state = post_reconnect_state_;
       break;
     // Activation completed/failed, ignore network changes.
     case PLAN_ACTIVATION_DONE:
     case PLAN_ACTIVATION_ERROR:
       break;
   }
@@ skipping 23 matching lines @@
     case PLAN_ACTIVATION_START_OTASP:
       return "START_OTASP";
     case PLAN_ACTIVATION_OTASP:
       return "OTASP";
     case PLAN_ACTIVATION_DONE:
       return "DONE";
     case PLAN_ACTIVATION_ERROR:
       return "ERROR";
     case PLAN_ACTIVATION_RECONNECTING:
       return "RECONNECTING";
+    case PLAN_ACTIVATION_WAITING_FOR_CONNECTION:
+      return "WAITING FOR CONNECTION";
   }
   return "UNKNOWN";
 }
 
 
 void MobileActivator::CompleteActivation(
     CellularNetwork* network) {
   // Remove observers, we are done with this page.
   NetworkLibrary* lib = GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
@@ skipping 68 matching lines @@
       }
       break;
     case PLAN_ACTIVATION_PAGE_LOADING:
       return;
     case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
     case PLAN_ACTIVATION_RECONNECTING_PAYMENT:
       // Fix for fix SSL for the walled gardens where cert chain verification
       // might not work.
       break;
+    case PLAN_ACTIVATION_WAITING_FOR_CONNECTION:
+      post_reconnect_state_ = old_state;
+      break;
     case PLAN_ACTIVATION_RECONNECTING: {
       PlanActivationState next_state = old_state;
       // Pick where we want to return to after we reconnect.
       switch (old_state) {
         case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
         case PLAN_ACTIVATION_SHOWING_PAYMENT:
           // We decide here what to do next based on the state of the modem.
           next_state = PLAN_ACTIVATION_RECONNECTING_PAYMENT;
           break;
         case PLAN_ACTIVATION_INITIATING_ACTIVATION:
@@ skipping 118 matching lines @@
 
 std::string MobileActivator::GetErrorMessage(const std::string& code) const {
   return cellular_config_->GetErrorMessage(code);
 }
 
 NetworkLibrary* MobileActivator::GetNetworkLibrary() const {
   return CrosLibrary::Get()->GetNetworkLibrary();
 }
 
 }  // namespace chromeos