Add a unified observer to replace NetworkManagerObserver

chrome/browser/chromeos/net/connectivity_state_helper.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 "chrome/browser/chromeos/net/connectivity_state_helper.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_state_handler_observer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 static ConnectivityStateHelper* g_connectivity_state_helper = NULL;
 
 // Implementation of the connectivity state helper that uses the network
 // state handler for fetching connectivity state.
 class ConnectivityStateHelperImpl
-    : public ConnectivityStateHelper {
+    : public ConnectivityStateHelper,
+      public NetworkStateHandlerObserver {
  public:
   ConnectivityStateHelperImpl();
   virtual ~ConnectivityStateHelperImpl();
 
+  // NetworkStateHandler overrides.
   virtual bool IsConnected() OVERRIDE;
   virtual bool IsConnectedType(const std::string& type) OVERRIDE;
   virtual bool IsConnectingType(const std::string& type) OVERRIDE;
   virtual std::string NetworkNameForType(const std::string& type) OVERRIDE;
   virtual std::string DefaultNetworkName() OVERRIDE;
   virtual bool DefaultNetworkOnline() OVERRIDE;
+  virtual void RequestScan() const OVERRIDE;
+
+  // NetworkStateHandlerObserver overrides.
+  virtual void NetworkManagerChanged() OVERRIDE;
 
  private:
   NetworkStateHandler* network_state_handler_;
 };
 
 // Implementation of the connectivity state helper that uses the network
 // library for fetching connectivity state.
 class ConnectivityStateHelperNetworkLibrary
-    : public ConnectivityStateHelper {
+    : public ConnectivityStateHelper,
+      public NetworkLibrary::NetworkManagerObserver {
  public:
   ConnectivityStateHelperNetworkLibrary();
   virtual ~ConnectivityStateHelperNetworkLibrary();
 
+  // ConnectivityStateHelper overrides.
   virtual bool IsConnected() OVERRIDE;
   virtual bool IsConnectedType(const std::string& type) OVERRIDE;
   virtual bool IsConnectingType(const std::string& type) OVERRIDE;
   virtual std::string NetworkNameForType(const std::string& type) OVERRIDE;
   virtual std::string DefaultNetworkName() OVERRIDE;
   virtual bool DefaultNetworkOnline() OVERRIDE;
+  virtual void RequestScan() const OVERRIDE;
+
+  // NetworkLibrary::NetworkManagerObserver overrides.
+  virtual void OnNetworkManagerChanged(NetworkLibrary* network_library);
 
  private:
   NetworkLibrary* network_library_;
 };
 
+ConnectivityStateHelper::ConnectivityStateHelper() {
+}
+
+ConnectivityStateHelper::~ConnectivityStateHelper() {
+}
+
 // static
 void ConnectivityStateHelper::Initialize() {
   CHECK(!g_connectivity_state_helper);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableNewNetworkChangeNotifier)) {
     g_connectivity_state_helper = new ConnectivityStateHelperImpl();
   } else {
     g_connectivity_state_helper =
         new ConnectivityStateHelperNetworkLibrary();
   }
 }
 
 // static
 void ConnectivityStateHelper::InitializeForTesting(
     ConnectivityStateHelper* connectivity_state_helper) {
   CHECK(!g_connectivity_state_helper);
   CHECK(connectivity_state_helper);
   g_connectivity_state_helper = connectivity_state_helper;
 }
 
 // static
+bool ConnectivityStateHelper::IsInitialized() {
+  return g_connectivity_state_helper != NULL;
+}
+
+// static
 void ConnectivityStateHelper::Shutdown() {
   CHECK(g_connectivity_state_helper);
   delete g_connectivity_state_helper;
   g_connectivity_state_helper = NULL;
 }
 
 // static
 ConnectivityStateHelper* ConnectivityStateHelper::Get() {
   CHECK(g_connectivity_state_helper)
       << "ConnectivityStateHelper: Get() called before Initialize()";
   return g_connectivity_state_helper;
 }
 
+void ConnectivityStateHelper::AddNetworkManagerObserver(
+    ConnectivityStateHelperObserver* observer) {
+  network_manager_observers_.AddObserver(observer);
+}
+
+void ConnectivityStateHelper::RemoveNetworkManagerObserver(
+    ConnectivityStateHelperObserver* observer) {
+  network_manager_observers_.RemoveObserver(observer);
+}
+
 ConnectivityStateHelperImpl::ConnectivityStateHelperImpl() {
   network_state_handler_ = NetworkStateHandler::Get();
+  network_state_handler_->AddObserver(this);
 }
 
-ConnectivityStateHelperImpl::~ConnectivityStateHelperImpl() {}
+ConnectivityStateHelperImpl::~ConnectivityStateHelperImpl() {
+  NetworkStateHandler::Get()->RemoveObserver(this);
+}
 
 bool ConnectivityStateHelperImpl::IsConnected() {
   return network_state_handler_->ConnectedNetworkByType(
       NetworkStateHandler::kMatchTypeDefault) != NULL;
 }
 
 bool ConnectivityStateHelperImpl::IsConnectedType(
     const std::string& type) {
   return network_state_handler_->ConnectedNetworkByType(type) != NULL;
 }
@@ skipping 22 matching lines @@
   const NetworkState* network = network_state_handler_->DefaultNetwork();
   if (!network)
     return false;
   if (!network->IsConnectedState())
     return false;
   if (network->connection_state() == flimflam::kStatePortal)
     return false;
   return true;
 }
 
+void ConnectivityStateHelperImpl::RequestScan() const {
+  network_state_handler_->RequestScan();
+}
+
+void ConnectivityStateHelperImpl::NetworkManagerChanged() {
+  FOR_EACH_OBSERVER(ConnectivityStateHelperObserver, network_manager_observers_,
+                    NetworkManagerChanged());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary implementation.
 //
 
 ConnectivityStateHelperNetworkLibrary::ConnectivityStateHelperNetworkLibrary() {
   network_library_ = CrosLibrary::Get()->GetNetworkLibrary();
+  network_library_->AddNetworkManagerObserver(this);
 }
 
 ConnectivityStateHelperNetworkLibrary::~ConnectivityStateHelperNetworkLibrary()
-{}
+{
+  network_library_->RemoveNetworkManagerObserver(this);
+}
 
 bool ConnectivityStateHelperNetworkLibrary::IsConnected() {
   return network_library_->Connected();
 }
 
 bool ConnectivityStateHelperNetworkLibrary::IsConnectedType(
     const std::string& type) {
   if (type == flimflam::kTypeEthernet)
     return network_library_->ethernet_connected();
   if (type == flimflam::kTypeWifi)
@@ skipping 41 matching lines @@
   const Network* active_network = network_library_->active_network();
   if (!active_network)
     return false;
   if (!active_network->connected())
     return false;
   if (active_network->restricted_pool())
     return false;
   return true;
 }
 
+void ConnectivityStateHelperNetworkLibrary::RequestScan() const {
+  network_library_->RequestNetworkScan();
+}
+
+void ConnectivityStateHelperNetworkLibrary::OnNetworkManagerChanged(
+    NetworkLibrary* network_library) {
+  FOR_EACH_OBSERVER(ConnectivityStateHelperObserver, network_manager_observers_,
+                    NetworkManagerChanged());
+}
+
 }  // namespace chromeos