Added logic that will retry to reload+reconnect the mobile payment portal page 5 times before it ...

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 13 matching lines @@
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
+#include "content/browser/renderer_host/render_view_host_observer.h"
 #include "content/browser/tab_contents/tab_contents.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 "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
 // Host page JS API function names.
 const char kJsApiStartActivation[] = "startActivation";
 const char kJsApiSetTransactionStatus[] = "setTransactionStatus";
+const char kJsApiPaymentPortalLoad[] = "paymentPortalLoad";
+const char kJsApiResultOK[] = "ok";
 
-const char kJsDeviceStatusChangedHandler[] =
+const char kJsDeviceStatusChangedCallback[] =
     "mobile.MobileSetup.deviceStateChanged";
+const char kJsPortalFrameLoadFailedCallback[] =
+    "mobile.MobileSetup.portalFrameLoadError";
+const char kJsPortalFrameLoadCompletedCallback[] =
+    "mobile.MobileSetup.portalFrameLoadCompleted";
 
 // 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 kErrorDisabled[] = "disabled";
 const char kErrorNoDevice[] = "no_device";
 const char kFailedPaymentError[] = "failed_payment";
 const char kFailedConnectivity[] = "connectivity";
 const char kErrorAlreadyRunning[] = "already_running";
 
 // 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 restart the activation process in case
 // there is no connectivity in the restricted pool.
 const int kMaxActivationAttempt = 3;
 // Number of times we will retry to reconnect if connection fails.
 const int kMaxConnectionRetry = 10;
+// Number of times we will retry to reconnect and reload payment portal page.
+const int kMaxPortalReconnectCount = 5;
 // Number of times we will retry to reconnect if connection fails.
 const int kMaxConnectionRetryOTASP = 30;
 // Number of times we will retry to reconnect after payment is processed.
 const int kMaxReconnectAttemptOTASP = 30;
 // Reconnect retry delay (after payment is processed).
 const int kPostPaymentReconnectDelayMS = 30000;   // 30s.
 // Connection timeout in seconds.
 const int kConnectionTimeoutSeconds = 45;
 // Reconnect delay.
 const int kReconnectDelayMS = 3000;
@@ skipping 14 matching lines @@
 }
 
 chromeos::CellularNetwork* GetCellularNetwork(
     const std::string& service_path) {
   return chromeos::CrosLibrary::Get()->
       GetNetworkLibrary()->FindCellularNetworkByPath(service_path);
 }
 
 }  // namespace
 
+// Observes IPC messages from the rederer and notifies JS if frame loading error
+// appears.
+class PortalFrameLoadObserver : public RenderViewHostObserver {
+ public:
+  PortalFrameLoadObserver(RenderViewHost* host, WebUI* webui)
+      : RenderViewHostObserver(host), webui_(webui) {
+    DCHECK(webui_);
+    Send(new ChromeViewMsg_StartFrameSniffer(routing_id(),
+                                             UTF8ToUTF16("paymentForm")));
+  }
+
+  virtual ~PortalFrameLoadObserver() {}
+
+  // IPC::Channel::Listener implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(PortalFrameLoadObserver, message)
+      IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FrameLoadingError, OnFrameLoadError)
+      IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FrameLoadingCompleted,
+                          OnFrameLoadCompleted)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+ private:
+  void OnFrameLoadError(int error) {
+    base::FundamentalValue result_value(error);
+    webui_->CallJavascriptFunction(
+        kJsPortalFrameLoadFailedCallback, result_value);
+  }
+
+  void OnFrameLoadCompleted() {
+    webui_->CallJavascriptFunction(kJsPortalFrameLoadCompletedCallback);
+  }
+
+  WebUI* webui_;
+  DISALLOW_COPY_AND_ASSIGN(PortalFrameLoadObserver);
+};
+
 class CellularConfigDocument {
  public:
   CellularConfigDocument() {}
 
   // Return error message for a given code.
   std::string GetErrorMessage(const std::string& code);
   const std::string& version() { return version_; }
 
   bool LoadFromFile(const FilePath& config_path);
 
@@ skipping 50 matching lines @@
                                 const chromeos::Network* network) OVERRIDE;
 
  private:
   typedef enum PlanActivationState {
     PLAN_ACTIVATION_PAGE_LOADING            = -1,
     PLAN_ACTIVATION_START                   = 0,
     PLAN_ACTIVATION_TRYING_OTASP            = 1,
     PLAN_ACTIVATION_RECONNECTING_OTASP_TRY  = 2,
     PLAN_ACTIVATION_INITIATING_ACTIVATION   = 3,
     PLAN_ACTIVATION_RECONNECTING            = 4,
-    PLAN_ACTIVATION_SHOWING_PAYMENT         = 5,
-    PLAN_ACTIVATION_DELAY_OTASP             = 6,
-    PLAN_ACTIVATION_START_OTASP             = 7,
-    PLAN_ACTIVATION_OTASP                   = 8,
-    PLAN_ACTIVATION_RECONNECTING_OTASP      = 9,
-    PLAN_ACTIVATION_DONE                    = 10,
+    PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING  = 5,
+    PLAN_ACTIVATION_SHOWING_PAYMENT         = 6,
+    PLAN_ACTIVATION_RECONNECTING_PAYMENT    = 7,
+    PLAN_ACTIVATION_DELAY_OTASP             = 8,
+    PLAN_ACTIVATION_START_OTASP             = 9,
+    PLAN_ACTIVATION_OTASP                   = 10,
+    PLAN_ACTIVATION_RECONNECTING_OTASP      = 11,
+    PLAN_ACTIVATION_DONE                    = 12,
     PLAN_ACTIVATION_ERROR                   = 0xFF,
   } PlanActivationState;
 
   class TaskProxy : public base::RefCountedThreadSafe<TaskProxy> {
    public:
     TaskProxy(const base::WeakPtr<MobileSetupHandler>& handler, int delay)
         : handler_(handler), delay_(delay) {
     }
     TaskProxy(const base::WeakPtr<MobileSetupHandler>& handler,
               const std::string& status)
@@ skipping 18 matching lines @@
    private:
     base::WeakPtr<MobileSetupHandler> handler_;
     std::string status_;
     int delay_;
     DISALLOW_COPY_AND_ASSIGN(TaskProxy);
   };
 
   // Handlers for JS WebUI messages.
   void HandleSetTransactionStatus(const ListValue* args);
   void HandleStartActivation(const ListValue* args);
+  void HandlePaymentPortalLoad(const ListValue* args);
   void SetTransactionStatus(const std::string& status);
   // Schedules activation process via task proxy.
   void InitiateActivation();
   // Starts activation.
   void StartActivation();
   // Retried OTASP.
   void RetryOTASP();
   // Continues activation process. This method is called after we disconnect
   // due to detected connectivity issue to kick off reconnection.
   void ContinueConnecting(int delay);
@@ skipping 72 matching lines @@
   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_;
   // Activation retry attempt count;
   int activation_attempt_;
   // Connection start time.
   base::Time connection_start_time_;
   // Timer that monitors reconnection timeouts.
   base::RepeatingTimer<MobileSetupHandler> reconnect_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(MobileSetupHandler);
 };
 
@@ skipping 121 matching lines @@
     : 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())
@@ skipping 17 matching lines @@
     already_running_ = true;
 }
 
 void MobileSetupHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback(kJsApiStartActivation,
       base::Bind(&MobileSetupHandler::HandleStartActivation,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback(kJsApiSetTransactionStatus,
       base::Bind(&MobileSetupHandler::HandleSetTransactionStatus,
                  base::Unretained(this)));
+  web_ui_->RegisterMessageCallback(kJsApiPaymentPortalLoad,
+      base::Bind(&MobileSetupHandler::HandlePaymentPortalLoad,
+                 base::Unretained(this)));
 }
 
 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.
@@ skipping 19 matching lines @@
     return;
   // Get change callback function name.
   std::string status;
   if (!args->GetString(0, &status))
     return;
   scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr(), status);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskProxy::HandleSetTransactionStatus, task.get()));
 }
 
