Remove unnecessary calls to AddWakeOnPaketConnection and RemoveWakeOnPacketConnection

chrome/browser/chromeos/net/wake_on_wifi_manager.cc

 // Copyright 2014 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/wake_on_wifi_manager.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
-#include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "components/gcm_driver/gcm_connection_observer.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/gcm_driver/gcm_profile_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 32 matching lines @@
 
 bool IsWakeOnPacketEnabled(WakeOnWifiManager::WakeOnWifiFeature feature) {
   return feature & WakeOnWifiManager::WAKE_ON_WIFI_PACKET;
 }
 
 // Weak pointer.  This class is owned by ChromeBrowserMainPartsChromeos.
 WakeOnWifiManager* g_wake_on_wifi_manager = NULL;
 
 }  // namespace
 
-// Simple class that listens for a connection to the GCM server and passes the
-// connection information down to shill.  Each profile gets its own instance of
-// this class.
-class WakeOnWifiManager::WakeOnPacketConnectionObserver
-    : public gcm::GCMConnectionObserver {
- public:
-  WakeOnPacketConnectionObserver(Profile* profile,
-                                 bool wifi_properties_received)
-      : profile_(profile),
-        ip_endpoint_(net::IPEndPoint()),
-        wifi_properties_received_(wifi_properties_received) {
-    gcm::GCMProfileServiceFactory::GetForProfile(profile_)
-        ->driver()
-        ->AddConnectionObserver(this);
+WakeOnWifiManager::ConnectionObserver::ConnectionObserver(
+    Profile* profile,
+    bool wifi_properties_received,
+    WakeOnWifiManager::WakeOnWifiFeature feature,
+    NetworkDeviceHandler* network_device_handler)
+    : profile_(profile),
+      ip_endpoint_(net::IPEndPoint()),
+      wifi_properties_received_(wifi_properties_received),
+      feature_(feature),
+      network_device_handler_(network_device_handler) {
+  gcm::GCMProfileServiceFactory::GetForProfile(profile_)
+      ->driver()
+      ->AddConnectionObserver(this);
+}
+
+WakeOnWifiManager::ConnectionObserver::~ConnectionObserver() {
+  if (!(ip_endpoint_ == net::IPEndPoint()))
+    OnDisconnected();
+
+  gcm::GCMProfileServiceFactory::GetForProfile(profile_)
+      ->driver()
+      ->RemoveConnectionObserver(this);
+}
+
+void WakeOnWifiManager::ConnectionObserver::HandleWifiDevicePropertiesReady() {
+  wifi_properties_received_ = true;
+
+  // IPEndPoint doesn't implement operator!=
+  if (ip_endpoint_ == net::IPEndPoint())
+    return;
+
+  AddWakeOnPacketConnection();
+}
+
+void WakeOnWifiManager::ConnectionObserver::OnConnected(
+    const net::IPEndPoint& ip_endpoint) {
+  ip_endpoint_ = ip_endpoint;
+
+  if (wifi_properties_received_)
+    AddWakeOnPacketConnection();
+}
+
+void WakeOnWifiManager::ConnectionObserver::OnDisconnected() {
+  if (ip_endpoint_ == net::IPEndPoint()) {
+    VLOG(1) << "Received GCMConnectionObserver::OnDisconnected without a "
+            << "valid IPEndPoint.";
+    return;
   }
 
-  ~WakeOnPacketConnectionObserver() override {
-    if (!(ip_endpoint_ == net::IPEndPoint()))
-      OnDisconnected();
+  if (wifi_properties_received_)
+    RemoveWakeOnPacketConnection();
 
-    gcm::GCMProfileServiceFactory::GetForProfile(profile_)
-        ->driver()
-        ->RemoveConnectionObserver(this);
-  }
+  ip_endpoint_ = net::IPEndPoint();
+}
 
-  void HandleWifiDevicePropertiesReady() {
-    wifi_properties_received_ = true;
+void WakeOnWifiManager::ConnectionObserver::AddWakeOnPacketConnection() {
+  if (!IsWakeOnPacketEnabled(WakeOnWifiManager::ConnectionObserver::feature_))
+    return;
+  network_device_handler_
+      ->AddWifiWakeOnPacketConnection(ip_endpoint_,
+                                      base::Bind(&base::DoNothing),
+                                      network_handler::ErrorCallback());
+}
 
-    // IPEndPoint doesn't implement operator!=
-    if (ip_endpoint_ == net::IPEndPoint())
-      return;
-
-    AddWakeOnPacketConnection();
-  }
-
-  // gcm::GCMConnectionObserver overrides.
-
-  void OnConnected(const net::IPEndPoint& ip_endpoint) override {
-    ip_endpoint_ = ip_endpoint;
-
-    if (wifi_properties_received_)
-      AddWakeOnPacketConnection();
-  }
-
-  void OnDisconnected() override {
-    if (ip_endpoint_ == net::IPEndPoint()) {
-      VLOG(1) << "Received GCMConnectionObserver::OnDisconnected without a "
-              << "valid IPEndPoint.";
-      return;
-    }
-
-    if (wifi_properties_received_)
-      RemoveWakeOnPacketConnection();
-
-    ip_endpoint_ = net::IPEndPoint();
-  }
-
- private:
-  void AddWakeOnPacketConnection() {
-    NetworkHandler::Get()
-        ->network_device_handler()
-        ->AddWifiWakeOnPacketConnection(ip_endpoint_,
-                                        base::Bind(&base::DoNothing),
-                                        network_handler::ErrorCallback());
-  }
-
-  void RemoveWakeOnPacketConnection() {
-    NetworkHandler::Get()
-        ->network_device_handler()
-        ->RemoveWifiWakeOnPacketConnection(ip_endpoint_,
-                                           base::Bind(&base::DoNothing),
-                                           network_handler::ErrorCallback());
-  }
-
-  Profile* profile_;
-  net::IPEndPoint ip_endpoint_;
-  bool wifi_properties_received_;
-
-  DISALLOW_COPY_AND_ASSIGN(WakeOnPacketConnectionObserver);
-};
+void WakeOnWifiManager::ConnectionObserver::RemoveWakeOnPacketConnection() {
+  if (!IsWakeOnPacketEnabled(WakeOnWifiManager::ConnectionObserver::feature_))
+    return;
+  network_device_handler_
+      ->RemoveWifiWakeOnPacketConnection(ip_endpoint_,
+                                         base::Bind(&base::DoNothing),
+                                         network_handler::ErrorCallback());
+}
 
 // static
 WakeOnWifiManager* WakeOnWifiManager::Get() {
   DCHECK(g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return g_wake_on_wifi_manager;
 }
 
 WakeOnWifiManager::WakeOnWifiManager()
     : current_feature_(WakeOnWifiManager::INVALID),
@@ skipping 38 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (current_feature_ == NOT_SUPPORTED)
     return;
   if (!switches::WakeOnWifiEnabled())
     feature = WAKE_ON_WIFI_NONE;
   if (feature == current_feature_)
     return;
 
   current_feature_ = feature;
 
+  // Update value of member variable feature for all connection observers.
+  for (const auto& kv_pair : connection_observers_) {
+    kv_pair.second->set_feature(current_feature_);
+  }
+
   if (wifi_properties_received_)
     HandleWakeOnWifiFeatureUpdated();
 }
 
 bool WakeOnWifiManager::WakeOnWifiSupported() {
   return current_feature_ != NOT_SUPPORTED && current_feature_ != INVALID;
 }
 
 void WakeOnWifiManager::Observe(int type,
                                 const content::NotificationSource& source,
@@ skipping 94 matching lines @@
     return;
 
   wifi_properties_received_ = true;
 
   NetworkHandler::Get()
       ->network_device_handler()
       ->RemoveAllWifiWakeOnPacketConnections(base::Bind(&base::DoNothing),
                                              network_handler::ErrorCallback());
 
   for (const auto& kv_pair : connection_observers_) {
-    WakeOnPacketConnectionObserver* observer = kv_pair.second;
-    observer->HandleWifiDevicePropertiesReady();
+    kv_pair.second->HandleWifiDevicePropertiesReady();
   }
 }
 
 void WakeOnWifiManager::OnProfileAdded(Profile* profile) {
-  // add will do nothing if |profile| already exists in |connection_observers_|.
-  auto result = connection_observers_.add(
-      profile,
-      base::WrapUnique(new WakeOnWifiManager::WakeOnPacketConnectionObserver(
-          profile, wifi_properties_received_)));
+  auto result = connection_observers_.find(profile);
 
-  if (result.second) {
-    // This is a profile we haven't seen before.
-    gcm::GCMProfileServiceFactory::GetForProfile(profile)
-        ->driver()
-        ->WakeFromSuspendForHeartbeat(
-            IsWakeOnPacketEnabled(current_feature_));
-  }
+  // Only add the profile if it is not already present.
+  if (result != connection_observers_.end())
+    return;
+
+  connection_observers_[profile] =
+      base::WrapUnique(new WakeOnWifiManager::ConnectionObserver(
+          profile, wifi_properties_received_, current_feature_,
+          NetworkHandler::Get()->network_device_handler()));
+
+  gcm::GCMProfileServiceFactory::GetForProfile(profile)
+      ->driver()
+      ->WakeFromSuspendForHeartbeat(
+          IsWakeOnPacketEnabled(current_feature_));
 }
 
 void WakeOnWifiManager::OnProfileDestroyed(Profile* profile) {
   connection_observers_.erase(profile);
 }
 
 }  // namespace chromeos