Switch over MobileActivator to use Network*Handler

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>
 
 #include "ash/system/chromeos/network/network_connect.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/network/device_state.h"
+#include "chromeos/network/network_activation_handler.h"
+#include "chromeos/network/network_configuration_handler.h"
+#include "chromeos/network/network_connection_handler.h"
+#include "chromeos/network/network_event_log.h"
+#include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Cellular configuration file path.
 const char kCellularConfigPath[] =
     "/usr/share/chromeos-assets/mobile/mobile_config.json";
 
 // Cellular config file field names.
@@ skipping 116 matching lines @@
 
 MobileActivator::~MobileActivator() {
   TerminateActivation();
 }
 
 MobileActivator* MobileActivator::GetInstance() {
   return Singleton<MobileActivator>::get();
 }
 
 void MobileActivator::TerminateActivation() {
-  // We're exiting; don't continue with termination.
-  if (!NetworkLibrary::Get())
-    return;
-
   state_duration_timer_.Stop();
   continue_reconnect_timer_.Stop();
   reconnect_timeout_timer_.Stop();
 
-  NetworkLibrary* lib = GetNetworkLibrary();
-  lib->RemoveNetworkManagerObserver(this);
-  lib->RemoveObserverForAllNetworks(this);
+  if (NetworkHandler::IsInitialized())
+    NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
+                                                                   FROM_HERE);
   ReEnableCertRevocationChecking();
   meid_.clear();
   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) {
+void MobileActivator::NetworkManagerChanged() {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING ||
       state_ == PLAN_ACTIVATION_DONE ||
       state_ == PLAN_ACTIVATION_ERROR) {
     return;
   }
 
-  CellularNetwork* network = FindMatchingCellularNetwork(true);
-  if (network && network->activate_over_non_cellular_network()) {
+  NetworkStateHandler* nsh = NetworkHandler::Get()->network_state_handler();
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
+  if (network && network->activate_over_non_cellular_networks()) {
     bool waiting = (state_ == PLAN_ACTIVATION_WAITING_FOR_CONNECTION);
-    bool is_online =
-        cros->connected_network() && cros->connected_network()->online();
+    bool is_online = nsh->DefaultNetwork() &&
+        nsh->DefaultNetwork()->connection_state() == flimflam::kStateOnline;
     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) {
+void MobileActivator::DefaultNetworkChanged(const NetworkState* network) {
+  NetworkManagerChanged();
+}
+
+void MobileActivator::NetworkPropertiesUpdated(const NetworkState* network) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
 
-  if (!network || network->type() != TYPE_CELLULAR) {
-    NOTREACHED();
+  if (!network || network->type() != flimflam::kTypeCellular)
+    return;
+  if (network->path() != service_path_) {
+    LOG(WARNING) << "Ignoring property update for unknown cellular service "
+                 << network->path() << " (Expected " << service_path_<< ")";
     return;
   }
 
-  EvaluateCellularNetwork(
-      static_cast<CellularNetwork*>(const_cast<Network*>(network)));
+  EvaluateCellularNetwork(network);
 }
 
 void MobileActivator::AddObserver(MobileActivator::Observer* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void MobileActivator::RemoveObserver(MobileActivator::Observer* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
 void MobileActivator::InitiateActivation(const std::string& service_path) {
   DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::UI));
-  NetworkLibrary* lib = GetNetworkLibrary();
-  CellularNetwork* network = lib->FindCellularNetworkByPath(service_path);
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path);
   if (!network) {
     LOG(ERROR) << "Cellular service can't be found: " << service_path;
     return;
   }
 
-  const chromeos::NetworkDevice* device =
-      lib->FindNetworkDeviceByPath(network->device_path());
+  const DeviceState* device = NetworkHandler::Get()->network_state_handler()->
+      GetDeviceState(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())
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
+  if (!network ||
+      (network->payment_url().empty() && network->usage_url().empty()))
     return;
 
   DisableCertRevocationChecking();
-  // We want shill to connect us after activations.
-  network->SetAutoConnect(true);
 
+  // We want shill to connect us after activations, so enable autoconnect.
+  DictionaryValue auto_connect_property;
+  auto_connect_property.SetBoolean(flimflam::kAutoConnectProperty, true);
+  NetworkHandler::Get()->network_configuration_handler()->SetProperties(
+      network->path(),
+      auto_connect_property,
+      base::Bind(&base::DoNothing),
+      network_handler::ErrorCallback());
   StartActivation();
 }
 
 void MobileActivator::OnSetTransactionStatus(bool success) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&MobileActivator::HandleSetTransactionStatus,
                  AsWeakPtr(), success));
 }
 
 void MobileActivator::HandleSetTransactionStatus(bool success) {
   // 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();
+    SignalCellularPlanPayment();
     UMA_HISTOGRAM_COUNTS("Cellular.PaymentReceived", 1);
-    CellularNetwork* network = FindMatchingCellularNetwork(true);
-    if (network && network->activate_over_non_cellular_network()) {
+    const NetworkState* network =
+        NetworkHandler::Get()->network_state_handler()->GetNetworkState(
+            service_path_);
+    if (network && network->activate_over_non_cellular_networks()) {
       state_ = PLAN_ACTIVATION_DONE;
-      network->CompleteActivation();
+      NetworkHandler::Get()->network_activation_handler()->
+          CompleteActivation(network->path(),
+                             base::Bind(&base::DoNothing),
+                             network_handler::ErrorCallback());
     } 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);
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(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 (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())
+      if (network->activate_over_non_cellular_networks())
         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,
                   GetErrorMessage(kFailedPaymentError));
     }
   } else {
     NOTREACHED() << "Called paymentPortalLoad while in unexpected state: "
                  << GetStateDescription(state_);
   }
 }
 
