Add NetworkState::RequiresActivation.

chromeos/network/network_connection_handler.cc

 // Copyright (c) 2013 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 "chromeos/network/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 29 matching lines @@
 }
 
 bool IsAuthenticationError(const std::string& error) {
   return (error == flimflam::kErrorBadWEPKey ||
           error == flimflam::kErrorPppAuthFailed ||
           error == shill::kErrorEapLocalTlsFailed ||
           error == shill::kErrorEapRemoteTlsFailed ||
           error == shill::kErrorEapAuthenticationFailed);
 }
 
-bool NetworkRequiresActivation(const NetworkState* network) {
-  return (network->type() == flimflam::kTypeCellular &&
-      ((network->activation_state() != flimflam::kActivationStateActivated &&
-        network->activation_state() != flimflam::kActivationStateUnknown)));
-}
-
 bool VPNIsConfigured(const std::string& service_path,
                      const std::string& provider_type,
                      const base::DictionaryValue& provider_properties) {
   if (provider_type == flimflam::kProviderOpenVpn) {
     std::string hostname;
     provider_properties.GetStringWithoutPathExpansion(
         flimflam::kHostProperty, &hostname);
     if (hostname.empty()) {
       NET_LOG_EVENT("OpenVPN: No hostname", service_path);
       return false;
@@ skipping 157 matching lines @@
   if (network) {
     // For existing networks, perform some immediate consistency checks.
     if (network->IsConnectedState()) {
       InvokeErrorCallback(service_path, error_callback, kErrorConnected);
       return;
     }
     if (network->IsConnectingState()) {
       InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
       return;
     }
-    if (NetworkRequiresActivation(network)) {
+    if (network->RequiresActivation()) {
       InvokeErrorCallback(service_path, error_callback,
                           kErrorActivationRequired);
       return;
     }
 
     if (check_error_state) {
       const std::string& error = network->error();
       if (error == flimflam::kErrorBadPassphrase) {
         InvokeErrorCallback(service_path, error_callback, error);
         return;
@@ skipping 399 matching lines @@
 
 void NetworkConnectionHandler::HandleShillDisconnectSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Disconnect Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos