Enable lucid sleep (wake on wi-fi SSID) and add to Privacy options.

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"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.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.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 "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 16 matching lines @@
     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();
+    case WakeOnWifiManager::NOT_SUPPORTED:
+      NOTREACHED();
+      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;
+  return feature & WakeOnWifiManager::WAKE_ON_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.
@@ skipping 55 matching lines @@
 };
 
 // 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) {
+    : current_feature_(WakeOnWifiManager::INVALID),
+      weak_ptr_factory_(this) {
   // 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;
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_ADDED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   NetworkHandler::Get()
       ->network_device_handler()
       ->RemoveAllWifiWakeOnPacketConnections(
           base::Bind(&base::DoNothing),
           network_handler::ErrorCallback());
+
+  if (!switches::WakeOnWifiEnabled())
+    return;
+
+  const DeviceState* device =
+      NetworkHandler::Get()->network_state_handler()->GetDeviceStateByType(
+          NetworkTypePattern::WiFi());
+  if (!device)
+    return;
+  // Get device properties to check whether wake-on-wifi is supported.
+  NetworkHandler::Get()->network_device_handler()->GetDeviceProperties(
+      device->path(),
+      base::Bind(&WakeOnWifiManager::GetDevicePropertiesCallback,
+                 weak_ptr_factory_.GetWeakPtr()),
+      network_handler::ErrorCallback());
 }
 
 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 (current_feature_ == NOT_SUPPORTED)
+    return;
+  if (!switches::WakeOnWifiEnabled())
+    feature = WAKE_ON_NONE;
   if (feature == current_feature_)
     return;
 
   current_feature_ = feature;
 
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceStateByType(
           NetworkTypePattern::WiFi());
   if (!device)
     return;
@@ skipping 10 matching lines @@
 
   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);
   }
 }
 
+bool WakeOnWifiManager::WakeOnWifiSupported() {
+  return current_feature_ != NOT_SUPPORTED && current_feature_ != INVALID;
+}
+
+void WakeOnWifiManager::GetDevicePropertiesCallback(
+    const std::string& device_path,
+    const base::DictionaryValue& properties) {
+  if (!properties.HasKey(shill::kWakeOnWiFiFeaturesEnabledProperty))
+    return;
+  std::string enabled;
+  if (properties.GetString(shill::kWakeOnWiFiFeaturesEnabledProperty,
+                           &enabled) &&
+      enabled == shill::kWakeOnWiFiFeaturesEnabledNotSupported) {
+    current_feature_ = NOT_SUPPORTED;
+  }
+}
+
 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());
@@ skipping 18 matching lines @@
         ->WakeFromSuspendForHeartbeat(
             IsWakeOnPacketEnabled(current_feature_));
   }
 }
 
 void WakeOnWifiManager::OnProfileDestroyed(Profile* profile) {
   connection_observers_.erase(profile);
 }
 
 }  // namespace chromeos