+void MobileSetupHandler::HandlePaymentPortalLoad(const ListValue* args) {
+  const size_t kPaymentPortalLoadParamCount = 1;
+  if (args->GetSize() != kPaymentPortalLoadParamCount)
+    return;
+  // Get change callback function name.
+  std::string result;
+  if (!args->GetString(0, &result))
+    return;
+  chromeos::CellularNetwork* network = GetCellularNetwork(service_path_);
+  if (!network) {
+    ChangeState(NULL, PLAN_ACTIVATION_ERROR,
+                GetErrorMessage(kErrorNoService));
+    return;
+  }
+  if (state_ == PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING ||
+      state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
+    if (LowerCaseEqualsASCII(result, kJsApiResultOK)) {
+      payment_reconnect_count_ = 0;
+      ChangeState(network, PLAN_ACTIVATION_SHOWING_PAYMENT, std::string());
+    } else {
+      payment_reconnect_count_++;
+      if (payment_reconnect_count_ > kMaxPortalReconnectCount) {
+        ChangeState(NULL, PLAN_ACTIVATION_ERROR,
+                    GetErrorMessage(kErrorNoService));
+        return;
+      }
+      // Disconnect now, this should force reconnection and we will retry to
+      // load the frame containing payment portal again.
+      DisconnectFromNetwork(network);
+    }
+  } else {
+    NOTREACHED() << "Called paymentPortalLoad while in unexpected state: "
+                 << GetStateDescription(state_);
+  }
+}
+
 void MobileSetupHandler::InitiateActivation() {
   scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr(), 0);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskProxy::HandleStartActivation, task.get()));
 }
 
 void MobileSetupHandler::StartActivation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
@@ skipping 37 matching lines @@
     EvaluateCellularNetwork(network);
   } else {
     ConnectToNetwork(network, delay);
   }
 }
 
 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") &&
+  if (LowerCaseEqualsASCII(status, kJsApiResultOK) &&
       state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
     chromeos::NetworkLibrary* lib =
         chromeos::CrosLibrary::Get()->GetNetworkLibrary();
     lib->SignalCellularPlanPayment();
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentReceived", 1);
     StartOTASP();
   } else {
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentFailed", 1);
   }
 }
 
 void MobileSetupHandler::StartOTASP() {
   state_ = PLAN_ACTIVATION_START_OTASP;
   chromeos::CellularNetwork* network = GetCellularNetwork();
   if (network &&
       network->connected() &&
       network->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATED) {
     chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
         DisconnectFromNetwork(network);
   } else {
     EvaluateCellularNetwork(network);
   }
 }
 
 void MobileSetupHandler::ReconnectTimerFired() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Permit network connection changes only in reconnecting states.
   if (state_ != PLAN_ACTIVATION_RECONNECTING_OTASP_TRY &&
       state_ != PLAN_ACTIVATION_RECONNECTING &&
+      state_ != PLAN_ACTIVATION_RECONNECTING_PAYMENT &&
       state_ != PLAN_ACTIVATION_RECONNECTING_OTASP)
     return;
   chromeos::CellularNetwork* network = GetCellularNetwork(service_path_);
   if (!network) {
     // No service, try again since this is probably just transient condition.
     LOG(WARNING) << "Service not present at reconnect attempt.";
   }
   EvaluateCellularNetwork(network);
 }
 
