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

chrome/browser/chromeos/preferences.cc

 // Copyright (c) 2012 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/preferences.h"
 
 #include <vector>
 
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/shell.h"
@@ skipping 254 matching lines @@
   registry->RegisterIntegerPref(
       prefs::kLanguageXkbAutoRepeatDelay,
       language_prefs::kXkbAutoRepeatDelayInMs,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterIntegerPref(
       prefs::kLanguageXkbAutoRepeatInterval,
       language_prefs::kXkbAutoRepeatIntervalInMs,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
   // We don't sync wake-on-wifi related prefs because they are device specific.
-  // TODO(chirantan): Default this to on when we are ready to launch.
-  registry->RegisterIntegerPref(
-      prefs::kWakeOnWiFiEnabled,
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kWakeOnPackets)
-          ? WakeOnWifiManager::WAKE_ON_PACKET_AND_SSID
-          : WakeOnWifiManager::WAKE_ON_NONE,
+  registry->RegisterBooleanPref(
+      prefs::kWakeOnWifiSsid,
+      true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   // Mobile plan notifications default to on.
   registry->RegisterBooleanPref(
       prefs::kShowPlanNotifications,
       true,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
   // 3G first-time usage promo will be shown at least once.
   registry->RegisterBooleanPref(
@@ skipping 59 matching lines @@
   previous_input_method_.Init(prefs::kLanguagePreviousInputMethod,
                               prefs, callback);
 
   xkb_auto_repeat_enabled_.Init(
       prefs::kLanguageXkbAutoRepeatEnabled, prefs, callback);
   xkb_auto_repeat_delay_pref_.Init(
       prefs::kLanguageXkbAutoRepeatDelay, prefs, callback);
   xkb_auto_repeat_interval_pref_.Init(
       prefs::kLanguageXkbAutoRepeatInterval, prefs, callback);
 
-  wake_on_wifi_enabled_.Init(prefs::kWakeOnWiFiEnabled, prefs, callback);
+  wake_on_wifi_ssid_.Init(prefs::kWakeOnWifiSsid, prefs, callback);
 }
 
 void Preferences::Init(Profile* profile, const user_manager::User* user) {
   DCHECK(profile);
   DCHECK(user);
   PrefServiceSyncable* prefs = PrefServiceSyncable::FromProfile(profile);
   // This causes OnIsSyncingChanged to be called when the value of
   // PrefService::IsSyncing() changes.
   prefs->AddObserver(this);
   user_ = user;
@@ skipping 194 matching lines @@
           ->SetAutoRepeatEnabled(enabled);
     }
   }
   if (reason != REASON_PREF_CHANGED ||
       pref_name == prefs::kLanguageXkbAutoRepeatDelay ||
       pref_name == prefs::kLanguageXkbAutoRepeatInterval) {
     if (user_is_active)
       UpdateAutoRepeatRate();
   }
 
-  if (user_is_primary_ && (reason != REASON_PREF_CHANGED ||
-                           pref_name == prefs::kWakeOnWiFiEnabled)) {
-    WakeOnWifiManager::Get()->OnPreferenceChanged(
-        static_cast<WakeOnWifiManager::WakeOnWifiFeature>(
-            wake_on_wifi_enabled_.GetValue()));
-  }
-
   if (reason == REASON_INITIALIZATION)
     SetInputMethodList();
 
   if (pref_name == prefs::kLanguagePreloadEngines &&
       reason == REASON_PREF_CHANGED) {
     SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
                                      language_prefs::kPreloadEnginesConfigName,
                                      preload_engines_.GetValue());
   }
 
   if ((reason == REASON_INITIALIZATION) ||
       (pref_name == prefs::kLanguageEnabledExtensionImes &&
        reason == REASON_PREF_CHANGED)) {
     std::string value(enabled_extension_imes_.GetValue());
 
     std::vector<std::string> split_values;
     if (!value.empty())
       base::SplitString(value, ',', &split_values);
 
     ime_state_->SetEnabledExtensionImes(&split_values);
   }
 
   if (user_is_active) {
     system::InputDeviceSettings::Get()->UpdateTouchpadSettings(
         touchpad_settings);
     system::InputDeviceSettings::Get()->UpdateMouseSettings(mouse_settings);
   }
+
+  if (user_is_primary_ && (reason != REASON_PREF_CHANGED ||
+                           pref_name == prefs::kWakeOnWifiSsid)) {
+    int features = wake_on_wifi_ssid_.GetValue() ?
+        WakeOnWifiManager::WAKE_ON_SSID : WakeOnWifiManager::WAKE_ON_NONE;
+    // The flag enables wake on packets but doesn't update a preference.
+    if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kWakeOnPackets))
+      features |= WakeOnWifiManager::WAKE_ON_PACKET;
+    WakeOnWifiManager::Get()->OnPreferenceChanged(
+        static_cast<WakeOnWifiManager::WakeOnWifiFeature>(features));
+  }
 }
 
 void Preferences::OnIsSyncingChanged() {
   DVLOG(1) << "OnIsSyncingChanged";
   ForceNaturalScrollDefault();
 }
 
 void Preferences::ForceNaturalScrollDefault() {
   DVLOG(1) << "ForceNaturalScrollDefault";
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 71 matching lines @@
   touch_hud_projection_enabled_.SetValue(enabled);
 }
 
 void Preferences::ActiveUserChanged(const user_manager::User* active_user) {
   if (active_user != user_)
     return;
   ApplyPreferences(REASON_ACTIVE_USER_CHANGED, "");
 }
 
 }  // namespace chromeos