Link GCM heartbeat with wake on wifi preference

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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 33 matching lines @@
     WakeOnWifiManager::WakeOnWifiFeature feature) {
   switch (feature) {
     case WakeOnWifiManager::WAKE_ON_NONE:
       return kWakeOnNone;
     case WakeOnWifiManager::WAKE_ON_PACKET:
       return kWakeOnPacket;
     case WakeOnWifiManager::WAKE_ON_SSID:
       return kWakeOnSsid;
     case WakeOnWifiManager::WAKE_ON_PACKET_AND_SSID:
       return kWakeOnPacketAndSsid;
+    case WakeOnWifiManager::INVALID:
+      return std::string();
   }
 
   NOTREACHED() << "Unknown wake on wifi feature: " << feature;
   return std::string();
 }
 
+bool IsWakeOnPacketEnabled(WakeOnWifiManager::WakeOnWifiFeature feature) {
+  return feature == WakeOnWifiManager::WAKE_ON_PACKET ||
+         feature == WakeOnWifiManager::WAKE_ON_PACKET_AND_SSID;
+}
+
 // 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 {
@@ skipping 52 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WakeOnPacketConnectionObserver);
 };
 
 // static
 WakeOnWifiManager* WakeOnWifiManager::Get() {
   DCHECK(g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return g_wake_on_wifi_manager;
 }
 
-WakeOnWifiManager::WakeOnWifiManager() {
+WakeOnWifiManager::WakeOnWifiManager()
+    : current_feature_(WakeOnWifiManager::INVALID) {
   // This class must be constructed before any users are logged in, i.e., before
   // any profiles are created or added to the ProfileManager.  Additionally,
   // IsUserLoggedIn always returns true when we are not running on a Chrome OS
   // device so this check should only run on real devices.
   CHECK(!base::SysInfo::IsRunningOnChromeOS() ||
         !LoginState::Get()->IsUserLoggedIn());
   DCHECK(!g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   g_wake_on_wifi_manager = this;
@@ skipping 14 matching lines @@
 
 WakeOnWifiManager::~WakeOnWifiManager() {
   DCHECK(g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   g_wake_on_wifi_manager = NULL;
 }
 
 void WakeOnWifiManager::OnPreferenceChanged(
     WakeOnWifiManager::WakeOnWifiFeature feature) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (feature == current_feature_)
+    return;
+
+  current_feature_ = feature;
+
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceStateByType(
           NetworkTypePattern::WiFi());
   if (!device)
     return;
 
   std::string feature_string(WakeOnWifiFeatureToString(feature));
   DCHECK(!feature_string.empty());
 
   NetworkHandler::Get()->network_device_handler()->SetDeviceProperty(
       device->path(),
       shill::kWakeOnWiFiFeaturesEnabledProperty,
       base::StringValue(feature_string),
       base::Bind(&base::DoNothing),
       network_handler::ErrorCallback());
+
+  bool wake_from_suspend = IsWakeOnPacketEnabled(current_feature_);
+  for (const auto& kv_pair : connection_observers_) {
+    Profile* profile = kv_pair.first;
+    gcm::GCMProfileServiceFactory::GetForProfile(profile)
+        ->driver()
+        ->WakeFromSuspendForHeartbeat(wake_from_suspend);
+  }
 }
 
 void WakeOnWifiManager::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_ADDED: {
       OnProfileAdded(content::Source<Profile>(source).ptr());
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       OnProfileDestroyed(content::Source<Profile>(source).ptr());
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void WakeOnWifiManager::OnProfileAdded(Profile* profile) {
   // add will do nothing if |profile| already exists in |connection_observers_|.
-  connection_observers_.add(
+  auto result = connection_observers_.add(
       profile,
       make_scoped_ptr(
           new WakeOnWifiManager::WakeOnPacketConnectionObserver(profile)));
+
+  if (result.second) {
+    // This is a profile we haven't seen before.
+    gcm::GCMProfileServiceFactory::GetForProfile(profile)
+        ->driver()
+        ->WakeFromSuspendForHeartbeat(
+            IsWakeOnPacketEnabled(current_feature_));
+  }
 }
 
 void WakeOnWifiManager::OnProfileDestroyed(Profile* profile) {
   connection_observers_.erase(profile);
 }
 
 }  // namespace chromeos