@@ skipping 33 matching lines @@
 }
 
 bool MobileSetupHandler::ConnectToNetwork(
     chromeos::CellularNetwork* network,
     int delay) {
   if (network && network->connecting_or_connected())
     return true;
   // Permit network connection changes only in reconnecting states.
   if (state_ != PLAN_ACTIVATION_RECONNECTING_OTASP_TRY &&
       state_ != PLAN_ACTIVATION_RECONNECTING &&
+      state_ != PLAN_ACTIVATION_RECONNECTING_PAYMENT &&
       state_ != PLAN_ACTIVATION_RECONNECTING_OTASP)
     return false;
   if (network)
     LOG(INFO) << "Connecting to: " << network->service_path();
   connection_retry_count_++;
   connection_start_time_ = base::Time::Now();
   if (!network) {
     LOG(WARNING) << "Connect failed."
                  << (network ? network->service_path().c_str() : "no service");
     // If we coudn't connect during reconnection phase, try to reconnect
@@ skipping 36 matching lines @@
 void MobileSetupHandler::EvaluateCellularNetwork(
     chromeos::CellularNetwork* network) {
   if (!web_ui_)
     return;
 
   PlanActivationState new_state = state_;
   if (!network) {
     LOG(WARNING) << "Cellular service lost";
     if (state_ == PLAN_ACTIVATION_RECONNECTING_OTASP_TRY ||
         state_ == PLAN_ACTIVATION_RECONNECTING ||
+        state_ == PLAN_ACTIVATION_RECONNECTING_PAYMENT ||
         state_ == PLAN_ACTIVATION_RECONNECTING_OTASP) {
       // This might be the legit case when service is lost after activation.
       // We need to make sure we force reconnection as soon as it shows up.
       LOG(INFO) << "Force service reconnection";
       connection_start_time_ = base::Time();
     }
     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;
   std::string error_description;
 
   LOG(WARNING) << "Cellular:\n  service=" << network->GetStateString().c_str()
       << "\n  ui=" << GetStateDescription(state_)
       << "\n  activation=" << network->GetActivationStateString().c_str()
       << "\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->disconnected()) {
             new_state = PLAN_ACTIVATION_RECONNECTING;
           } else if (network->connected()) {
             if (network->restricted_pool()) {
-              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+              new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
             } else {
               new_state = PLAN_ACTIVATION_DONE;
             }
           }
           break;
         }
         default: {
           if (network->disconnected() ||
               network->state() == chromeos::STATE_ACTIVATION_FAILURE) {
             new_state = (network->activation_state() ==
@@ skipping 37 matching lines @@
       return;
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
     case PLAN_ACTIVATION_OTASP:
     case PLAN_ACTIVATION_TRYING_OTASP: {
       switch (network->activation_state()) {
         case chromeos::ACTIVATION_STATE_ACTIVATED:
           if (network->disconnected()) {
             new_state = GetNextReconnectState(state_);
           } else if (network->connected()) {
             if (network->restricted_pool()) {
-              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+              new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
             } else {
               new_state = PLAN_ACTIVATION_DONE;
             }
           }
           break;
         case chromeos::ACTIVATION_STATE_PARTIALLY_ACTIVATED:
           if (network->connected()) {
             if (network->restricted_pool())
-              new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+              new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
           } else {
             new_state = GetNextReconnectState(state_);
           }
           break;
         case chromeos::ACTIVATION_STATE_NOT_ACTIVATED:
         case chromeos::ACTIVATION_STATE_ACTIVATING:
           // Wait in this state until activation state changes.
           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()) {
@@ skipping 11 matching lines @@
                   return;
                 } else {
                   new_state = PLAN_ACTIVATION_ERROR;
                   UMA_HISTOGRAM_COUNTS("Cellular.ActivationRetryFailure", 1);
                   error_description = GetErrorMessage(kFailedConnectivity);
                 }
               } else {
                 // If we have already received payment, don't show the payment
                 // page again. We should try to reconnect after some
                 // time instead.
-                new_state = PLAN_ACTIVATION_SHOWING_PAYMENT;
+                new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
               }
             } else if (network->activation_state() ==
                            chromeos::ACTIVATION_STATE_ACTIVATED) {
               new_state = PLAN_ACTIVATION_DONE;
             }
             break;
           default:
             break;
         }
       } else if (NeedsReconnecting(network, &new_state, &error_description)) {
@@ skipping 37 matching lines @@
         }
       } else if (NeedsReconnecting(network, &new_state, &error_description)) {
         evaluating_ = false;
         return;
       }
       break;
     }
     case PLAN_ACTIVATION_PAGE_LOADING:
       break;
     // Just ignore all signals until the site confirms payment.
