Trigger ConnectToBestNetwork in more cases.

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/json/json_reader.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 134 matching lines @@
   ConnectState connect_state;
   base::Closure success_callback;
   network_handler::ErrorCallback error_callback;
 };
 
 NetworkConnectionHandler::NetworkConnectionHandler()
     : cert_loader_(NULL),
       network_state_handler_(NULL),
       configuration_handler_(NULL),
       logged_in_(false),
-      certificates_loaded_(false),
-      applied_autoconnect_policy_(false),
-      requested_connect_to_best_network_(false) {
+      certificates_loaded_(false) {
 }
 
 NetworkConnectionHandler::~NetworkConnectionHandler() {
   if (network_state_handler_)
     network_state_handler_->RemoveObserver(this, FROM_HERE);
   if (cert_loader_)
     cert_loader_->RemoveObserver(this);
   if (LoginState::IsInitialized())
     LoginState::Get()->RemoveObserver(this);
 }
@@ skipping 16 matching lines @@
     // TODO(tbarzic): Require a mock or stub cert_loader in tests.
     NET_LOG_EVENT("Certificate Loader not initialized", "");
     certificates_loaded_ = true;
   }
 
   if (network_state_handler) {
     network_state_handler_ = network_state_handler;
     network_state_handler_->AddObserver(this, FROM_HERE);
   }
   configuration_handler_ = network_configuration_handler;
-
-  if (managed_network_configuration_handler) {
-    managed_configuration_handler_ = managed_network_configuration_handler;
-    managed_configuration_handler_->AddObserver(this);
-  }
+  managed_configuration_handler_ = managed_network_configuration_handler;
 
   // After this point, the NetworkConnectionHandler is fully initialized (all
   // handler references set, observers registered, ...).
 
   if (LoginState::IsInitialized())
     LoggedInStateChanged();
 }
 
+void NetworkConnectionHandler::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void NetworkConnectionHandler::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void NetworkConnectionHandler::LoggedInStateChanged() {
   LoginState* login_state = LoginState::Get();
   if (logged_in_ || !login_state->IsUserLoggedIn())
     return;
 
   NET_LOG_EVENT("Logged In", "");
   logged_in_ = true;
   logged_in_time_ = base::TimeTicks::Now();
-
-  DisconnectIfPolicyRequires();
 }
 
 void NetworkConnectionHandler::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
   certificates_loaded_ = true;
   NET_LOG_EVENT("Certificates Loaded", "");
-  if (queued_connect_) {
+  if (queued_connect_)
     ConnectToQueuedNetwork();
-  } else if (initial_load) {
-    // Connecting to the "best" available network requires certificates to be
-    // loaded. Try to connect now.
-    ConnectToBestNetworkAfterLogin();
-  }
-}
-
-void NetworkConnectionHandler::PolicyChanged(const std::string& userhash) {
-  // Ignore user policies.
-  if (!userhash.empty())
-    return;
-  DisconnectIfPolicyRequires();
 }
 
 void NetworkConnectionHandler::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
     bool check_error_state) {
   NET_LOG_USER("ConnectToNetwork", service_path);
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    ConnectToNetworkRequested(service_path));
+
   // Clear any existing queued connect request.
   queued_connect_.reset();
   if (HasConnectingNetwork(service_path)) {
     NET_LOG_USER("Connect Request While Pending", service_path);
     InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
     return;
   }
 
   // Check cached network state for connected, connecting, or unactivated
   // networks. These states will not be affected by a recent configuration.
@@ skipping 498 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();
 }
 
-void NetworkConnectionHandler::ConnectToBestNetworkAfterLogin() {
-  if (requested_connect_to_best_network_ || !applied_autoconnect_policy_ ||
-      !certificates_loaded_) {
-    return;
-  }
-
-  requested_connect_to_best_network_ = true;
-  network_state_handler_->ConnectToBestWifiNetwork();
-}
-
-void NetworkConnectionHandler::DisconnectIfPolicyRequires() {
-  if (applied_autoconnect_policy_ || !LoginState::Get()->IsUserLoggedIn())
-    return;
-
-  const base::DictionaryValue* global_network_config =
-      managed_configuration_handler_->GetGlobalConfigFromPolicy(std::string());
-  if (!global_network_config)
-    return;
-
-  applied_autoconnect_policy_ = true;
-
-  bool only_policy_autoconnect = false;
-  global_network_config->GetBooleanWithoutPathExpansion(
-      ::onc::global_network_config::kAllowOnlyPolicyNetworksToAutoconnect,
-      &only_policy_autoconnect);
-
-  if (only_policy_autoconnect)
-    DisconnectFromUnmanagedSharedWiFiNetworks();
-
-  ConnectToBestNetworkAfterLogin();
-}
-
-void NetworkConnectionHandler::DisconnectFromUnmanagedSharedWiFiNetworks() {
-  NET_LOG_DEBUG("DisconnectFromUnmanagedSharedWiFiNetworks", "");
-
-  NetworkStateHandler::NetworkStateList networks;
-  network_state_handler_->GetVisibleNetworkListByType(
-      NetworkTypePattern::Wireless(), &networks);
-  for (NetworkStateHandler::NetworkStateList::const_iterator it =
-           networks.begin();
-       it != networks.end();
-       ++it) {
-    const NetworkState* network = *it;
-    if (!(network->IsConnectingState() || network->IsConnectedState()))
-      break;  // Connected and connecting networks are listed first.
-
-    if (network->IsPrivate())
-      continue;
-
-    const bool network_is_policy_managed =
-        !network->profile_path().empty() && !network->guid().empty() &&
-        managed_configuration_handler_->FindPolicyByGuidAndProfile(
-            network->guid(), network->profile_path());
-    if (network_is_policy_managed)
-      continue;
-
-    NET_LOG_EVENT("Disconnect Forced by Policy", network->path());
-    CallShillDisconnect(
-        network->path(), base::Closure(), network_handler::ErrorCallback());
-  }
-}
-
 }  // namespace chromeos