-CellularNetwork* MobileActivator::FindMatchingCellularNetwork(
-    bool reattach_observer) {
-  NetworkLibrary* lib = GetNetworkLibrary();
-  for (CellularNetworkVector::const_iterator it =
-           lib->cellular_networks().begin();
-       it != lib->cellular_networks().end(); ++it) {
-    const chromeos::NetworkDevice* device =
-        lib->FindNetworkDeviceByPath((*it)->device_path());
-    if (device && ((!meid_.empty() && meid_ == device->meid()) ||
-                   (!iccid_.empty() && iccid_ == device->iccid()))) {
-      CellularNetwork* network = *it;
-      // If service path has changed, reattach the event observer for this
-      // network service.
-      if (reattach_observer && service_path_ != network->service_path()) {
-        lib->RemoveObserverForAllNetworks(this);
-        lib->AddNetworkObserver(network->service_path(), this);
-        service_path_ = network->service_path();
-      }
-      return network;
-    }
-  }
-  return NULL;
-}
-
 void MobileActivator::StartOTASPTimer() {
   state_duration_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kOTASPRetryDelay),
       this, &MobileActivator::HandleOTASPTimeout);
 }
 
 void MobileActivator::StartActivation() {
   UMA_HISTOGRAM_COUNTS("Cellular.MobileSetupStart", 1);
-  NetworkLibrary* lib = GetNetworkLibrary();
-  CellularNetwork* network = FindMatchingCellularNetwork(true);
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
   // Check if we can start activation process.
   if (!network) {
+    NetworkStateHandler::TechnologyState technology_state =
+        NetworkHandler::Get()->network_state_handler()->GetTechnologyState(
+            flimflam::kTypeCellular);
     std::string error;
-    if (!lib->cellular_available())
+    if (technology_state == NetworkStateHandler::TECHNOLOGY_UNAVAILABLE) {
       error = kErrorNoDevice;
-    else if (!lib->cellular_enabled())
+    } else if (technology_state !=NetworkStateHandler::TECHNOLOGY_ENABLED) {
       error = kErrorDisabled;
-    else
+    } else {
       error = kErrorNoService;
+    }
     ChangeState(NULL, PLAN_ACTIVATION_ERROR, GetErrorMessage(error));
     return;
   }
 
   // Start monitoring network property changes.
-  lib->AddNetworkManagerObserver(this);
-  if (network->activate_over_non_cellular_network()) {
+  NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
+  if (network->activate_over_non_cellular_networks()) {
     // 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,
-                "");
+    ChangeState(
+        network,
+        (network->activation_state() == flimflam::kActivationStateActivated) ?
+        PLAN_ACTIVATION_DONE :
+        PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING,
+        "");
     // Verify that there is no need to wait for the connection. This will also
     // evaluate the network.
-    OnNetworkManagerChanged(lib);
+    NetworkManagerChanged();
     return;
   }
 
-  if (lib->HasRecentCellularPlanPayment() &&
-      network->activation_state() == ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
+  if (HasRecentCellularPlanPayment() &&
+      (network->activation_state() ==
+       flimflam::kActivationStatePartiallyActivated)) {
     // 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() {
   DCHECK(state_ == PLAN_ACTIVATION_DELAY_OTASP);
   StartOTASP();
 }
 
 void MobileActivator::StartOTASP() {
-  CellularNetwork* network = FindMatchingCellularNetwork(true);
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
   ChangeState(network, PLAN_ACTIVATION_START_OTASP, std::string());
   EvaluateCellularNetwork(network);
 }
 
 void MobileActivator::HandleOTASPTimeout() {
   LOG(WARNING) << "OTASP seems to be taking too long.";
-  CellularNetwork* network = FindMatchingCellularNetwork(true);
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
   // We're here because one of OTASP steps is taking too long to complete.
   // Usually, this means something bad has happened below us.
   if (state_ == PLAN_ACTIVATION_INITIATING_ACTIVATION) {
     ++initial_OTASP_attempts_;
     if (initial_OTASP_attempts_ <= kMaxOTASPTries) {
       ChangeState(network,
                   PLAN_ACTIVATION_RECONNECTING,
                   GetErrorMessage(kErrorDefault));
       return;
     }
@@ skipping 16 matching lines @@
     }
   } else {
     LOG(ERROR) << "OTASP timed out from a non-OTASP wait state?";
   }
   LOG(ERROR) << "OTASP failed too many times; aborting.";
   ChangeState(network,
               PLAN_ACTIVATION_ERROR,
               GetErrorMessage(kErrorDefault));
 }
 
-void MobileActivator::ForceReconnect(CellularNetwork* network,
+void MobileActivator::ForceReconnect(const NetworkState* network,
                                      PlanActivationState next_state) {
   DCHECK(network);
   // Store away our next destination for when we complete.
   post_reconnect_state_ = next_state;
   UMA_HISTOGRAM_COUNTS("Cellular.ActivationRetry", 1);
   // First, disconnect...
-  LOG(INFO) << "Disconnecting from " << network->service_path();
+  LOG(INFO) << "Disconnecting from " << network->path();
   // Explicit service Disconnect()s disable autoconnect on the service until
   // Connect() is called on the service again.  Hence this dance to explicitly
   // call Connect().
-  GetNetworkLibrary()->DisconnectFromNetwork(network);
+  NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
+      network->path(),
+      base::Bind(&base::DoNothing),
+      network_handler::ErrorCallback());
   // Keep trying to connect until told otherwise.
   continue_reconnect_timer_.Stop();
   continue_reconnect_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kReconnectDelayMS),
       this, &MobileActivator::ContinueConnecting);
   // If we don't ever connect again, we're going to call this a failure.
   reconnect_timeout_timer_.Stop();
   reconnect_timeout_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kMaxReconnectTime),
       this, &MobileActivator::ReconnectTimedOut);
 }
 
 void MobileActivator::ReconnectTimedOut() {
   LOG(ERROR) << "Ending activation attempt after failing to reconnect.";
-  ChangeState(FindMatchingCellularNetwork(true),
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
+  ChangeState(network,
               PLAN_ACTIVATION_ERROR,
               GetErrorMessage(kFailedConnectivity));
 }
 
 void MobileActivator::ContinueConnecting() {
-  CellularNetwork* network = FindMatchingCellularNetwork(true);
-  if (network && network->connected()) {
-    if (network->restricted_pool() &&
-        network->error() == ERROR_DNS_LOOKUP_FAILED) {
+  const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path_);
+  if (network && network->IsConnectedState()) {
+    if (network->connection_state() == flimflam::kStatePortal &&
+        network->error() == flimflam::kErrorDNSLookupFailed) {
       // It isn't an error to be in a restricted pool, but if DNS doesn't work,
       // then we're not getting traffic through at all.  Just disconnect and
       // try again.
-      GetNetworkLibrary()->DisconnectFromNetwork(network);
+      NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
+          network->path(),
+          base::Bind(&base::DoNothing),
+          network_handler::ErrorCallback());
       return;
     }
     // Stop this callback
     continue_reconnect_timer_.Stop();
     EvaluateCellularNetwork(network);
   } else {
     LOG(WARNING) << "Connect failed, will try again in a little bit.";
     if (network) {
-      LOG(INFO) << "Connecting to: " << network->service_path();
+      LOG(INFO) << "Connecting to: " << network->path();
       ash::network_connect::ConnectToNetwork(
-          network->service_path(), NULL /* no parent window */);
+          network->path(), NULL /* no parent window */);
     }
   }
 }
 
-void MobileActivator::EvaluateCellularNetwork(CellularNetwork* network) {
+void MobileActivator::EvaluateCellularNetwork(const NetworkState* network) {
   if (terminated_) {
     LOG(ERROR) << "Tried to run MobileActivator state machine while "
                << "terminated.";
     return;
   }
 
   if (!network) {
     LOG(WARNING) << "Cellular service lost";
     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();
+  LOG(WARNING) << "Cellular:\n  service state=" << network->connection_state()
+               << "\n  ui=" << GetStateDescription(state_)
+               << "\n  activation=" << network->activation_state()
+               << "\n  error=" << network->error()
+               << "\n  setvice_path=" << network->path()
+               << "\n  connected=" << network->IsConnectedState();
 
   // 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())
+  if (network->activate_over_non_cellular_networks())
     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 {
+    const NetworkState* network, std::string* error_description) const {
   PlanActivationState new_state = state_;
-  if (!network->connected())
+  if (!network->IsConnectedState())
     new_state = PickNextOfflineState(network);
   else
     new_state = PickNextOnlineState(network);
   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() == ACTIVATION_STATE_PARTIALLY_ACTIVATED ||
-         network->activation_state() == ACTIVATION_STATE_ACTIVATING) &&
-        (network->error() == ERROR_NO_ERROR ||
-         network->error() == ERROR_OTASP_FAILED) &&
-        network->state() == STATE_ACTIVATION_FAILURE) {
-      LOG(WARNING) << "Activation failure detected "
-                   << network->service_path();
+    const std::string& activation = network->activation_state();
+    bool is_partially_activated =
+        activation == flimflam::kActivationStatePartiallyActivated ||
+        activation == flimflam::kActivationStateActivating;
+    if (is_partially_activated &&
+        (network->error().empty() ||
+         network->error() == flimflam::kErrorOtaspFailed) &&
+        network->connection_state() == flimflam::kStateActivationFailure) {
+      LOG(WARNING) << "Activation failure detected " << network->path();
       switch (state_) {
         case PLAN_ACTIVATION_OTASP:
           new_state = PLAN_ACTIVATION_DELAY_OTASP;
           break;
         case PLAN_ACTIVATION_INITIATING_ACTIVATION:
         case PLAN_ACTIVATION_TRYING_OTASP:
           new_state = PLAN_ACTIVATION_START;
           break;
         case PLAN_ACTIVATION_START:
           // We are just starting, so this must be previous activation attempt
           // failure.
           new_state = PLAN_ACTIVATION_TRYING_OTASP;
           break;
         case PLAN_ACTIVATION_DELAY_OTASP:
           new_state = state_;
           break;
         default:
           new_state = PLAN_ACTIVATION_ERROR;
           break;
       }
     } else {
-      LOG(WARNING) << "Unexpected activation failure for "
-                   << network->service_path();
+      LOG(WARNING) << "Unexpected activation failure for " << network->path();
       new_state = PLAN_ACTIVATION_ERROR;
     }
   }
 
   if (new_state == PLAN_ACTIVATION_ERROR && !error_description->length())
     *error_description = GetErrorMessage(kErrorDefault);
   return new_state;
 }
 
 MobileActivator::PlanActivationState MobileActivator::PickNextOfflineState(
-    CellularNetwork* network) const {
+    const NetworkState* network) const {
   PlanActivationState new_state = state_;
+  const std::string& activation = network->activation_state();
   switch (state_) {
     case PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING:
     case PLAN_ACTIVATION_SHOWING_PAYMENT:
-      if (!network->activate_over_non_cellular_network())
+      if (!network->activate_over_non_cellular_networks())
         new_state = PLAN_ACTIVATION_RECONNECTING;
       break;
     case PLAN_ACTIVATION_START:
-      switch (network->activation_state()) {
-        case ACTIVATION_STATE_ACTIVATED:
-          if (network->restricted_pool())
-            new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
-          else
-            new_state = PLAN_ACTIVATION_DONE;
-          break;
-        case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
-          new_state = PLAN_ACTIVATION_TRYING_OTASP;
-          break;
-        default:
-          new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
-          break;
+      if (activation == flimflam::kActivationStateActivated) {
+        if (network->connection_state() == flimflam::kStatePortal)
+          new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
+        else
+          new_state = PLAN_ACTIVATION_DONE;
+      } else if (activation == flimflam::kActivationStatePartiallyActivated) {
+        new_state = PLAN_ACTIVATION_TRYING_OTASP;
+      } else {
+        new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
       }
       break;
-    default: {
+    default:
       LOG(INFO) << "Waiting for cellular service to connect.";
-      } break;
+      break;
   }
   return new_state;
 }
 
 MobileActivator::PlanActivationState MobileActivator::PickNextOnlineState(
-    CellularNetwork* network) const {
+    const NetworkState* network) const {
   PlanActivationState new_state = state_;
+  const std::string& activation = network->activation_state();
   switch (state_) {
     case PLAN_ACTIVATION_START:
-      switch (network->activation_state()) {
-        case ACTIVATION_STATE_ACTIVATED:
-          if (network->restricted_pool())
-            new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
-          else
-            new_state = PLAN_ACTIVATION_DONE;
-          break;
-        case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
-          new_state = PLAN_ACTIVATION_TRYING_OTASP;
-          break;
-        default:
-          new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
-          break;
+      if (activation == flimflam::kActivationStateActivated) {
+        if (network->connection_state() == flimflam::kStatePortal)
+          new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
+        else
+          new_state = PLAN_ACTIVATION_DONE;
+      } else if (activation == flimflam::kActivationStatePartiallyActivated) {
+        new_state = PLAN_ACTIVATION_TRYING_OTASP;
+      } else {
+        new_state = PLAN_ACTIVATION_INITIATING_ACTIVATION;
       }
       break;
     case PLAN_ACTIVATION_START_OTASP: {
-      switch (network->activation_state()) {
-        case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
+      if (activation == flimflam::kActivationStatePartiallyActivated) {
           new_state = PLAN_ACTIVATION_OTASP;
-          break;
-        case ACTIVATION_STATE_ACTIVATED:
-          new_state = PLAN_ACTIVATION_RECONNECTING;
-          break;
-        default: {
-          LOG(WARNING) << "Unexpected activation state for device "
-                       << network->service_path();
-          break;
-        }
+      } else if (activation == flimflam::kActivationStateActivated) {
+        new_state = PLAN_ACTIVATION_RECONNECTING;
+      } else {
+        LOG(WARNING) << "Unexpected activation state for device "
+                     << network->path();
       }
       break;
     }
     case PLAN_ACTIVATION_DELAY_OTASP:
       // Just ignore any changes until the OTASP retry timer kicks in.
       break;
     case PLAN_ACTIVATION_INITIATING_ACTIVATION: {
-      switch (network->activation_state()) {
-        case ACTIVATION_STATE_ACTIVATED:
-        case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
-          new_state = PLAN_ACTIVATION_START;
-          break;
-        case ACTIVATION_STATE_NOT_ACTIVATED:
-        case ACTIVATION_STATE_ACTIVATING:
-          // Wait in this state until activation state changes.
-          break;
-        default:
-          LOG(WARNING) << "Unknown transition";
-          break;
+      if (activation == flimflam::kActivationStateActivated ||
+          activation == flimflam::kActivationStatePartiallyActivated) {
+        new_state = PLAN_ACTIVATION_START;
+      } else if (activation == flimflam::kActivationStateNotActivated ||
+                 activation == flimflam::kActivationStateActivating) {
+        // Wait in this state until activation state changes.
+      } else {
+        LOG(WARNING) << "Unknown transition";
       }
       break;
     }
     case PLAN_ACTIVATION_OTASP:
     case PLAN_ACTIVATION_TRYING_OTASP:
-      if (network->activation_state() == ACTIVATION_STATE_NOT_ACTIVATED ||
-          network->activation_state() == ACTIVATION_STATE_ACTIVATING) {
+      if (activation == flimflam::kActivationStateNotActivated ||
+          activation == flimflam::kActivationStateActivating) {
         LOG(INFO) << "Waiting for the OTASP to finish and the service to "
                   << "come back online";
-      } else if (network->activation_state() == ACTIVATION_STATE_ACTIVATED) {
+      } else if (activation == flimflam::kActivationStateActivated) {
         new_state = PLAN_ACTIVATION_DONE;
       } else {
         new_state = PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING;
       }
       break;
     case PLAN_ACTIVATION_RECONNECTING_PAYMENT:
-      if (!network->restricted_pool() &&
-          network->activation_state() == ACTIVATION_STATE_ACTIVATED)
+      if (network->connection_state() != flimflam::kStatePortal &&
+          activation == flimflam::kActivationStateActivated)
         // We're not portalled, and we're already activated, so we're online!
         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:
@@ skipping 42 matching lines @@
       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) {
+void MobileActivator::CompleteActivation(const NetworkState* network) {
   // Remove observers, we are done with this page.
-  NetworkLibrary* lib = GetNetworkLibrary();
-  lib->RemoveNetworkManagerObserver(this);
-  lib->RemoveObserverForAllNetworks(this);
+  NetworkHandler::Get()->network_state_handler()->RemoveObserver(
+      this, FROM_HERE);
+
   // Reactivate other types of connections if we have
   // shut them down previously.
   ReEnableCertRevocationChecking();
 }
 
 bool MobileActivator::RunningActivation() const {
   return !(state_ == PLAN_ACTIVATION_DONE ||
            state_ == PLAN_ACTIVATION_ERROR ||
            state_ == PLAN_ACTIVATION_PAGE_LOADING);
 }
 
-void MobileActivator::ChangeState(CellularNetwork* network,
+void MobileActivator::HandleActivationFailure(
+    const std::string& service_path,
+    PlanActivationState new_state,
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
+          service_path);
+  if (!network)
+    NET_LOG_ERROR("Cellular service no longer exists", service_path);

[stevenjb, 2013/08/14 21:58:35]

Need to return here; ChangeState does not safely handle NULL network.

[gauravsh, 2013/08/15 01:46:35]

Done.

+  UMA_HISTOGRAM_COUNTS("Cellular.ActivationFailure", 1);
+  NET_LOG_ERROR("Failed to call Activate() on service", service_path);
+  if (new_state == PLAN_ACTIVATION_OTASP) {
+    ChangeState(network, PLAN_ACTIVATION_DELAY_OTASP, std::string());
+  } else {
+    ChangeState(network,
+                PLAN_ACTIVATION_ERROR,
+                GetErrorMessage(kFailedConnectivity));
+  }
+}
+
+void MobileActivator::ChangeState(const NetworkState* network,
                                   PlanActivationState new_state,
                                   const std::string& error_description) {
   static bool first_time = true;
   LOG(INFO) << "Activation state flip old = "
             << GetStateDescription(state_)
             << ", new = " << GetStateDescription(new_state);
   if (state_ == new_state && !first_time)
     return;
   first_time = false;
   LOG(INFO) << "Transitioning...";
 
   // Kill all the possible timers and callbacks we might have outstanding.
   state_duration_timer_.Stop();
   continue_reconnect_timer_.Stop();
   reconnect_timeout_timer_.Stop();
   const PlanActivationState old_state = state_;
   state_ = new_state;
 
   // Signal to observers layer that the state is changing.
   FOR_EACH_OBSERVER(Observer, observers_,
       OnActivationStateChanged(network, state_, error_description));
 
+  network_handler::ErrorCallback on_activation_error =
+      base::Bind(&MobileActivator::HandleActivationFailure, AsWeakPtr(),
+                 network->path(),
+                 new_state);
   // Pick action that should happen on entering the new state.
   switch (new_state) {
     case PLAN_ACTIVATION_START:
       break;
     case PLAN_ACTIVATION_DELAY_OTASP: {
       UMA_HISTOGRAM_COUNTS("Cellular.RetryOTASP", 1);
       BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&MobileActivator::RetryOTASP, AsWeakPtr()),
           base::TimeDelta::FromMilliseconds(kOTASPRetryDelay));
       break;
     }
     case PLAN_ACTIVATION_START_OTASP:
       break;
     case PLAN_ACTIVATION_INITIATING_ACTIVATION:
     case PLAN_ACTIVATION_TRYING_OTASP:
     case PLAN_ACTIVATION_OTASP:
       DCHECK(network);
-      LOG(WARNING) << "Activating service " << network->service_path();
+      NET_LOG_EVENT("Activating cellular service", network->path());
       UMA_HISTOGRAM_COUNTS("Cellular.ActivationTry", 1);
-      if (!network->StartActivation()) {
-        UMA_HISTOGRAM_COUNTS("Cellular.ActivationFailure", 1);
-        LOG(ERROR) << "Failed to call Activate() on service in shill.";
-        if (new_state == PLAN_ACTIVATION_OTASP) {
-          ChangeState(network, PLAN_ACTIVATION_DELAY_OTASP, std::string());
-        } else {
-          ChangeState(network,
-                      PLAN_ACTIVATION_ERROR,
-                      GetErrorMessage(kFailedConnectivity));
-        }
-      } else {
-        StartOTASPTimer();
-      }
+      NetworkHandler::Get()->network_activation_handler()->
+          Activate(network->path(),
+                   "",  // carrier
+                   base::Bind(&MobileActivator::StartOTASPTimer, AsWeakPtr()),
+                   on_activation_error);
       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:
         case PLAN_ACTIVATION_TRYING_OTASP:
           next_state = PLAN_ACTIVATION_START;
           break;
         case PLAN_ACTIVATION_START_OTASP:
         case PLAN_ACTIVATION_OTASP:
-          if (!network || !network->connected()) {
+          if (!network || !network->IsConnectedState()) {
             next_state = PLAN_ACTIVATION_START_OTASP;
           } else {
             // We're online, which means we've conspired with
             // PickNextOnlineState to reconnect after activation (that's the
             // only way we see this transition).  Thus, after we reconnect, we
             // should be done.
             next_state = PLAN_ACTIVATION_DONE;
           }
           break;
         default:
@@ skipping 34 matching lines @@
   PrefService* prefs = g_browser_process->local_state();
   if (!reenable_cert_check_ &&
       prefs->GetBoolean(
           prefs::kCertRevocationCheckingEnabled)) {
     reenable_cert_check_ = true;
     prefs->SetBoolean(prefs::kCertRevocationCheckingEnabled, false);
   }
 }
 
 bool MobileActivator::GotActivationError(
-    CellularNetwork* network, std::string* error) const {
+    const NetworkState* network, std::string* error) const {
   DCHECK(network);
   bool got_error = false;
   const char* error_code = kErrorDefault;
+  const std::string& activation = network->activation_state();
 
   // This is the magic for detection of errors in during activation process.
-  if (network->state() == STATE_FAILURE &&
-      network->error() == ERROR_AAA_FAILED) {
-    if (network->activation_state() ==
-            ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
+  if (network->connection_state() == flimflam::kStateFailure &&
+      network->error() == flimflam::kErrorAaaFailed) {
+    if (activation == flimflam::kActivationStatePartiallyActivated) {
       error_code = kErrorBadConnectionPartial;
-    } else if (network->activation_state() == ACTIVATION_STATE_ACTIVATED) {
-      if (network->roaming_state() == ROAMING_STATE_HOME)
+    } else if (activation == flimflam::kActivationStateActivated) {
+      if (network->roaming() == flimflam::kRoamingStateHome)
         error_code = kErrorBadConnectionActivated;
-      else if (network->roaming_state() == ROAMING_STATE_ROAMING)
+      else if (network->roaming() == flimflam::kRoamingStateRoaming)
         error_code = kErrorRoamingOnConnection;
     }
     got_error = true;
-  } else if (network->state() == STATE_ACTIVATION_FAILURE) {
-    if (network->error() == ERROR_NEED_EVDO) {
-      if (network->activation_state() == ACTIVATION_STATE_PARTIALLY_ACTIVATED)
+  } else if (network->connection_state() == flimflam::kStateActivationFailure) {
+    if (network->error() == flimflam::kErrorNeedEvdo) {
+      if (activation == flimflam::kActivationStatePartiallyActivated)
         error_code = kErrorNoEVDO;
-    } else if (network->error() == ERROR_NEED_HOME_NETWORK) {
-      if (network->activation_state() == ACTIVATION_STATE_NOT_ACTIVATED) {
+    } else if (network->error() == flimflam::kErrorNeedHomeNetwork) {
+      if (activation == flimflam::kActivationStateNotActivated) {
         error_code = kErrorRoamingActivation;
-      } else if (network->activation_state() ==
-                 ACTIVATION_STATE_PARTIALLY_ACTIVATED) {
+      } else if (activation == flimflam::kActivationStatePartiallyActivated) {
         error_code = kErrorRoamingPartiallyActivated;
       }
     }
     got_error = true;
   }
 
   if (got_error)
     *error = GetErrorMessage(error_code);
 
   return got_error;
 }
 
-void MobileActivator::GetDeviceInfo(CellularNetwork* network,
+void MobileActivator::GetDeviceInfo(const NetworkState* network,
                                     DictionaryValue* value) {
   DCHECK(network);
-  NetworkLibrary* cros = NetworkLibrary::Get();
-  if (!cros)
-    return;
   value->SetString("carrier", network->name());
   value->SetString("payment_url", network->payment_url());
-  if (network->using_post() && network->post_data().length())
+  if (network->post_method() == "post"  && !network->post_data().empty())
     value->SetString("post_data", network->post_data());
 
-  const NetworkDevice* device =
-      cros->FindNetworkDeviceByPath(network->device_path());
+  const DeviceState* device =
+      NetworkHandler::Get()->network_state_handler()->GetDeviceState(
+          network->device_path());
   if (device) {
     value->SetString("MEID", device->meid());
     value->SetString("IMEI", device->imei());
     value->SetString("MDN", device->mdn());
   }
 }
 
 std::string MobileActivator::GetErrorMessage(const std::string& code) const {
   return cellular_config_->GetErrorMessage(code);
 }
 
-NetworkLibrary* MobileActivator::GetNetworkLibrary() const {
-  return NetworkLibrary::Get();
+void MobileActivator::SignalCellularPlanPayment() {
+  DCHECK(!HasRecentCellularPlanPayment());
+  cellular_plan_payment_time_ = base::Time::Now();
+}
+
+bool MobileActivator::HasRecentCellularPlanPayment() const {
+  const int kRecentPlanPaymentHours = 6;
+  return (base::Time::Now() -
+          cellular_plan_payment_time_).InHours() < kRecentPlanPaymentHours;
 }
 
 }  // namespace chromeos