-    case PLAN_ACTIVATION_SHOWING_PAYMENT:
+    case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
+    case PLAN_ACTIVATION_SHOWING_PAYMENT: {
+      if (network->disconnected())
+        new_state = PLAN_ACTIVATION_RECONNECTING_PAYMENT;
+      break;
+    }
       // Activation completed/failed, ignore network changes.
     case PLAN_ACTIVATION_DONE:
     case PLAN_ACTIVATION_ERROR:
       break;
   }
 
   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
@@ skipping 69 matching lines @@
     case PLAN_ACTIVATION_START:
       return "ACTIVATION_START";
     case PLAN_ACTIVATION_TRYING_OTASP:
       return "TRYING_OTASP";
     case PLAN_ACTIVATION_RECONNECTING_OTASP_TRY:
       return "RECONNECTING_OTASP_TRY";
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
       return "INITIATING_ACTIVATION";
     case PLAN_ACTIVATION_RECONNECTING:
       return "RECONNECTING";
+    case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
+      return "PAYMENT_PORTAL_LOADING";
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
       return "SHOWING_PAYMENT";
+    case PLAN_ACTIVATION_RECONNECTING_PAYMENT:
+      return "RECONNECTING_PAYMENT";
     case PLAN_ACTIVATION_START_OTASP:
       return "START_OTASP";
     case PLAN_ACTIVATION_DELAY_OTASP:
       return "DELAY_OTASP";
     case PLAN_ACTIVATION_OTASP:
       return "OTASP";
     case PLAN_ACTIVATION_RECONNECTING_OTASP:
       return "RECONNECTING_OTASP";
     case PLAN_ACTIVATION_DONE:
       return "DONE";
@@ skipping 24 matching lines @@
 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);
   web_ui_->CallJavascriptFunction(
-      kJsDeviceStatusChangedHandler, device_dict);
+      kJsDeviceStatusChangedCallback, 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(WARNING) << "Activation state flip old = "
@@ skipping 40 matching lines @@
         if (new_state == PLAN_ACTIVATION_OTASP) {
           ChangeState(network, PLAN_ACTIVATION_DELAY_OTASP, std::string());
         } else {
           ChangeState(network, PLAN_ACTIVATION_ERROR,
                       GetErrorMessage(kFailedConnectivity));
         }
       }
       break;
     case PLAN_ACTIVATION_RECONNECTING_OTASP_TRY:
     case PLAN_ACTIVATION_RECONNECTING:
+    case PLAN_ACTIVATION_RECONNECTING_PAYMENT:
     case PLAN_ACTIVATION_RECONNECTING_OTASP: {
       // Start reconnect timer. This will ensure that we are not left in
       // limbo by the network library.
       if (!reconnect_timer_.IsRunning()) {
         reconnect_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(kReconnectTimerDelayMS),
             this, &MobileSetupHandler::ReconnectTimerFired);
       }
       // Reset connection metrics and try to connect.
       reconnect_wait_count_ = 0;
       connection_retry_count_ = 0;
       connection_start_time_ = base::Time::Now();
       ConnectToNetwork(network, kReconnectDelayMS);
       break;
     }
     case PLAN_ACTIVATION_PAGE_LOADING:
       return;
+    case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
     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:
@@ skipping 176 matching lines @@
   MobileSetupHandler* handler = new MobileSetupHandler(service_path);
   AddMessageHandler((handler)->Attach(this));
   handler->Init(contents);
   MobileSetupUIHTMLSource* html_source =
       new MobileSetupUIHTMLSource(service_path);
 
   // 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());
+}