Add policies to control power management on the Chrome OS login screen

This CL adds a device policy that controls power management on the login
screen. Before this CL, powerd controlled power policy on the login screen,
always using built-in defaults. After this CL, Chrome contols power policy
by explicitly sending it to powerd whenever the login screen is shown. The
built-in defaults match those that powerd used to have but they can now be
overridden through device policy.

BUG=241794
TEST=Full coverage with new unit and broweser tests

Review URL: https://chromiumcodereview.appspot.com/18153007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212024 0039d316-1c4b-4281-b951-d872f2087c98

35 files changed, 1866 insertions, 382 deletions

diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index 02d4e23..340da45 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -6120,6 +6120,9 @@ Keep your key file in a safe place. You will need it to create new versions of y
       <message name="IDS_POLICY_NETWORK_CONFIG_IMPORT_FAILED" desc="The text displayed in the status column when the corresponding network configuration policy is invalid.">
         The network configuration is invalid and couldn't be imported.
       </message>
+      <message name="IDS_POLICY_JSON_PARSE_ERROR" desc="The text displayed in the status column when a policy that should have been specified in JSON format could not be parsed.">
+        Failed to parse JSON format: <ph name="JSON_PARSE_ERROR">$1<ex>Unexpected token.</ex></ph>
+      </message>
       <message name="IDS_POLICY_OK" desc="Text displayed in the status column when a valid value is set for a policy.">
         OK
       </message>
diff --git a/chrome/app/policy/policy_templates.json b/chrome/app/policy/policy_templates.json
index 7205842..7b8dfa1 100644
--- a/chrome/app/policy/policy_templates.json
+++ b/chrome/app/policy/policy_templates.json
@@ -112,7 +112,7 @@
 #   persistent IDs for all fields (but not for groups!) are needed. These are
 #   specified by the 'id' keys of each policy. NEVER CHANGE EXISTING IDs,
 #   because doing so would break the deployed wire format!
-#   For your editing convenience: highest ID currently used: 224
+#   For your editing convenience: highest ID currently used: 225
 #
 # Placeholders:
 #   The following placeholder strings are automatically substituted:
@@ -4509,6 +4509,106 @@
       ],
     },
     {
+      # TODO(bartfab): Change the policy type to 'dict' once this is fully
+      # supported. http://crbug.com/258339
+      'name': 'DeviceLoginScreenPowerManagement',
+      'type': 'string',
+      'schema': { 'type': 'string' },
+      'supported_on': ['chrome_os:30-'],
+      'device_only': True,
+      'features': {
+        'dynamic_refresh': True,
+      },
+      'example_value': '{ "AC": { "IdleAction": "DoNothing" }, "Battery": { "IdleAction": "DoNothing" } }',
+      'id': 225,
+      'caption': '''Power mangement on the login screen''',
+      'desc': '''Configure power management on the login screen in <ph name="PRODUCT_OS_NAME">$2<ex>Google Chrome OS</ex></ph>.
+
+      This policy lets you configure how <ph name="PRODUCT_OS_NAME">$2<ex>Google Chrome OS</ex></ph> behaves when there is no user activity for some amount of time while the login screen is being shown. The policy controls multiple settings. For their individual semantics and value ranges, see the corresponding policies that control power management within a session. The only deviations from these policies are:
+      * The actions to take on idle or lid close cannot be to end the session.
+      * The default action taken on idle when running on AC power is to shut down.
+
+      The policy should be specified as a string that expresses the individual settings in JSON format, conforming to the following schema:
+      {
+        "type": "object",
+        "properties": {
+          "AC": {
+            "description": "Power management settings applicable only when running on AC power",
+            "type": "object",
+            "properties": {
+              "Delays": {
+                "type": "object",
+                "properties": {
+                  "ScreenDim": {
+                    "description": "The length of time without user input after which the screen is dimmed, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "ScreenOff": {
+                    "description": "The length of time without user input after which the screen is turned off, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "Idle": {
+                    "description": "The length of time without user input after which the idle action is taken, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  }
+                }
+              },
+              "IdleAction": {
+                "description": "Action to take when the idle delay is reached",
+                "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+              }
+            }
+          },
+          "Battery": {
+            "description": "Power management settings applicable only when running on battery power",
+            "type": "object",
+            "properties": {
+              "Delays": {
+                "type": "object",
+                "properties": {
+                  "ScreenDim": {
+                    "description": "The length of time without user input after which the screen is dimmed, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "ScreenOff": {
+                    "description": "The length of time without user input after which the screen is turned off, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  "Idle": {
+                    "description": "The length of time without user input after which the idle action is taken, in milliseconds",
+                    "type": "integer",
+                    "minimum": 0
+                  }
+                }
+              },
+              "IdleAction": {
+                "description": "Action to take when the idle delay is reached",
+                "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+              }
+            }
+          },
+          "LidCloseAction": {
+            "description": "Action to take when the lid is closed",
+            "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+          },
+          "UserActivityScreenDimDelayScale": {
+            "description": "Percentage by which the screen dim delay is scaled when user activity is observed while the screen is dimmed or soon after the screen has been turned off",
+            "type": "integer",
+            "minimum": 100
+          }
+        }
+      }
+
+      If a setting is left unspecified, a default value is used.
+
+      If this policy is unset, defaults are used for all settings.''',
+    },
+    {
       'name': 'DeviceAllowRedeemChromeOsRegistrationOffers',
       'type': 'main',
       'schema': { 'type': 'boolean' },
diff --git a/chrome/browser/chromeos/chrome_browser_main_chromeos.cc b/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
index e857e2d..dfebc21 100644
--- a/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
+++ b/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
@@ -60,6 +60,7 @@
 #include "chrome/browser/chromeos/power/idle_action_warning_observer.h"
 #include "chrome/browser/chromeos/power/peripheral_battery_observer.h"
 #include "chrome/browser/chromeos/power/power_button_observer.h"
+#include "chrome/browser/chromeos/power/power_prefs.h"
 #include "chrome/browser/chromeos/power/resume_observer.h"
 #include "chrome/browser/chromeos/power/screen_lock_observer.h"
 #include "chrome/browser/chromeos/power/suspend_observer.h"
@@ -97,6 +98,7 @@
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_library.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_policy_controller.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/ime/input_method_manager.h"
@@ -563,6 +565,9 @@ void ChromeBrowserMainPartsChromeos::PreProfileInit() {
     WizardController::SetZeroDelays();
   }
 
+  power_prefs_.reset(new PowerPrefs(
+      DBusThreadManager::Get()->GetPowerPolicyController()));
+
   // In Aura builds this will initialize ash::Shell.
   ChromeBrowserMainPartsLinux::PreProfileInit();
 
@@ -764,6 +769,7 @@ void ChromeBrowserMainPartsChromeos::PostMainMessageLoopRun() {
   brightness_observer_.reset();
   retail_mode_power_save_blocker_.reset();
   peripheral_battery_observer_.reset();
+  power_prefs_.reset();
 
   // The XInput2 event listener needs to be shut down earlier than when
   // Singletons are finally destroyed in AtExitManager.
diff --git a/chrome/browser/chromeos/chrome_browser_main_chromeos.h b/chrome/browser/chromeos/chrome_browser_main_chromeos.h
index 97e0310..f1073b0 100644
--- a/chrome/browser/chromeos/chrome_browser_main_chromeos.h
+++ b/chrome/browser/chromeos/chrome_browser_main_chromeos.h
@@ -26,6 +26,7 @@ class IdleActionWarningObserver;
 class MagnificationManager;
 class PeripheralBatteryObserver;
 class PowerButtonObserver;
+class PowerPrefs;
 class ResumeObserver;
 class ScreenLockObserver;
 class ScreensaverController;
@@ -77,6 +78,7 @@ class ChromeBrowserMainPartsChromeos : public ChromeBrowserMainPartsLinux {
   scoped_ptr<ScreenLockObserver> screen_lock_observer_;
   scoped_ptr<ScreensaverController> screensaver_controller_;
   scoped_ptr<PeripheralBatteryObserver> peripheral_battery_observer_;
+  scoped_ptr<PowerPrefs> power_prefs_;
   scoped_ptr<PowerButtonObserver> power_button_observer_;
   scoped_ptr<content::PowerSaveBlocker> retail_mode_power_save_blocker_;
   scoped_ptr<UserActivityNotifier> user_activity_notifier_;
diff --git a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
index 353b7d6..81844f2 100644
--- a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
+++ b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.cc
@@ -14,6 +14,7 @@
 #include "base/prefs/pref_value_map.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/policy/login_screen_power_management_policy.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_error_map.h"
 #include "chrome/browser/policy/policy_map.h"
@@ -192,4 +193,34 @@ void ScreenMagnifierPolicyHandler::ApplyPolicySettings(
   }
 }
 
+LoginScreenPowerManagementPolicyHandler::
+    LoginScreenPowerManagementPolicyHandler()
+    : TypeCheckingPolicyHandler(key::kDeviceLoginScreenPowerManagement,
+                                base::Value::TYPE_STRING) {
+}
+
+LoginScreenPowerManagementPolicyHandler::
+    ~LoginScreenPowerManagementPolicyHandler() {
+}
+
+bool LoginScreenPowerManagementPolicyHandler::CheckPolicySettings(
+    const PolicyMap& policies,
+    PolicyErrorMap* errors) {
+  const base::Value* value;
+  if (!CheckAndGetValue(policies, errors, &value))
+    return false;
+
+  if (!value)
+    return true;
+
+  std::string json;
+  value->GetAsString(&json);
+  return LoginScreenPowerManagementPolicy().Init(json, errors);
+}
+
+void LoginScreenPowerManagementPolicyHandler::ApplyPolicySettings(
+    const PolicyMap& policies,
+    PrefValueMap* prefs) {
+}
+
 }  // namespace policy
diff --git a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h
index 66e9303..9533d1d 100644
--- a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h
+++ b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h
@@ -78,6 +78,25 @@ class ScreenMagnifierPolicyHandler : public IntRangePolicyHandlerBase {
   DISALLOW_COPY_AND_ASSIGN(ScreenMagnifierPolicyHandler);
 };
 
+// ConfigurationPolicyHandler for login screen power management settings. This
+// does not actually set any prefs, it just checks whether the settings are
+// valid and generates errors if appropriate.
+class LoginScreenPowerManagementPolicyHandler
+    : public TypeCheckingPolicyHandler {
+ public:
+  LoginScreenPowerManagementPolicyHandler();
+  virtual ~LoginScreenPowerManagementPolicyHandler();
+
+  // TypeCheckingPolicyHandler:
+  virtual bool CheckPolicySettings(const PolicyMap& policies,
+                                   PolicyErrorMap* errors) OVERRIDE;
+  virtual void ApplyPolicySettings(const PolicyMap& policies,
+                                   PrefValueMap* prefs) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LoginScreenPowerManagementPolicyHandler);
+};
+
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_CHROMEOS_POLICY_CONFIGURATION_POLICY_HANDLER_CHROMEOS_H_
diff --git a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc
index 5e10990..761c82f 100644
--- a/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc
+++ b/chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc
@@ -16,6 +16,32 @@
 
 namespace policy {
 
+namespace {
+
+const char kLoginScreenPowerManagementPolicy[] =
+    "{"
+    "  \"AC\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 5000,"
+    "      \"ScreenOff\": 7000,"
+    "      \"Idle\": 9000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"Battery\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 1000,"
+    "      \"ScreenOff\": 3000,"
+    "      \"Idle\": 4000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"LidCloseAction\": \"DoNothing\","
+    "  \"UserActivityScreenDimDelayScale\": 300"
+    "}";
+
+}  // namespace
+
 TEST(NetworkConfigurationPolicyHandlerTest, Empty) {
   PolicyMap policy_map;
   scoped_ptr<NetworkConfigurationPolicyHandler> handler(
@@ -142,4 +168,54 @@ TEST(PinnedLauncherAppsPolicyHandler, PrefTranslation) {
   EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value));
 }
 
+TEST(LoginScreenPowerManagementPolicyHandlerTest, Empty) {
+  PolicyMap policy_map;
+  LoginScreenPowerManagementPolicyHandler handler;
+  PolicyErrorMap errors;
+  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
+  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+}
+
+TEST(LoginScreenPowerManagementPolicyHandlerTest, ValidPolicy) {
+  PolicyMap policy_map;
+  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 Value::CreateStringValue(kLoginScreenPowerManagementPolicy),
+                 NULL);
+  LoginScreenPowerManagementPolicyHandler handler;
+  PolicyErrorMap errors;
+  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
+  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+}
+
+TEST(LoginScreenPowerManagementPolicyHandlerTest, WrongType) {
+  PolicyMap policy_map;
+  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 Value::CreateBooleanValue(false),
+                 NULL);
+  LoginScreenPowerManagementPolicyHandler handler;
+  PolicyErrorMap errors;
+  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+}
+
+TEST(LoginScreenPowerManagementPolicyHandlerTest, JSONParseError) {
+  const std::string policy("I'm not proper JSON!");
+  PolicyMap policy_map;
+  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 Value::CreateStringValue(policy),
+                 NULL);
+  LoginScreenPowerManagementPolicyHandler handler;
+  PolicyErrorMap errors;
+  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+}
+
 }  // namespace policy
diff --git a/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc b/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
index 92f1fc4..7d25a8a 100644
--- a/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
+++ b/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
@@ -630,6 +630,19 @@ void DecodeGenericPolicies(const em::ChromeDeviceSettingsProto& policy,
                     NULL);
     }
   }
+
+  if (policy.has_login_screen_power_management()) {
+    const em::LoginScreenPowerManagementProto& container(
+        policy.login_screen_power_management());
+    if (container.has_login_screen_power_management()) {
+      policies->Set(key::kDeviceLoginScreenPowerManagement,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE,
+                    Value::CreateStringValue(
+                        container.login_screen_power_management()),
+                    NULL);
+    }
+  }
 }
 
 }  // namespace
diff --git a/chrome/browser/chromeos/policy/login_profile_policy_provider.cc b/chrome/browser/chromeos/policy/login_profile_policy_provider.cc
index 5eefa6b..9fc74fc 100644
--- a/chrome/browser/chromeos/policy/login_profile_policy_provider.cc
+++ b/chrome/browser/chromeos/policy/login_profile_policy_provider.cc
@@ -10,8 +10,10 @@
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/policy/login_screen_power_management_policy.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_bundle.h"
+#include "chrome/browser/policy/policy_error_map.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "policy/policy_constants.h"
@@ -23,10 +25,10 @@ namespace {
 // Applies the value of |device_policy| in |device_policy_map| as the
 // recommended value of |user_policy| in |user_policy_map|. If the value of
 // |device_policy| is unset, does nothing.
-void ApplyDevicePolicy(const std::string& device_policy,
-                       const std::string& user_policy,
-                       const PolicyMap& device_policy_map,
-                       PolicyMap* user_policy_map) {
+void ApplyDevicePolicyAsRecommendedPolicy(const std::string& device_policy,
+                                          const std::string& user_policy,
+                                          const PolicyMap& device_policy_map,
+                                          PolicyMap* user_policy_map) {
   const base::Value* value = device_policy_map.GetValue(device_policy);
   if (value) {
     user_policy_map->Set(user_policy,
@@ -37,6 +39,20 @@ void ApplyDevicePolicy(const std::string& device_policy,
   }
 }
 
+// Applies |value| as the mandatory value of |user_policy| in |user_policy_map|.
+// If |value| is NULL, does nothing.
+void ApplyValueAsMandatoryPolicy(const base::Value* value,
+                                 const std::string& user_policy,
+                                 PolicyMap* user_policy_map) {
+  if (value) {
+    user_policy_map->Set(user_policy,
+                         POLICY_LEVEL_MANDATORY,
+                         POLICY_SCOPE_USER,
+                         value->DeepCopy(),
+                         NULL);
+  }
+}
+
 }  // namespace
 
 LoginProfilePolicyProvider::LoginProfilePolicyProvider(
@@ -99,18 +115,67 @@ void LoginProfilePolicyProvider::UpdateFromDevicePolicy() {
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle);
   PolicyMap& user_policy_map = bundle->Get(chrome_namespaces);
 
-  ApplyDevicePolicy(key::kDeviceLoginScreenDefaultLargeCursorEnabled,
-                    key::kLargeCursorEnabled,
-                    device_policy_map, &user_policy_map);
-  ApplyDevicePolicy(key::kDeviceLoginScreenDefaultSpokenFeedbackEnabled,
-                    key::kSpokenFeedbackEnabled,
-                    device_policy_map, &user_policy_map);
-  ApplyDevicePolicy(key::kDeviceLoginScreenDefaultHighContrastEnabled,
-                    key::kHighContrastEnabled,
-                    device_policy_map, &user_policy_map);
-  ApplyDevicePolicy(key::kDeviceLoginScreenDefaultScreenMagnifierType,
-                    key::kScreenMagnifierType,
-                    device_policy_map, &user_policy_map);
+  ApplyDevicePolicyAsRecommendedPolicy(
+      key::kDeviceLoginScreenDefaultLargeCursorEnabled,
+      key::kLargeCursorEnabled,
+      device_policy_map, &user_policy_map);
+  ApplyDevicePolicyAsRecommendedPolicy(
+      key::kDeviceLoginScreenDefaultSpokenFeedbackEnabled,
+      key::kSpokenFeedbackEnabled,
+      device_policy_map, &user_policy_map);
+  ApplyDevicePolicyAsRecommendedPolicy(
+      key::kDeviceLoginScreenDefaultHighContrastEnabled,
+      key::kHighContrastEnabled,
+      device_policy_map, &user_policy_map);
+  ApplyDevicePolicyAsRecommendedPolicy(
+      key::kDeviceLoginScreenDefaultScreenMagnifierType,
+      key::kScreenMagnifierType,
+      device_policy_map, &user_policy_map);
+
+  // TODO(bartfab): Consolidate power management user policies into a single
+  // JSON policy, allowing the value of the device policy to be simply forwarded
+  // here. http://crbug.com/258339
+  const base::Value* value =
+      device_policy_map.GetValue(key::kDeviceLoginScreenPowerManagement);
+  std::string json;
+  if (value && value->GetAsString(&json)) {
+    LoginScreenPowerManagementPolicy power_management_policy;
+    power_management_policy.Init(json, NULL);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetScreenDimDelayAC(),
+                                key::kScreenDimDelayAC,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetScreenOffDelayAC(),
+                                key::kScreenOffDelayAC,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleDelayAC(),
+                                key::kIdleDelayAC,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(
+        power_management_policy.GetScreenDimDelayBattery(),
+        key::kScreenDimDelayBattery,
+        &user_policy_map);
+    ApplyValueAsMandatoryPolicy(
+        power_management_policy.GetScreenOffDelayBattery(),
+        key::kScreenOffDelayBattery,
+        &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleDelayBattery(),
+                                key::kIdleDelayBattery,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleActionAC(),
+                                key::kIdleActionAC,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleActionBattery(),
+                                key::kIdleActionBattery,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(power_management_policy.GetLidCloseAction(),
+                                key::kLidCloseAction,
+                                &user_policy_map);
+    ApplyValueAsMandatoryPolicy(
+        power_management_policy.GetUserActivityScreenDimDelayScale(),
+        key::kUserActivityScreenDimDelayScale,
+        &user_policy_map);
+  }
+
   UpdatePolicy(bundle.Pass());
 }
 
diff --git a/chrome/browser/chromeos/policy/login_profile_policy_provider.h b/chrome/browser/chromeos/policy/login_profile_policy_provider.h
index 47ee1af..3a7d3c4 100644
--- a/chrome/browser/chromeos/policy/login_profile_policy_provider.h
+++ b/chrome/browser/chromeos/policy/login_profile_policy_provider.h
@@ -16,7 +16,7 @@ namespace policy {
 // Policy provider for the login profile. Since the login profile is not
 // associated with any user, it does not receive regular user policy. However,
 // several device policies that control features on the login screen surface as
-// recommended user policies in the login profile.
+// user policies in the login profile.
 class LoginProfilePolicyProvider : public ConfigurationPolicyProvider,
                                    public PolicyService::Observer {
  public:
diff --git a/chrome/browser/chromeos/policy/login_screen_power_management_policy.cc b/chrome/browser/chromeos/policy/login_screen_power_management_policy.cc
new file mode 100644
index 0000000..a22aa79
--- /dev/null
+++ b/chrome/browser/chromeos/policy/login_screen_power_management_policy.cc
@@ -0,0 +1,196 @@
+// Copyright 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/policy/login_screen_power_management_policy.h"
+
+#include "base/json/json_reader.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/values.h"
+#include "chrome/browser/policy/configuration_policy_handler.h"
+#include "chrome/browser/policy/policy_error_map.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "grit/generated_resources.h"
+#include "policy/policy_constants.h"
+
+namespace policy {
+
+namespace {
+  const char kScreenDimDelayAC[] = "AC.Delays.ScreenDim";
+  const char kScreenOffDelayAC[] = "AC.Delays.ScreenOff";
+  const char kIdleDelayAC[] = "AC.Delays.Idle";
+  const char kScreenDimDelayBattery[] = "Battery.Delays.ScreenDim";
+  const char kScreenOffDelayBattery[] = "Battery.Delays.ScreenOff";
+  const char kIdleDelayBattery[] = "Battery.Delays.Idle";
+  const char kIdleActionAC[] = "AC.IdleAction";
+  const char kIdleActionBattery[] = "Battery.IdleAction";
+  const char kLidCloseAction[] = "LidCloseAction";
+  const char kUserActivityScreenDimDelayScale[] =
+      "UserActivityScreenDimDelayScale";
+
+  const char kActionSuspend[]   = "Suspend";
+  const char kActionShutdown[]  = "Shutdown";
+  const char kActionDoNothing[] = "DoNothing";
+
+scoped_ptr<base::Value> GetValue(const base::DictionaryValue* dict,
+                                 const std::string& key,
+                                 base::Value::Type type,
+                                 PolicyErrorMap* errors) {
+  const base::Value* value;
+  if (!dict->Get(key, &value))
+    return scoped_ptr<base::Value>();
+
+  if (!value->IsType(type)) {
+    if (errors) {
+      errors->AddError(key::kDeviceLoginScreenPowerManagement,
+                       key,
+                       IDS_POLICY_TYPE_ERROR,
+                       ConfigurationPolicyHandler::ValueTypeToString(type));
+    }
+    return scoped_ptr<base::Value>();
+  }
+
+  return scoped_ptr<base::Value>(value->DeepCopy());
+}
+
+scoped_ptr<base::Value> GetInteger(const base::DictionaryValue* dict,
+                                   const std::string& key,
+                                   int minimum,
+                                   PolicyErrorMap* errors) {
+  scoped_ptr<base::Value> value =
+      GetValue(dict, key, base::Value::TYPE_INTEGER, errors);
+  int integer;
+  if (!value || !value->GetAsInteger(&integer) || integer >= minimum)
+    return value.Pass();
+
+  if (errors) {
+    errors->AddError(key::kDeviceLoginScreenPowerManagement,
+                     key,
+                     IDS_POLICY_OUT_OF_RANGE_ERROR,
+                     base::IntToString(integer));
+  }
+  return scoped_ptr<base::Value>();
+}
+
+scoped_ptr<base::Value> GetAction(const base::DictionaryValue* dict,
+                                  const std::string& key,
+                                  PolicyErrorMap* errors) {
+  scoped_ptr<base::Value> value =
+      GetValue(dict, key, base::Value::TYPE_STRING, errors);
+  std::string action;
+  if (!value || !value->GetAsString(&action))
+    return value.Pass();
+
+  if (action == kActionSuspend) {
+    return scoped_ptr<base::Value>(new base::FundamentalValue(
+        chromeos::PowerPolicyController::ACTION_SUSPEND));
+  }
+  if (action == kActionShutdown) {
+    return scoped_ptr<base::Value>(new base::FundamentalValue(
+        chromeos::PowerPolicyController::ACTION_SHUT_DOWN));
+  }
+  if (action == kActionDoNothing) {
+    return scoped_ptr<base::Value>(new base::FundamentalValue(
+        chromeos::PowerPolicyController::ACTION_DO_NOTHING));
+  }
+
+  if (errors) {
+    errors->AddError(key::kDeviceLoginScreenPowerManagement,
+                     key,
+                     IDS_POLICY_OUT_OF_RANGE_ERROR,
+                     action);
+  }
+  return scoped_ptr<base::Value>();
+}
+
+}  // namespace
+
+LoginScreenPowerManagementPolicy::LoginScreenPowerManagementPolicy() {
+}
+
+LoginScreenPowerManagementPolicy::~LoginScreenPowerManagementPolicy() {
+}
+
+bool LoginScreenPowerManagementPolicy::Init(const std::string& json,
+                                            PolicyErrorMap* errors) {
+  std::string error;
+  scoped_ptr<base::Value> root(base::JSONReader::ReadAndReturnError(
+      json, base::JSON_ALLOW_TRAILING_COMMAS, NULL, &error));
+  base::DictionaryValue* dict = NULL;
+  if (!root || !root->GetAsDictionary(&dict)) {
+    if (errors) {
+      errors->AddError(key::kDeviceLoginScreenPowerManagement,
+                       IDS_POLICY_JSON_PARSE_ERROR,
+                       error);
+    }
+    // Errors in JSON decoding are fatal.
+    return false;
+  }
+
+  screen_dim_delay_ac_ = GetInteger(dict, kScreenDimDelayAC, 0, errors);
+  screen_off_delay_ac_ = GetInteger(dict, kScreenOffDelayAC, 0, errors);
+  idle_delay_ac_ = GetInteger(dict, kIdleDelayAC, 0, errors);
+  screen_dim_delay_battery_ =
+      GetInteger(dict, kScreenDimDelayBattery, 0, errors);
+  screen_off_delay_battery_ =
+      GetInteger(dict, kScreenOffDelayBattery, 0, errors);
+  idle_delay_battery_ = GetInteger(dict, kIdleDelayBattery, 0, errors);
+  idle_action_ac_ = GetAction(dict, kIdleActionAC, errors);
+  idle_action_battery_ = GetAction(dict, kIdleActionBattery, errors);
+  lid_close_action_ = GetAction(dict, kLidCloseAction, errors);
+  user_activity_screen_dim_delay_scale_ =
+      GetInteger(dict, kUserActivityScreenDimDelayScale, 100, errors);
+
+  // Validation errors for individual power policies are non-fatal as other
+  // power policies that pass validation will still be applied.
+  return true;
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetScreenDimDelayAC() const {
+  return screen_dim_delay_ac_.get();
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetScreenOffDelayAC() const {
+  return screen_off_delay_ac_.get();
+}
+
+const base::Value* LoginScreenPowerManagementPolicy::GetIdleDelayAC() const {
+  return idle_delay_ac_.get();
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetScreenDimDelayBattery() const {
+  return screen_dim_delay_battery_.get();
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetScreenOffDelayBattery() const {
+  return screen_off_delay_battery_.get();
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetIdleDelayBattery() const {
+  return idle_delay_battery_.get();
+}
+
+const base::Value* LoginScreenPowerManagementPolicy::GetIdleActionAC() const {
+  return idle_action_ac_.get();
+}
+
+const base::Value*
+    LoginScreenPowerManagementPolicy::GetIdleActionBattery() const {
+  return idle_action_battery_.get();
+}
+
+const base::Value* LoginScreenPowerManagementPolicy::GetLidCloseAction() const {
+  return lid_close_action_.get();
+}
+
+const base::Value* LoginScreenPowerManagementPolicy::
+    GetUserActivityScreenDimDelayScale() const {
+  return user_activity_screen_dim_delay_scale_.get();
+}
+
+} // namespace policy
diff --git a/chrome/browser/chromeos/policy/login_screen_power_management_policy.h b/chrome/browser/chromeos/policy/login_screen_power_management_policy.h
new file mode 100644
index 0000000..c651d06
--- /dev/null
+++ b/chrome/browser/chromeos/policy/login_screen_power_management_policy.h
@@ -0,0 +1,61 @@
+// Copyright 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_POLICY_LOGIN_SCREEN_POWER_MANAGEMENT_POLICY_H_
+#define CHROME_BROWSER_CHROMEOS_POLICY_LOGIN_SCREEN_POWER_MANAGEMENT_POLICY_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace base {
+class Value;
+}
+
+namespace policy {
+
+class PolicyErrorMap;
+
+// Parses power management policy encoded as a JSON string and extracts the
+// individual settings.
+// TODO(bartfab): Remove this code once the policy system has full support for
+// the 'dict' policy type, parsing JSON strings and verifying them against a
+// JSON schema internally. http://crbug.com/258339
+class LoginScreenPowerManagementPolicy {
+ public:
+  LoginScreenPowerManagementPolicy();
+  ~LoginScreenPowerManagementPolicy();
+
+  bool Init(const std::string& json, PolicyErrorMap* errors);
+
+  const base::Value* GetScreenDimDelayAC() const;
+  const base::Value* GetScreenOffDelayAC() const;
+  const base::Value* GetIdleDelayAC() const;
+  const base::Value* GetScreenDimDelayBattery() const;
+  const base::Value* GetScreenOffDelayBattery() const;
+  const base::Value* GetIdleDelayBattery() const;
+  const base::Value* GetIdleActionAC() const;
+  const base::Value* GetIdleActionBattery() const;
+  const base::Value* GetLidCloseAction() const;
+  const base::Value* GetUserActivityScreenDimDelayScale() const;
+
+ private:
+  scoped_ptr<base::Value> screen_dim_delay_ac_;
+  scoped_ptr<base::Value> screen_off_delay_ac_;
+  scoped_ptr<base::Value> idle_delay_ac_;
+  scoped_ptr<base::Value> screen_dim_delay_battery_;
+  scoped_ptr<base::Value> screen_off_delay_battery_;
+  scoped_ptr<base::Value> idle_delay_battery_;
+  scoped_ptr<base::Value> idle_action_ac_;
+  scoped_ptr<base::Value> idle_action_battery_;
+  scoped_ptr<base::Value> lid_close_action_;
+  scoped_ptr<base::Value> user_activity_screen_dim_delay_scale_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoginScreenPowerManagementPolicy);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_CHROMEOS_POLICY_LOGIN_SCREEN_POWER_MANAGEMENT_POLICY_H_
diff --git a/chrome/browser/chromeos/policy/login_screen_power_management_policy_unittest.cc b/chrome/browser/chromeos/policy/login_screen_power_management_policy_unittest.cc
new file mode 100644
index 0000000..b666264
--- /dev/null
+++ b/chrome/browser/chromeos/policy/login_screen_power_management_policy_unittest.cc
@@ -0,0 +1,187 @@
+// Copyright 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/policy/login_screen_power_management_policy.h"
+
+#include "chrome/browser/policy/policy_error_map.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "policy/policy_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace policy {
+
+namespace {
+
+const char kLoginScreenPowerManagementPolicy[] =
+    "{"
+    "  \"AC\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 5000,"
+    "      \"ScreenOff\": 7000,"
+    "      \"Idle\": 9000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"Battery\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 1000,"
+    "      \"ScreenOff\": 3000,"
+    "      \"Idle\": 4000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"LidCloseAction\": \"DoNothing\","
+    "  \"UserActivityScreenDimDelayScale\": 300"
+    "}";
+
+}  // namespace
+
+TEST(LoginScreenPowerManagementPolicyTest, InvalidJSON) {
+  PolicyErrorMap errors;
+  LoginScreenPowerManagementPolicy policy;
+  EXPECT_FALSE(policy.Init("Invalid JSON!", &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  EXPECT_FALSE(policy.GetScreenDimDelayAC());
+  EXPECT_FALSE(policy.GetScreenOffDelayAC());
+  EXPECT_FALSE(policy.GetIdleDelayAC());
+  EXPECT_FALSE(policy.GetScreenDimDelayBattery());
+  EXPECT_FALSE(policy.GetScreenOffDelayBattery());
+  EXPECT_FALSE(policy.GetIdleDelayBattery());
+  EXPECT_FALSE(policy.GetIdleActionAC());
+  EXPECT_FALSE(policy.GetIdleActionBattery());
+  EXPECT_FALSE(policy.GetLidCloseAction());
+  EXPECT_FALSE(policy.GetUserActivityScreenDimDelayScale());
+}
+
+TEST(LoginScreenPowerManagementPolicyTest, InitInvalidValues) {
+  PolicyErrorMap errors;
+  scoped_ptr<LoginScreenPowerManagementPolicy> policy;
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"AC\": { \"Delays\": { \"ScreenDim\": -1 } } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetScreenDimDelayAC());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"AC\": { \"Delays\": { \"ScreenOff\": -1 } } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetScreenOffDelayAC());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"AC\": { \"Delays\": { \"Idle\": -1 } } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetIdleDelayAC());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init(
+      "{ \"Battery\": { \"Delays\": { \"ScreenDim\": -1 } } }", &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetScreenDimDelayBattery());
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init(
+      "{ \"Battery\": { \"Delays\": { \"ScreenOff\": -1 } } }", &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetScreenOffDelayBattery());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"Battery\": { \"Delays\": { \"Idle\": -1 } } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetIdleDelayBattery());
+
+  errors.Clear();
+  EXPECT_TRUE(policy->Init("{ \"AC\": { \"IdleAction\": \"SignOut\" } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  EXPECT_FALSE(policy->GetIdleActionAC());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"Battery\": { \"IdleAction\": \"SignOut\" } }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetIdleActionBattery());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"LidCloseAction\": \"SignOut\" }", &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetLidCloseAction());
+
+  errors.Clear();
+  policy.reset(new LoginScreenPowerManagementPolicy);
+  EXPECT_TRUE(policy->Init("{ \"UserActivityScreenDimDelayScale\": 50 }",
+                           &errors));
+  EXPECT_FALSE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy);
+  EXPECT_FALSE(policy->GetUserActivityScreenDimDelayScale());
+}
+
+TEST(LoginScreenPowerManagementPolicyTest, ValidJSON) {
+  PolicyErrorMap errors;
+  LoginScreenPowerManagementPolicy policy;
+  EXPECT_TRUE(policy.Init(kLoginScreenPowerManagementPolicy, &errors));
+  EXPECT_TRUE(
+      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
+  ASSERT_TRUE(policy.GetScreenDimDelayAC());
+  EXPECT_TRUE(base::FundamentalValue(5000).Equals(
+      policy.GetScreenDimDelayAC()));
+  ASSERT_TRUE(policy.GetScreenOffDelayAC());
+  EXPECT_TRUE(base::FundamentalValue(7000).Equals(
+      policy.GetScreenOffDelayAC()));
+  ASSERT_TRUE(policy.GetIdleDelayAC());
+  EXPECT_TRUE(base::FundamentalValue(9000).Equals(policy.GetIdleDelayAC()));
+  ASSERT_TRUE(policy.GetScreenDimDelayBattery());
+  EXPECT_TRUE(base::FundamentalValue(1000).Equals(
+      policy.GetScreenDimDelayBattery()));
+  ASSERT_TRUE(policy.GetScreenOffDelayBattery());
+  EXPECT_TRUE(base::FundamentalValue(3000).Equals(
+      policy.GetScreenOffDelayBattery()));
+  ASSERT_TRUE(policy.GetIdleDelayBattery());
+  EXPECT_TRUE(base::FundamentalValue(4000).Equals(
+      policy.GetIdleDelayBattery()));
+  ASSERT_TRUE(policy.GetIdleActionAC());
+  EXPECT_TRUE(base::FundamentalValue(
+      chromeos::PowerPolicyController::ACTION_DO_NOTHING).Equals(
+          policy.GetIdleActionAC()));
+  ASSERT_TRUE(policy.GetIdleActionBattery());
+  EXPECT_TRUE(base::FundamentalValue(
+      chromeos::PowerPolicyController::ACTION_DO_NOTHING).Equals(
+          policy.GetIdleActionBattery()));
+  ASSERT_TRUE(policy.GetLidCloseAction());
+  EXPECT_TRUE(base::FundamentalValue(
+      chromeos::PowerPolicyController::ACTION_DO_NOTHING).Equals(
+          policy.GetLidCloseAction()));
+  ASSERT_TRUE(policy.GetUserActivityScreenDimDelayScale());
+  EXPECT_TRUE(base::FundamentalValue(300).Equals(
+      policy.GetUserActivityScreenDimDelayScale()));
+}
+
+}  // namespace policy
diff --git a/chrome/browser/chromeos/policy/power_policy_browsertest.cc b/chrome/browser/chromeos/policy/power_policy_browsertest.cc
index 718d31e..37a0ca1 100644
--- a/chrome/browser/chromeos/policy/power_policy_browsertest.cc
+++ b/chrome/browser/chromeos/policy/power_policy_browsertest.cc
@@ -3,203 +3,381 @@
 // found in the LICENSE file.
 
 #include <string>
+#include <vector>
 
+#include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
 #include "base/run_loop.h"
-#include "base/values.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/policy/device_policy_builder.h"
+#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
+#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
+#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/extensions/api/power/power_api_manager.h"
-#include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/policy/cloud/cloud_policy_core.h"
+#include "chrome/browser/policy/cloud/cloud_policy_store.h"
+#include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
-#include "chrome/browser/policy/mock_configuration_policy_provider.h"
-#include "chrome/browser/policy/policy_map.h"
-#include "chrome/browser/policy/policy_types.h"
+#include "chrome/browser/policy/mock_policy_service.h"
+#include "chrome/browser/policy/policy_service.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_factory.h"
+#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
+#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/power.h"
-#include "chrome/test/base/in_process_browser_test.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chromeos/chromeos_paths.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
+#include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_policy_controller.h"
-#include "policy/policy_constants.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/test/test_utils.h"
+#include "crypto/rsa_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
-namespace policy {
-
-namespace {
+namespace em = enterprise_management;
+namespace pm = power_manager;
 
 using ::testing::AnyNumber;
-using ::testing::Return;
+using ::testing::InvokeWithoutArgs;
 using ::testing::_;
 
-namespace pm = power_manager;
+namespace policy {
+
+namespace {
+
+const char kLoginScreenPowerManagementPolicy[] =
+    "{"
+    "  \"AC\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 5000,"
+    "      \"ScreenOff\": 7000,"
+    "      \"Idle\": 9000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"Battery\": {"
+    "    \"Delays\": {"
+    "      \"ScreenDim\": 1000,"
+    "      \"ScreenOff\": 3000,"
+    "      \"Idle\": 4000"
+    "    },"
+    "    \"IdleAction\": \"DoNothing\""
+    "  },"
+    "  \"LidCloseAction\": \"DoNothing\","
+    "  \"UserActivityScreenDimDelayScale\": 300"
+    "}";
 
 }  // namespace
 
-class PowerPolicyBrowserTest : public InProcessBrowserTest {
+class PowerPolicyBrowserTestBase : public DevicePolicyCrosBrowserTest {
  protected:
-  // InProcessBrowserTest:
+  PowerPolicyBrowserTestBase();
+
+  // DevicePolicyCrosBrowserTest:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
+  virtual void SetUpOnMainThread() OVERRIDE;
 
-  // Sets |user_policy_name| to |user_policy_value|.
-  void SetUserPolicy(const std::string& user_policy_name,
-                     base::Value* user_policy_value);
+  void InstallUserKey();
+  void StoreAndReloadUserPolicy();
+
+  void StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
 
   // Returns a string describing |policy|.
   std::string GetDebugString(const pm::PowerManagementPolicy& policy);
 
+  UserPolicyBuilder user_policy_;
+
   chromeos::FakePowerManagerClient* power_manager_client_;
 
  private:
-  MockConfigurationPolicyProvider provider_;
+  // Runs |closure| and waits for |profile|'s user policy to be updated as a
+  // result.
+  void RunClosureAndWaitForUserPolicyUpdate(const base::Closure& closure,
+                                            Profile* profile);
+
+  // Reloads user policy for |profile| from session manager client.
+  void ReloadUserPolicy(Profile* profile);
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyBrowserTestBase);
 };
 
-void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
-  chromeos::MockDBusThreadManagerWithoutGMock* dbus_thread_manager =
-      new chromeos::MockDBusThreadManagerWithoutGMock;
-  power_manager_client_ = dbus_thread_manager->fake_power_manager_client();
-  chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager);
-  EXPECT_CALL(provider_, IsInitializationComplete(_))
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
-  BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
-}
-
-void PowerPolicyBrowserTest::SetUserPolicy(
-    const std::string& user_policy_name,
-    base::Value* user_policy_value) {
-  PolicyMap policy_map;
-  policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                 user_policy_value, NULL);
-  provider_.UpdateChromePolicy(policy_map);
-  base::RunLoop().RunUntilIdle();
+class PowerPolicyLoginScreenBrowserTest : public PowerPolicyBrowserTestBase {
+ protected:
+  PowerPolicyLoginScreenBrowserTest();
+
+  // PowerPolicyBrowserTestBase:
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
+  virtual void SetUpOnMainThread() OVERRIDE;
+  virtual void CleanUpOnMainThread() OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyLoginScreenBrowserTest);
+};
+
+class PowerPolicyInSessionBrowserTest : public PowerPolicyBrowserTestBase {
+ protected:
+  PowerPolicyInSessionBrowserTest();
+
+  // PowerPolicyBrowserTestBase:
+  virtual void SetUpOnMainThread() OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPolicyInSessionBrowserTest);
+};
+
+PowerPolicyBrowserTestBase::PowerPolicyBrowserTestBase()
+    : power_manager_client_(NULL) {
+}
+
+void PowerPolicyBrowserTestBase::SetUpInProcessBrowserTestFixture() {
+  DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
+
+  // Initialize device policy.
+  InstallOwnerKey();
+  MarkAsEnterpriseOwned();
+
+  power_manager_client_ =
+      mock_dbus_thread_manager()->fake_power_manager_client();
+}
+
+void PowerPolicyBrowserTestBase::SetUpOnMainThread() {
+  DevicePolicyCrosBrowserTest::SetUpOnMainThread();
+
+  // Initialize user policy.
+  InstallUserKey();
+  user_policy_.policy_data().set_username(chromeos::UserManager::kStubUser);
 }
 
-std::string PowerPolicyBrowserTest::GetDebugString(
+void PowerPolicyBrowserTestBase::InstallUserKey() {
+  base::FilePath user_keys_dir;
+  ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &user_keys_dir));
+  base::FilePath user_key_file =
+      user_keys_dir.AppendASCII(chromeos::UserManager::kStubUser)
+                   .AppendASCII("policy.pub");
+  std::vector<uint8> user_key_bits;
+  ASSERT_TRUE(user_policy_.signing_key()->ExportPublicKey(&user_key_bits));
+  ASSERT_TRUE(file_util::CreateDirectory(user_key_file.DirName()));
+  ASSERT_EQ(file_util::WriteFile(
+                user_key_file,
+                reinterpret_cast<const char*>(user_key_bits.data()),
+                user_key_bits.size()),
+            static_cast<int>(user_key_bits.size()));
+}
+
+void PowerPolicyBrowserTestBase::StoreAndReloadUserPolicy() {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  Profile* profile = profile_manager->GetProfileByPath(
+      profile_manager->user_data_dir().Append(
+          TestingProfile::kTestUserProfileDir));
+  ASSERT_TRUE(profile);
+
+  // Install the new user policy blob in session manager client.
+  user_policy_.Build();
+  session_manager_client()->set_user_policy(
+      user_policy_.policy_data().username(),
+      user_policy_.GetBlob());
+
+  // Reload user policy from session manager client and wait for the update to
+  // take effect.
+  RunClosureAndWaitForUserPolicyUpdate(
+      base::Bind(&PowerPolicyBrowserTestBase::ReloadUserPolicy, this, profile),
+      profile);
+}
+
+void PowerPolicyBrowserTestBase::
+    StoreAndReloadDevicePolicyAndWaitForLoginProfileChange() {
+  Profile* profile = chromeos::ProfileHelper::GetSigninProfile();
+  ASSERT_TRUE(profile);
+
+  // Install the new device policy blob in session manager client, reload device
+  // policy from session manager client and wait for a change in the login
+  // profile's policy to be observed.
+  RunClosureAndWaitForUserPolicyUpdate(
+      base::Bind(&PowerPolicyBrowserTestBase::RefreshDevicePolicy, this),
+      profile);
+}
+
+std::string PowerPolicyBrowserTestBase::GetDebugString(
     const pm::PowerManagementPolicy& policy) {
   return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
 }
 
-IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
-  pm::PowerManagementPolicy original_power_management_policy =
-      power_manager_client_->get_policy();
-
-  pm::PowerManagementPolicy power_management_policy =
-      original_power_management_policy;
-  power_management_policy.set_ac_idle_action(
-      pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kIdleActionAC,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyBrowserTestBase::RunClosureAndWaitForUserPolicyUpdate(
+    const base::Closure& closure,
+    Profile* profile) {
+  base::RunLoop run_loop;
+  MockPolicyServiceObserver observer;
+  EXPECT_CALL(observer, OnPolicyUpdated(_, _, _))
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(AnyNumber());
+  PolicyService* policy_service =
+      ProfilePolicyConnectorFactory::GetForProfile(profile)->policy_service();
+  ASSERT_TRUE(policy_service);
+  policy_service->AddObserver(POLICY_DOMAIN_CHROME, &observer);
+  closure.Run();
+  run_loop.Run();
+  policy_service->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.set_battery_idle_action(
-      pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kIdleActionBattery,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyBrowserTestBase::ReloadUserPolicy(Profile* profile) {
+  UserCloudPolicyManagerChromeOS* policy_manager =
+      UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
+  ASSERT_TRUE(policy_manager);
+  policy_manager->core()->store()->Load();
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.set_lid_closed_action(
-      pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicy(
-      key::kLidCloseAction,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+PowerPolicyLoginScreenBrowserTest::PowerPolicyLoginScreenBrowserTest() {
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
-  SetUserPolicy(key::kIdleDelayAC, base::Value::CreateIntegerValue(9000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyLoginScreenBrowserTest::SetUpCommandLine(
+    CommandLine* command_line) {
+  PowerPolicyBrowserTestBase::SetUpCommandLine(command_line);
+  command_line->AppendSwitch(chromeos::switches::kLoginManager);
+  command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
-  SetUserPolicy(key::kIdleWarningDelayAC,
-                base::Value::CreateIntegerValue(8000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyLoginScreenBrowserTest::SetUpOnMainThread() {
+  PowerPolicyBrowserTestBase::SetUpOnMainThread();
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
-  SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+  // Wait for the login screen to be shown.
+  content::WindowedNotificationObserver(
+      chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE,
+      content::NotificationService::AllSources()).Wait();
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
-  SetUserPolicy(key::kScreenDimDelayAC, base::Value::CreateIntegerValue(5000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyLoginScreenBrowserTest::CleanUpOnMainThread() {
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(&chrome::AttemptExit));
+  base::RunLoop().RunUntilIdle();
+  PowerPolicyBrowserTestBase::CleanUpOnMainThread();
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
-  SetUserPolicy(key::kScreenLockDelayAC, base::Value::CreateIntegerValue(6000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+PowerPolicyInSessionBrowserTest::PowerPolicyInSessionBrowserTest() {
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
-  SetUserPolicy(key::kIdleDelayBattery, base::Value::CreateIntegerValue(5000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+void PowerPolicyInSessionBrowserTest::SetUpOnMainThread() {
+  PowerPolicyBrowserTestBase::SetUpOnMainThread();
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
-  SetUserPolicy(key::kIdleWarningDelayBattery,
-                base::Value::CreateIntegerValue(4000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+  // Tell the DeviceSettingsService that there is no local owner.
+  chromeos::DeviceSettingsService::Get()->SetUsername(std::string());
+}
 
-  power_management_policy = original_power_management_policy;
+// Verifies that device policy is applied on the login screen.
+IN_PROC_BROWSER_TEST_F(PowerPolicyLoginScreenBrowserTest, SetDevicePolicy) {
+  pm::PowerManagementPolicy power_management_policy =
+      power_manager_client_->get_policy();
+  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
+  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
+  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
+  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
   power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
-  SetUserPolicy(key::kScreenOffDelayBattery,
-                base::Value::CreateIntegerValue(3000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+  power_management_policy.mutable_battery_delays()->set_idle_ms(4000);
+  power_management_policy.set_ac_idle_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  power_management_policy.set_battery_idle_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  power_management_policy.set_lid_closed_action(
+      pm::PowerManagementPolicy::DO_NOTHING);
+  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
-  SetUserPolicy(key::kScreenDimDelayBattery,
-                base::Value::CreateIntegerValue(1000));
+  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
+  proto.mutable_login_screen_power_management()->
+      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
+  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_policy()));
+}
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
-  SetUserPolicy(key::kScreenLockDelayBattery,
-                base::Value::CreateIntegerValue(2000));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
+// Verifies that device policy is ignored during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetDevicePolicy) {
+  pm::PowerManagementPolicy power_management_policy =
+      power_manager_client_->get_policy();
 
-  power_management_policy = original_power_management_policy;
-  power_management_policy.set_use_audio_activity(false);
-  SetUserPolicy(key::kPowerManagementUsesAudioActivity,
-                base::Value::CreateBooleanValue(false));
+  em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
+  proto.mutable_login_screen_power_management()->
+      set_login_screen_power_management(kLoginScreenPowerManagementPolicy);
+  StoreAndReloadDevicePolicyAndWaitForLoginProfileChange();
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_policy()));
+}
 
-  power_management_policy = original_power_management_policy;
+// Verifies that user policy is applied during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, SetUserPolicy) {
+  pm::PowerManagementPolicy power_management_policy =
+      power_manager_client_->get_policy();
+  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
+  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
+  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
+  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
+  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
+  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
+  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
+  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
+  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
+  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
+  power_management_policy.set_use_audio_activity(false);
   power_management_policy.set_use_video_activity(false);
-  SetUserPolicy(key::kPowerManagementUsesVideoActivity,
-                base::Value::CreateBooleanValue(false));
-  EXPECT_EQ(GetDebugString(power_management_policy),
-            GetDebugString(power_manager_client_->get_policy()));
-
-  power_management_policy = original_power_management_policy;
+  power_management_policy.set_ac_idle_action(
+      pm::PowerManagementPolicy::STOP_SESSION);
+  power_management_policy.set_battery_idle_action(
+      pm::PowerManagementPolicy::STOP_SESSION);
+  power_management_policy.set_lid_closed_action(
+      pm::PowerManagementPolicy::STOP_SESSION);
   power_management_policy.set_presentation_screen_dim_delay_factor(3.0);
-  SetUserPolicy(key::kPresentationScreenDimDelayScale,
-                base::Value::CreateIntegerValue(300));
+  power_management_policy.set_user_activity_screen_dim_delay_factor(3.0);
+
+  user_policy_.payload().mutable_screendimdelayac()->set_value(5000);
+  user_policy_.payload().mutable_screenlockdelayac()->set_value(6000);
+  user_policy_.payload().mutable_screenoffdelayac()->set_value(7000);
+  user_policy_.payload().mutable_idlewarningdelayac()->set_value(8000);
+  user_policy_.payload().mutable_idledelayac()->set_value(9000);
+  user_policy_.payload().mutable_screendimdelaybattery()->set_value(1000);
+  user_policy_.payload().mutable_screenlockdelaybattery()->set_value(2000);
+  user_policy_.payload().mutable_screenoffdelaybattery()->set_value(3000);
+  user_policy_.payload().mutable_idlewarningdelaybattery()->set_value(4000);
+  user_policy_.payload().mutable_idledelaybattery()->set_value(5000);
+  user_policy_.payload().mutable_powermanagementusesaudioactivity()->set_value(
+      false);
+  user_policy_.payload().mutable_powermanagementusesvideoactivity()->set_value(
+      false);
+  user_policy_.payload().mutable_idleactionac()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  user_policy_.payload().mutable_idleactionbattery()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  user_policy_.payload().mutable_lidcloseaction()->set_value(
+      chromeos::PowerPolicyController::ACTION_STOP_SESSION);
+  user_policy_.payload().mutable_presentationscreendimdelayscale()->set_value(
+      300);
+  user_policy_.payload().mutable_useractivityscreendimdelayscale()->set_value(
+      300);
+  StoreAndReloadUserPolicy();
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_policy()));
 }
 
-IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, AllowScreenWakeLocks) {
+// Verifies that screen wake locks can be enabled and disabled by extensions and
+// user policy during a session.
+IN_PROC_BROWSER_TEST_F(PowerPolicyInSessionBrowserTest, AllowScreenWakeLocks) {
   pm::PowerManagementPolicy baseline_policy =
       power_manager_client_->get_policy();
 
@@ -216,7 +394,8 @@ IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, AllowScreenWakeLocks) {
       kExtensionId, extensions::api::power::LEVEL_DISPLAY);
   base::RunLoop().RunUntilIdle();
 
-  // Check that the lock is in effect (ignoring idle_action and reason).
+  // Check that the lock is in effect (ignoring ac_idle_action,
+  // battery_idle_action and reason).
   pm::PowerManagementPolicy policy = baseline_policy;
   policy.mutable_ac_delays()->set_screen_dim_ms(0);
   policy.mutable_ac_delays()->set_screen_off_ms(0);
@@ -230,9 +409,9 @@ IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, AllowScreenWakeLocks) {
   EXPECT_EQ(GetDebugString(policy),
             GetDebugString(power_manager_client_->get_policy()));
 
-  // Engage the policy and verify that the defaults take effect again.
-  SetUserPolicy(key::kAllowScreenWakeLocks,
-                base::Value::CreateBooleanValue(false));
+  // Engage the user policy and verify that the defaults take effect again.
+  user_policy_.payload().mutable_allowscreenwakelocks()->set_value(false);
+  StoreAndReloadUserPolicy();
   policy = baseline_policy;
   policy.set_ac_idle_action(
       power_manager_client_->get_policy().ac_idle_action());
diff --git a/chrome/browser/chromeos/power/power_prefs.cc b/chrome/browser/chromeos/power/power_prefs.cc
new file mode 100644
index 0000000..60fc213
--- /dev/null
+++ b/chrome/browser/chromeos/power/power_prefs.cc
@@ -0,0 +1,267 @@
+// Copyright 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/power/power_prefs.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/prefs/pref_change_registrar.h"
+#include "base/prefs/pref_service.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/pref_names.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "components/user_prefs/pref_registry_syncable.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+
+namespace chromeos {
+
+PowerPrefs::PowerPrefs(PowerPolicyController* power_policy_controller)
+    : power_policy_controller_(power_policy_controller),
+      profile_(NULL) {
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE,
+                              content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_SESSION_STARTED,
+                              content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_PROFILE_DESTROYED,
+                              content::NotificationService::AllSources());
+}
+
+PowerPrefs::~PowerPrefs() {
+}
+
+// static
+void PowerPrefs::RegisterUserProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  RegisterProfilePrefs(registry);
+
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryIdleAction,
+      PowerPolicyController::ACTION_SUSPEND,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerLidClosedAction,
+      PowerPolicyController::ACTION_SUSPEND,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+// static
+void PowerPrefs::RegisterLoginProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  RegisterProfilePrefs(registry);
+
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryIdleAction,
+      PowerPolicyController::ACTION_SHUT_DOWN,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerLidClosedAction,
+      PowerPolicyController::ACTION_SHUT_DOWN,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+void PowerPrefs::Observe(int type,
+                         const content::NotificationSource& source,
+                         const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE:
+      // Update |profile_| when entering the login screen.
+      SetProfile(ProfileHelper::GetSigninProfile());
+      break;
+    case chrome::NOTIFICATION_SESSION_STARTED:
+      // Update |profile_| when entering a session.
+      SetProfile(ProfileManager::GetDefaultProfile());
+      break;
+    case chrome::NOTIFICATION_PROFILE_DESTROYED: {
+      // Update |profile_| when exiting a session or shutting down.
+      Profile* profile = content::Source<Profile>(source).ptr();
+      if (profile_ == profile)
+        SetProfile(NULL);
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void PowerPrefs::UpdatePowerPolicyFromPrefs() {
+  if (!pref_change_registrar_ || !pref_change_registrar_->prefs()) {
+    NOTREACHED();
+    return;
+  }
+
+  const PrefService* prefs = pref_change_registrar_->prefs();
+  PowerPolicyController::PrefValues values;
+  values.ac_screen_dim_delay_ms =
+      prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs);
+  values.ac_screen_off_delay_ms =
+      prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs);
+  values.ac_screen_lock_delay_ms =
+      prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs);
+  values.ac_idle_warning_delay_ms =
+      prefs->GetInteger(prefs::kPowerAcIdleWarningDelayMs);
+  values.ac_idle_delay_ms =
+      prefs->GetInteger(prefs::kPowerAcIdleDelayMs);
+  values.battery_screen_dim_delay_ms =
+      prefs->GetInteger(prefs::kPowerBatteryScreenDimDelayMs);
+  values.battery_screen_off_delay_ms =
+      prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs);
+  values.battery_screen_lock_delay_ms =
+      prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs);
+  values.battery_idle_warning_delay_ms =
+      prefs->GetInteger(prefs::kPowerBatteryIdleWarningDelayMs);
+  values.battery_idle_delay_ms =
+      prefs->GetInteger(prefs::kPowerBatteryIdleDelayMs);
+  values.ac_idle_action = static_cast<PowerPolicyController::Action>(
+      prefs->GetInteger(prefs::kPowerAcIdleAction));
+  values.battery_idle_action = static_cast<PowerPolicyController::Action>(
+      prefs->GetInteger(prefs::kPowerBatteryIdleAction));
+  values.lid_closed_action = static_cast<PowerPolicyController::Action>(
+      prefs->GetInteger(prefs::kPowerLidClosedAction));
+  values.use_audio_activity =
+      prefs->GetBoolean(prefs::kPowerUseAudioActivity);
+  values.use_video_activity =
+      prefs->GetBoolean(prefs::kPowerUseVideoActivity);
+  values.allow_screen_wake_locks =
+      prefs->GetBoolean(prefs::kPowerAllowScreenWakeLocks);
+  values.enable_screen_lock =
+      prefs->GetBoolean(prefs::kEnableScreenLock);
+  values.presentation_screen_dim_delay_factor =
+      prefs->GetDouble(prefs::kPowerPresentationScreenDimDelayFactor);
+  values.user_activity_screen_dim_delay_factor =
+      prefs->GetDouble(prefs::kPowerUserActivityScreenDimDelayFactor);
+
+  power_policy_controller_->ApplyPrefs(values);
+}
+
+// static
+void PowerPrefs::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcScreenDimDelayMs,
+      420000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcScreenOffDelayMs,
+      480000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcScreenLockDelayMs,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcIdleWarningDelayMs,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcIdleDelayMs,
+      1800000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryScreenDimDelayMs,
+      300000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryScreenOffDelayMs,
+      360000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryScreenLockDelayMs,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryIdleWarningDelayMs,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerBatteryIdleDelayMs,
+      600000,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPowerAcIdleAction,
+      PowerPolicyController::ACTION_SUSPEND,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kPowerUseAudioActivity,
+      true,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kPowerUseVideoActivity,
+      true,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kPowerAllowScreenWakeLocks,
+      true,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kEnableScreenLock,
+      false,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDoublePref(
+      prefs::kPowerPresentationScreenDimDelayFactor,
+      2.0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterDoublePref(
+      prefs::kPowerUserActivityScreenDimDelayFactor,
+      2.0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+void PowerPrefs::SetProfile(Profile* profile) {
+  profile_ = profile;
+  pref_change_registrar_.reset();
+
+  if (!profile) {
+    power_policy_controller_->ClearPrefs();
+    return;
+  }
+
+  base::Closure update_callback(base::Bind(
+      &PowerPrefs::UpdatePowerPolicyFromPrefs,
+      base::Unretained(this)));
+  pref_change_registrar_.reset(new PrefChangeRegistrar);
+  pref_change_registrar_->Init(profile->GetPrefs());
+  pref_change_registrar_->Add(prefs::kPowerAcScreenDimDelayMs, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAcScreenOffDelayMs, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAcScreenLockDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAcIdleWarningDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAcIdleDelayMs, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenDimDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenOffDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryScreenLockDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryIdleWarningDelayMs,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryIdleDelayMs, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAcIdleAction, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerBatteryIdleAction, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerLidClosedAction, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerUseAudioActivity, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerUseVideoActivity, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerAllowScreenWakeLocks,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kEnableScreenLock, update_callback);
+  pref_change_registrar_->Add(prefs::kPowerPresentationScreenDimDelayFactor,
+                              update_callback);
+  pref_change_registrar_->Add(prefs::kPowerUserActivityScreenDimDelayFactor,
+                              update_callback);
+
+  UpdatePowerPolicyFromPrefs();
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/power/power_prefs.h b/chrome/browser/chromeos/power/power_prefs.h
new file mode 100644
index 0000000..db2c82f
--- /dev/null
+++ b/chrome/browser/chromeos/power/power_prefs.h
@@ -0,0 +1,68 @@
+// Copyright 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_POWER_POWER_PREFS_H_
+#define CHROME_BROWSER_CHROMEOS_POWER_POWER_PREFS_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+
+class PrefChangeRegistrar;
+class Profile;
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
+namespace chromeos {
+
+class PowerPolicyController;
+
+// Sends an updated power policy to the |power_policy_controller| whenever one
+// of the power-related prefs changes.
+class PowerPrefs : public content::NotificationObserver {
+ public:
+  explicit PowerPrefs(PowerPolicyController* power_policy_controller);
+  virtual ~PowerPrefs();
+
+  // Register power prefs with default values applicable to a user profile.
+  static void RegisterUserProfilePrefs(
+      user_prefs::PrefRegistrySyncable* registry);
+
+  // Register power prefs with default values applicable to the login profile.
+  static void RegisterLoginProfilePrefs(
+      user_prefs::PrefRegistrySyncable* registry);
+
+  // content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  void UpdatePowerPolicyFromPrefs();
+
+ private:
+  friend class PowerPrefsTest;
+
+  // Register power prefs whose default values are the same in user profiles and
+  // the login profile.
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  void SetProfile(Profile* profile);
+
+  PowerPolicyController* power_policy_controller_;  // Not owned.
+
+  content::NotificationRegistrar notification_registrar_;
+
+  Profile* profile_;  // Not owned.
+  scoped_ptr<PrefChangeRegistrar> pref_change_registrar_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPrefs);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_POWER_POWER_PREFS_H_
diff --git a/chrome/browser/chromeos/power/power_prefs_unittest.cc b/chrome/browser/chromeos/power/power_prefs_unittest.cc
new file mode 100644
index 0000000..27deca2
--- /dev/null
+++ b/chrome/browser/chromeos/power/power_prefs_unittest.cc
@@ -0,0 +1,250 @@
+// Copyright 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/power/power_prefs.h"
+
+#include <string>
+
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/prefs/pref_service.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/extension_special_storage_policy.h"
+#include "chrome/browser/prefs/browser_prefs.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/fake_power_manager_client.h"
+#include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
+#include "chromeos/dbus/power_manager/policy.pb.h"
+#include "chromeos/dbus/power_policy_controller.h"
+#include "components/user_prefs/pref_registry_syncable.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+class PowerPrefsTest : public testing::Test {
+ protected:
+  PowerPrefsTest();
+
+  // testing::Test:
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+
+  const Profile* GetProfile() const;
+
+  std::string GetExpectedPowerPolicyForProfile(Profile* profile) const;
+  std::string GetCurrentPowerPolicy() const;
+  bool GetExpectedAllowScreenWakeLocksForProfile(Profile* profile) const;
+  bool GetCurrentAllowScreenWakeLocks() const;
+
+  TestingProfileManager profile_manager_;
+  MockDBusThreadManagerWithoutGMock mock_dbus_thread_manager_;
+  PowerPolicyController* power_policy_controller_;     // Not owned.
+  FakePowerManagerClient* fake_power_manager_client_;  // Not owned.
+
+  scoped_ptr<PowerPrefs> power_prefs_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerPrefsTest);
+};
+
+PowerPrefsTest::PowerPrefsTest()
+    : profile_manager_(TestingBrowserProcess::GetGlobal()),
+      power_policy_controller_(
+          mock_dbus_thread_manager_.GetPowerPolicyController()),
+      fake_power_manager_client_(
+          mock_dbus_thread_manager_.fake_power_manager_client()) {
+}
+
+void PowerPrefsTest::SetUp() {
+  testing::Test::SetUp();
+  ASSERT_TRUE(profile_manager_.SetUp());
+
+  power_prefs_.reset(new PowerPrefs(power_policy_controller_));
+  EXPECT_FALSE(GetProfile());
+  EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(
+                power_manager::PowerManagementPolicy()),
+            GetCurrentPowerPolicy());
+}
+
+void PowerPrefsTest::TearDown() {
+  power_prefs_.reset();
+  testing::Test::TearDown();
+}
+
+const Profile* PowerPrefsTest::GetProfile() const {
+  return power_prefs_->profile_;
+}
+
+std::string PowerPrefsTest::GetExpectedPowerPolicyForProfile(
+    Profile* profile) const {
+  const PrefService* prefs = profile->GetPrefs();
+  power_manager::PowerManagementPolicy expected_policy;
+  expected_policy.mutable_ac_delays()->set_screen_dim_ms(
+      prefs->GetInteger(prefs::kPowerAcScreenDimDelayMs));
+  expected_policy.mutable_ac_delays()->set_screen_off_ms(
+      prefs->GetInteger(prefs::kPowerAcScreenOffDelayMs));
+  expected_policy.mutable_ac_delays()->set_screen_lock_ms(
+      prefs->GetInteger(prefs::kPowerAcScreenLockDelayMs));
+  expected_policy.mutable_ac_delays()->set_idle_warning_ms(
+      prefs->GetInteger(prefs::kPowerAcIdleWarningDelayMs));
+  expected_policy.mutable_ac_delays()->set_idle_ms(
+      prefs->GetInteger(prefs::kPowerAcIdleDelayMs));
+  expected_policy.mutable_battery_delays()->set_screen_dim_ms(
+      prefs->GetInteger(prefs::kPowerBatteryScreenDimDelayMs));
+  expected_policy.mutable_battery_delays()->set_screen_off_ms(
+      prefs->GetInteger(prefs::kPowerBatteryScreenOffDelayMs));
+  expected_policy.mutable_battery_delays()->set_screen_lock_ms(
+      prefs->GetInteger(prefs::kPowerBatteryScreenLockDelayMs));
+  expected_policy.mutable_battery_delays()->set_idle_warning_ms(
+      prefs->GetInteger(prefs::kPowerBatteryIdleWarningDelayMs));
+  expected_policy.mutable_battery_delays()->set_idle_ms(
+      prefs->GetInteger(prefs::kPowerBatteryIdleDelayMs));
+  expected_policy.set_ac_idle_action(
+      static_cast<power_manager::PowerManagementPolicy_Action>(
+            prefs->GetInteger(prefs::kPowerAcIdleAction)));
+  expected_policy.set_battery_idle_action(
+      static_cast<power_manager::PowerManagementPolicy_Action>(
+            prefs->GetInteger(prefs::kPowerBatteryIdleAction)));
+  expected_policy.set_lid_closed_action(
+      static_cast<power_manager::PowerManagementPolicy_Action>(
+            prefs->GetInteger(prefs::kPowerLidClosedAction)));
+  expected_policy.set_use_audio_activity(
+      prefs->GetBoolean(prefs::kPowerUseAudioActivity));
+  expected_policy.set_use_video_activity(
+      prefs->GetBoolean(prefs::kPowerUseVideoActivity));
+  expected_policy.set_presentation_screen_dim_delay_factor(
+      prefs->GetDouble(prefs::kPowerPresentationScreenDimDelayFactor));
+  expected_policy.set_user_activity_screen_dim_delay_factor(
+      prefs->GetDouble(prefs::kPowerUserActivityScreenDimDelayFactor));
+  expected_policy.set_reason("Prefs");
+  return PowerPolicyController::GetPolicyDebugString(expected_policy);
+}
+
+std::string PowerPrefsTest::GetCurrentPowerPolicy() const {
+  return PowerPolicyController::GetPolicyDebugString(
+      fake_power_manager_client_->get_policy());
+}
+
+bool PowerPrefsTest::GetCurrentAllowScreenWakeLocks() const {
+  return power_policy_controller_->honor_screen_wake_locks_;
+}
+
+bool PowerPrefsTest::GetExpectedAllowScreenWakeLocksForProfile(
+    Profile* profile) const {
+  return profile->GetPrefs()->GetBoolean(prefs::kPowerAllowScreenWakeLocks);
+}
+
+TEST_F(PowerPrefsTest, LoginScreen) {
+  // Set up login profile.
+  scoped_ptr<TestingPrefServiceSyncable> login_profile_prefs(
+      new TestingPrefServiceSyncable);
+  chrome::RegisterLoginProfilePrefs(login_profile_prefs->registry());
+  scoped_ptr<TestingProfile> login_profile_owner(new TestingProfile(
+      profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile),
+      NULL,
+      scoped_refptr<ExtensionSpecialStoragePolicy>(),
+      scoped_ptr<PrefServiceSyncable>(login_profile_prefs.release())));
+  TestingProfile* login_profile = login_profile_owner.get();
+  TestingProfile* login_profile_parent = profile_manager_.CreateTestingProfile(
+      chrome::kInitialProfile);
+  login_profile_parent->SetOffTheRecordProfile(login_profile_owner.release());
+  login_profile->SetOriginalProfile(login_profile_parent);
+  login_profile->set_incognito(true);
+
+  // Inform power_prefs_ that the login screen is being shown.
+  power_prefs_->Observe(chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE,
+                        content::Source<PowerPrefsTest>(this),
+                        content::NotificationService::NoDetails());
+
+  EXPECT_EQ(login_profile, GetProfile());
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+            GetCurrentPowerPolicy());
+  EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile),
+            GetCurrentAllowScreenWakeLocks());
+
+  TestingProfile* other_profile =
+      profile_manager_.CreateTestingProfile("other");
+
+  // Inform power_prefs_ that an unrelated profile has been destroyed.
+  power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
+                        content::Source<Profile>(other_profile),
+                        content::NotificationService::NoDetails());
+
+  // Verify that the login profile's power prefs are still being used.
+  EXPECT_EQ(login_profile, GetProfile());
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(login_profile),
+            GetCurrentPowerPolicy());
+  EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(login_profile),
+            GetCurrentAllowScreenWakeLocks());
+
+  // Inform power_prefs_ that the login profile has been destroyed.
+  power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
+                        content::Source<Profile>(login_profile),
+                        content::NotificationService::NoDetails());
+
+  EXPECT_FALSE(GetProfile());
+  EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(
+                power_manager::PowerManagementPolicy()),
+            GetCurrentPowerPolicy());
+}
+
+TEST_F(PowerPrefsTest, UserSession) {
+  // Set up user profile.
+  TestingProfile* user_profile = profile_manager_.CreateTestingProfile("user");
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(switches::kLoginProfile,
+                                                      "user");
+  profile_manager_.SetLoggedIn(true);
+  ProfileManager::AllowGetDefaultProfile();
+
+  // Inform power_prefs_ that a session has started.
+  power_prefs_->Observe(chrome::NOTIFICATION_SESSION_STARTED,
+                        content::Source<PowerPrefsTest>(this),
+                        content::NotificationService::NoDetails());
+
+  EXPECT_EQ(user_profile, GetProfile());
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+            GetCurrentPowerPolicy());
+  EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
+            GetCurrentAllowScreenWakeLocks());
+
+  TestingProfile* other_profile =
+      profile_manager_.CreateTestingProfile("other");
+
+  // Inform power_prefs_ that an unrelated profile has been destroyed.
+  power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
+                        content::Source<Profile>(other_profile),
+                        content::NotificationService::NoDetails());
+
+  // Verify that the user profile's power prefs are still being used.
+  EXPECT_EQ(user_profile, GetProfile());
+  EXPECT_EQ(GetExpectedPowerPolicyForProfile(user_profile),
+            GetCurrentPowerPolicy());
+  EXPECT_EQ(GetExpectedAllowScreenWakeLocksForProfile(user_profile),
+            GetCurrentAllowScreenWakeLocks());
+
+  // Inform power_prefs_ that the session has ended and the user profile has
+  // been destroyed.
+  power_prefs_->Observe(chrome::NOTIFICATION_PROFILE_DESTROYED,
+                        content::Source<Profile>(user_profile),
+                        content::NotificationService::NoDetails());
+
+  EXPECT_FALSE(GetProfile());
+  EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(
+                power_manager::PowerManagementPolicy()),
+            GetCurrentPowerPolicy());
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc
index 2971210..5248353 100644
--- a/chrome/browser/chromeos/preferences.cc
+++ b/chrome/browser/chromeos/preferences.cc
@@ -30,8 +30,6 @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/power_policy_controller.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/ime/xkeyboard.h"
 #include "components/user_prefs/pref_registry_syncable.h"
@@ -312,12 +310,6 @@ void Preferences::RegisterProfilePrefs(
       language_prefs::kXkbAutoRepeatIntervalInMs,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
-  // Screen lock default to off.
-  registry->RegisterBooleanPref(
-      prefs::kEnableScreenLock,
-      false,
-      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
-
   // Mobile plan notifications default to on.
   registry->RegisterBooleanPref(
       prefs::kShowPlanNotifications,
@@ -341,79 +333,6 @@ void Preferences::RegisterProfilePrefs(
       false,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcScreenDimDelayMs,
-      420000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcScreenOffDelayMs,
-      480000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcScreenLockDelayMs,
-      0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcIdleWarningDelayMs,
-      0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcIdleDelayMs,
-      1800000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryScreenDimDelayMs,
-      300000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryScreenOffDelayMs,
-      360000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryScreenLockDelayMs,
-      0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryIdleWarningDelayMs,
-      0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryIdleDelayMs,
-      600000,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerAcIdleAction,
-      PowerPolicyController::ACTION_SUSPEND,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerBatteryIdleAction,
-      PowerPolicyController::ACTION_SUSPEND,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterIntegerPref(
-      prefs::kPowerLidClosedAction,
-      PowerPolicyController::ACTION_SUSPEND,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterBooleanPref(
-      prefs::kPowerUseAudioActivity,
-      true,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterBooleanPref(
-      prefs::kPowerUseVideoActivity,
-      true,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterBooleanPref(
-      prefs::kPowerAllowScreenWakeLocks,
-      true,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterDoublePref(
-      prefs::kPowerPresentationScreenDimDelayFactor,
-      2.0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterDoublePref(
-      prefs::kPowerUserActivityScreenDimDelayFactor,
-      2.0,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-
   registry->RegisterStringPref(
       prefs::kTermsOfServiceURL,
       "",
@@ -527,42 +446,6 @@ void Preferences::InitUserPrefs(PrefServiceSyncable* prefs) {
   xkb_auto_repeat_interval_pref_.Init(
       prefs::kLanguageXkbAutoRepeatInterval, prefs, callback);
 
-  enable_screen_lock_.Init(prefs::kEnableScreenLock, prefs, callback);
-
-  power_ac_screen_dim_delay_ms_.Init(
-      prefs::kPowerAcScreenDimDelayMs, prefs, callback);
-  power_ac_screen_off_delay_ms_.Init(
-      prefs::kPowerAcScreenOffDelayMs, prefs, callback);
-  power_ac_screen_lock_delay_ms_.Init(
-      prefs::kPowerAcScreenLockDelayMs, prefs, callback);
-  power_ac_idle_warning_delay_ms_.Init(
-      prefs::kPowerAcIdleWarningDelayMs, prefs, callback);
-  power_ac_idle_delay_ms_.Init(prefs::kPowerAcIdleDelayMs, prefs, callback);
-  power_battery_screen_dim_delay_ms_.Init(
-      prefs::kPowerBatteryScreenDimDelayMs, prefs, callback);
-  power_battery_screen_off_delay_ms_.Init(
-      prefs::kPowerBatteryScreenOffDelayMs, prefs, callback);
-  power_battery_screen_lock_delay_ms_.Init(
-      prefs::kPowerBatteryScreenLockDelayMs, prefs, callback);
-  power_battery_idle_warning_delay_ms_.Init(
-      prefs::kPowerBatteryIdleWarningDelayMs, prefs, callback);
-  power_battery_idle_delay_ms_.Init(
-      prefs::kPowerBatteryIdleDelayMs, prefs, callback);
-  power_ac_idle_action_.Init(prefs::kPowerAcIdleAction, prefs, callback);
-  power_battery_idle_action_.Init(
-      prefs::kPowerBatteryIdleAction, prefs, callback);
-  power_lid_closed_action_.Init(prefs::kPowerLidClosedAction, prefs, callback);
-  power_use_audio_activity_.Init(
-      prefs::kPowerUseAudioActivity, prefs, callback);
-  power_use_video_activity_.Init(
-      prefs::kPowerUseVideoActivity, prefs, callback);
-  power_allow_screen_wake_locks_.Init(
-      prefs::kPowerAllowScreenWakeLocks, prefs, callback);
-  power_presentation_screen_dim_delay_factor_.Init(
-      prefs::kPowerPresentationScreenDimDelayFactor, prefs, callback);
-  power_user_activity_screen_dim_delay_factor_.Init(
-      prefs::kPowerUserActivityScreenDimDelayFactor, prefs, callback);
-
   // TODO(achuith): Remove deprecated pref in M31. crbug.com/223480.
   prefs->ClearPref(kEnableTouchpadThreeFingerSwipe);
 }
@@ -876,60 +759,6 @@ void Preferences::NotifyPrefChanged(const std::string* pref_name) {
       }
     }
   }
-
-  if (!pref_name ||
-      *pref_name == prefs::kPowerAcScreenDimDelayMs ||
-      *pref_name == prefs::kPowerAcScreenOffDelayMs ||
-      *pref_name == prefs::kPowerAcScreenLockDelayMs ||
-      *pref_name == prefs::kPowerAcIdleWarningDelayMs ||
-      *pref_name == prefs::kPowerAcIdleDelayMs ||
-      *pref_name == prefs::kPowerBatteryScreenDimDelayMs ||
-      *pref_name == prefs::kPowerBatteryScreenOffDelayMs ||
-      *pref_name == prefs::kPowerBatteryScreenLockDelayMs ||
-      *pref_name == prefs::kPowerBatteryIdleWarningDelayMs ||
-      *pref_name == prefs::kPowerBatteryIdleDelayMs ||
-      *pref_name == prefs::kPowerAcIdleAction ||
-      *pref_name == prefs::kPowerBatteryIdleAction ||
-      *pref_name == prefs::kPowerLidClosedAction ||
-      *pref_name == prefs::kPowerUseAudioActivity ||
-      *pref_name == prefs::kPowerUseVideoActivity ||
-      *pref_name == prefs::kPowerAllowScreenWakeLocks ||
-      *pref_name == prefs::kPowerPresentationScreenDimDelayFactor ||
-      *pref_name == prefs::kPowerUserActivityScreenDimDelayFactor ||
-      *pref_name == prefs::kEnableScreenLock) {
-    PowerPolicyController::PrefValues values;
-    values.ac_screen_dim_delay_ms = power_ac_screen_dim_delay_ms_.GetValue();
-    values.ac_screen_off_delay_ms = power_ac_screen_off_delay_ms_.GetValue();
-    values.ac_screen_lock_delay_ms = power_ac_screen_lock_delay_ms_.GetValue();
-    values.ac_idle_warning_delay_ms =
-        power_ac_idle_warning_delay_ms_.GetValue();
-    values.ac_idle_delay_ms = power_ac_idle_delay_ms_.GetValue();
-    values.battery_screen_dim_delay_ms =
-        power_battery_screen_dim_delay_ms_.GetValue();
-    values.battery_screen_off_delay_ms =
-        power_battery_screen_off_delay_ms_.GetValue();
-    values.battery_screen_lock_delay_ms =
-        power_battery_screen_lock_delay_ms_.GetValue();
-    values.battery_idle_warning_delay_ms =
-        power_battery_idle_warning_delay_ms_.GetValue();
-    values.battery_idle_delay_ms = power_battery_idle_delay_ms_.GetValue();
-    values.ac_idle_action = static_cast<PowerPolicyController::Action>(
-        power_ac_idle_action_.GetValue());
-    values.battery_idle_action = static_cast<PowerPolicyController::Action>(
-        power_battery_idle_action_.GetValue());
-    values.lid_closed_action = static_cast<PowerPolicyController::Action>(
-        power_lid_closed_action_.GetValue());
-    values.use_audio_activity = power_use_audio_activity_.GetValue();
-    values.use_video_activity = power_use_video_activity_.GetValue();
-    values.allow_screen_wake_locks = power_allow_screen_wake_locks_.GetValue();
-    values.enable_screen_lock = enable_screen_lock_.GetValue();
-    values.presentation_screen_dim_delay_factor =
-        power_presentation_screen_dim_delay_factor_.GetValue();
-    values.user_activity_screen_dim_delay_factor =
-        power_user_activity_screen_dim_delay_factor_.GetValue();
-
-    DBusThreadManager::Get()->GetPowerPolicyController()->ApplyPrefs(values);
-  }
 }
 
 void Preferences::OnIsSyncingChanged() {
diff --git a/chrome/browser/chromeos/preferences.h b/chrome/browser/chromeos/preferences.h
index 970013d..9fb6c78 100644
--- a/chrome/browser/chromeos/preferences.h
+++ b/chrome/browser/chromeos/preferences.h
@@ -170,30 +170,8 @@ class Preferences : public PrefServiceSyncableObserver,
   IntegerPrefMember xkb_auto_repeat_delay_pref_;
   IntegerPrefMember xkb_auto_repeat_interval_pref_;
 
-  BooleanPrefMember enable_screen_lock_;
-
   BooleanPrefMember enable_drm_;
 
-  // Power-management-related preferences.
-  IntegerPrefMember power_ac_screen_dim_delay_ms_;
-  IntegerPrefMember power_ac_screen_off_delay_ms_;
-  IntegerPrefMember power_ac_screen_lock_delay_ms_;
-  IntegerPrefMember power_ac_idle_warning_delay_ms_;
-  IntegerPrefMember power_ac_idle_delay_ms_;
-  IntegerPrefMember power_battery_screen_dim_delay_ms_;
-  IntegerPrefMember power_battery_screen_off_delay_ms_;
-  IntegerPrefMember power_battery_screen_lock_delay_ms_;
-  IntegerPrefMember power_battery_idle_warning_delay_ms_;
-  IntegerPrefMember power_battery_idle_delay_ms_;
-  IntegerPrefMember power_ac_idle_action_;
-  IntegerPrefMember power_battery_idle_action_;
-  IntegerPrefMember power_lid_closed_action_;
-  BooleanPrefMember power_use_audio_activity_;
-  BooleanPrefMember power_use_video_activity_;
-  BooleanPrefMember power_allow_screen_wake_locks_;
-  DoublePrefMember power_presentation_screen_dim_delay_factor_;
-  DoublePrefMember power_user_activity_screen_dim_delay_factor_;
-
   DISALLOW_COPY_AND_ASSIGN(Preferences);
 };
 
diff --git a/chrome/browser/policy/configuration_policy_handler.cc b/chrome/browser/policy/configuration_policy_handler.cc
index 030b4d5..a1ba5bb 100644
--- a/chrome/browser/policy/configuration_policy_handler.cc
+++ b/chrome/browser/policy/configuration_policy_handler.cc
@@ -5,7 +5,6 @@
 #include "chrome/browser/policy/configuration_policy_handler.h"
 
 #include <algorithm>
-#include <string>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ -119,22 +118,7 @@ const ProxyModeValidationEntry kProxyModeValidationMap[] = {
 };
 
 
-// Helper functions ------------------------------------------------------------
-
-std::string ValueTypeToString(Value::Type type) {
-  static const char* strings[] = {
-    "null",
-    "boolean",
-    "integer",
-    "double",
-    "string",
-    "binary",
-    "dictionary",
-    "list"
-  };
-  CHECK(static_cast<size_t>(type) < arraysize(strings));
-  return std::string(strings[type]);
-}
+// Helper function -------------------------------------------------------------
 
 // Utility function that returns a JSON representation of the given |dict| as
 // a StringValue. The caller owns the returned object.
@@ -154,6 +138,22 @@ base::StringValue* DictionaryToJSONString(const base::DictionaryValue* dict) {
 
 // ConfigurationPolicyHandler implementation -----------------------------------
 
+// static
+std::string ConfigurationPolicyHandler::ValueTypeToString(Value::Type type) {
+  static const char* strings[] = {
+    "null",
+    "boolean",
+    "integer",
+    "double",
+    "string",
+    "binary",
+    "dictionary",
+    "list"
+  };
+  CHECK(static_cast<size_t>(type) < arraysize(strings));
+  return std::string(strings[type]);
+}
+
 ConfigurationPolicyHandler::ConfigurationPolicyHandler() {
 }
 
diff --git a/chrome/browser/policy/configuration_policy_handler.h b/chrome/browser/policy/configuration_policy_handler.h
index 449a11a..bd87dc0 100644
--- a/chrome/browser/policy/configuration_policy_handler.h
+++ b/chrome/browser/policy/configuration_policy_handler.h
@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_HANDLER_H_
 #define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_HANDLER_H_
 
+#include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ -24,6 +25,8 @@ class PolicyMap;
 // their corresponding preferences, and to check whether the policies are valid.
 class ConfigurationPolicyHandler {
  public:
+  static std::string ValueTypeToString(Value::Type type);
+
   ConfigurationPolicyHandler();
   virtual ~ConfigurationPolicyHandler();
 
diff --git a/chrome/browser/policy/configuration_policy_handler_list.cc b/chrome/browser/policy/configuration_policy_handler_list.cc
index c0b3fc5..582e076 100644
--- a/chrome/browser/policy/configuration_policy_handler_list.cc
+++ b/chrome/browser/policy/configuration_policy_handler_list.cc
@@ -20,6 +20,7 @@
 #if defined(OS_CHROMEOS)
 #include "ash/magnifier/magnifier_constants.h"
 #include "chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h"
+#include "chromeos/dbus/power_policy_controller.h"
 #endif  // defined(OS_CHROMEOS)
 
 namespace policy {
@@ -477,6 +478,7 @@ ConfigurationPolicyHandlerList::ConfigurationPolicyHandlerList() {
   handlers_.push_back(NetworkConfigurationPolicyHandler::CreateForUserPolicy());
   handlers_.push_back(new PinnedLauncherAppsPolicyHandler());
   handlers_.push_back(new ScreenMagnifierPolicyHandler());
+  handlers_.push_back(new LoginScreenPowerManagementPolicyHandler);
 
   handlers_.push_back(
       new IntRangePolicyHandler(
@@ -532,17 +534,23 @@ ConfigurationPolicyHandlerList::ConfigurationPolicyHandlerList() {
       new IntRangePolicyHandler(
           key::kIdleActionAC,
           prefs::kPowerAcIdleAction,
-          0, 3, false));
+          chromeos::PowerPolicyController::ACTION_SUSPEND,
+          chromeos::PowerPolicyController::ACTION_DO_NOTHING,
+          false));
   handlers_.push_back(
       new IntRangePolicyHandler(
           key::kIdleActionBattery,
           prefs::kPowerBatteryIdleAction,
-          0, 3, false));
+          chromeos::PowerPolicyController::ACTION_SUSPEND,
+          chromeos::PowerPolicyController::ACTION_DO_NOTHING,
+          false));
   handlers_.push_back(
       new IntRangePolicyHandler(
           key::kLidCloseAction,
           prefs::kPowerLidClosedAction,
-          0, 3, false));
+          chromeos::PowerPolicyController::ACTION_SUSPEND,
+          chromeos::PowerPolicyController::ACTION_DO_NOTHING,
+          false));
   handlers_.push_back(
       new IntPercentageToDoublePolicyHandler(
           key::kPresentationScreenDimDelayScale,
diff --git a/chrome/browser/policy/mock_policy_service.cc b/chrome/browser/policy/mock_policy_service.cc
index b71bbf1..bc56c65 100644
--- a/chrome/browser/policy/mock_policy_service.cc
+++ b/chrome/browser/policy/mock_policy_service.cc
@@ -6,6 +6,12 @@
 
 namespace policy {
 
+MockPolicyServiceObserver::MockPolicyServiceObserver() {
+}
+
+MockPolicyServiceObserver::~MockPolicyServiceObserver() {
+}
+
 MockPolicyService::MockPolicyService() {
 }
 
diff --git a/chrome/browser/policy/mock_policy_service.h b/chrome/browser/policy/mock_policy_service.h
index 31caa36..953ce2d 100644
--- a/chrome/browser/policy/mock_policy_service.h
+++ b/chrome/browser/policy/mock_policy_service.h
@@ -11,10 +11,21 @@
 
 namespace policy {
 
+class MockPolicyServiceObserver : public PolicyService::Observer {
+ public:
+  MockPolicyServiceObserver();
+  virtual ~MockPolicyServiceObserver();
+
+  MOCK_METHOD3(OnPolicyUpdated, void(const PolicyNamespace&,
+                                     const PolicyMap& previous,
+                                     const PolicyMap& current));
+  MOCK_METHOD1(OnPolicyServiceInitialized, void(PolicyDomain));
+};
+
 class MockPolicyService : public PolicyService {
  public:
   MockPolicyService();
-  ~MockPolicyService();
+  virtual ~MockPolicyService();
 
   MOCK_METHOD2(AddObserver, void(PolicyDomain, Observer*));
   MOCK_METHOD2(RemoveObserver, void(PolicyDomain, Observer*));
diff --git a/chrome/browser/policy/policy_service_impl_unittest.cc b/chrome/browser/policy/policy_service_impl_unittest.cc
index ad4fdcb..6b8ac7f 100644
--- a/chrome/browser/policy/policy_service_impl_unittest.cc
+++ b/chrome/browser/policy/policy_service_impl_unittest.cc
@@ -14,6 +14,7 @@
 #include "base/values.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/policy/mock_policy_service.h"
 #include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/common/policy/policy_schema.h"
 #include "content/public/browser/browser_thread.h"
@@ -34,15 +35,6 @@ const char kExtension[] = "extension-id";
 const char kSameLevelPolicy[] = "policy-same-level-and-scope";
 const char kDiffLevelPolicy[] = "chrome-diff-level-and-scope";
 
-class MockPolicyServiceObserver : public PolicyService::Observer {
- public:
-  virtual ~MockPolicyServiceObserver() {}
-  MOCK_METHOD3(OnPolicyUpdated, void(const PolicyNamespace&,
-                                     const PolicyMap& previous,
-                                     const PolicyMap& current));
-  MOCK_METHOD1(OnPolicyServiceInitialized, void(PolicyDomain));
-};
-
 // Helper to compare the arguments to an EXPECT_CALL of OnPolicyUpdated() with
 // their expected values.
 MATCHER_P(PolicyEquals, expected, "") {
diff --git a/chrome/browser/policy/proto/chromeos/chrome_device_policy.proto b/chrome/browser/policy/proto/chromeos/chrome_device_policy.proto
index 48b268a..06deb8b 100644
--- a/chrome/browser/policy/proto/chromeos/chrome_device_policy.proto
+++ b/chrome/browser/policy/proto/chromeos/chrome_device_policy.proto
@@ -414,6 +414,101 @@ message SupervisedUsersSettingsProto {
   optional bool supervised_users_enabled = 1;
 }
 
+message LoginScreenPowerManagementProto {
+  // Configures power management on the login screen. The policy should be
+  // specified as a string that expresses the individual settings in JSON
+  // format, conforming to the following schema:
+  // {
+  //   "type": "object",
+  //   "properties": {
+  //     "AC": {
+  //       "description": "Power management settings applicable only when
+  //                       running on AC power",
+  //       "type": "object",
+  //       "properties": {
+  //         "Delays": {
+  //           "type": "object",
+  //           "properties": {
+  //             "ScreenDim": {
+  //               "description": "The length of time without user input after
+  //                               which the screen is dimmed, in milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             },
+  //             "ScreenOff": {
+  //               "description": "The length of time without user input after
+  //                               which the screen is turned off, in
+  //                               milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             },
+  //             "Idle": {
+  //               "description": "The length of time without user input after
+  //                               which the idle action is taken, in
+  //                               milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             }
+  //           }
+  //         },
+  //         "IdleAction": {
+  //           "description": "Action to take when the idle delay is reached",
+  //           "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+  //         }
+  //       }
+  //     },
+  //     "Battery": {
+  //       "description": "Power management settings applicable only when
+  //                       running on battery power",
+  //       "type": "object",
+  //       "properties": {
+  //         "Delays": {
+  //           "type": "object",
+  //           "properties": {
+  //             "ScreenDim": {
+  //               "description": "The length of time without user input after
+  //                               which the screen is dimmed, in milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             },
+  //             "ScreenOff": {
+  //               "description": "The length of time without user input after
+  //                               which the screen is turned off, in
+  //                               milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             },
+  //             "Idle": {
+  //               "description": "The length of time without user input after
+  //                               which the idle action is taken, in
+  //                               milliseconds",
+  //               "type": "integer",
+  //               "minimum": 0
+  //             }
+  //           }
+  //         },
+  //         "IdleAction": {
+  //           "description": "Action to take when the idle delay is reached",
+  //           "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+  //         }
+  //       }
+  //     },
+  //     "LidCloseAction": {
+  //       "description": "Action to take when the lid is closed",
+  //       "enum": [ "Suspend", "Shutdown", "DoNothing" ]
+  //     },
+  //     "UserActivityScreenDimDelayScale": {
+  //       "description": "Percentage by which the screen dim delay is scaled
+  //                       when user activity is observed while the screen is
+  //                       dimmed or soon after the screen has been turned off",
+  //       "type": "integer",
+  //       "minimum": 0
+  //     }
+  //   }
+  // }
+  optional string login_screen_power_management = 1;
+}
+
 message ChromeDeviceSettingsProto {
   optional DevicePolicyRefreshRateProto device_policy_refresh_rate = 1;
   optional UserWhitelistProto user_whitelist = 2;
@@ -443,4 +538,5 @@ message ChromeDeviceSettingsProto {
   optional AttestationSettingsProto attestation_settings = 26;
   optional AccessibilitySettingsProto accessibility_settings = 27;
   optional SupervisedUsersSettingsProto supervised_users_settings = 28;
+  optional LoginScreenPowerManagementProto login_screen_power_management = 29;
 }
diff --git a/chrome/browser/prefs/browser_prefs.cc b/chrome/browser/prefs/browser_prefs.cc
index 69c7e85..11f1f7e 100644
--- a/chrome/browser/prefs/browser_prefs.cc
+++ b/chrome/browser/prefs/browser_prefs.cc
@@ -138,6 +138,7 @@
 #include "chrome/browser/chromeos/policy/auto_enrollment_client.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
+#include "chrome/browser/chromeos/power/power_prefs.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_settings_cache.h"
@@ -396,11 +397,17 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 
 void RegisterUserProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   RegisterProfilePrefs(registry);
+
+#if defined(OS_CHROMEOS)
+  chromeos::PowerPrefs::RegisterUserProfilePrefs(registry);
+#endif
 }
 
 #if defined(OS_CHROMEOS)
 void RegisterLoginProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   RegisterProfilePrefs(registry);
+
+  chromeos::PowerPrefs::RegisterLoginProfilePrefs(registry);
 }
 #endif
 
diff --git a/chrome/chrome_browser_chromeos.gypi b/chrome/chrome_browser_chromeos.gypi
index 3c13642..5f59fc7 100644
--- a/chrome/chrome_browser_chromeos.gypi
+++ b/chrome/chrome_browser_chromeos.gypi
@@ -664,6 +664,8 @@
         'browser/chromeos/policy/enterprise_install_attributes.h',
         'browser/chromeos/policy/login_profile_policy_provider.cc',
         'browser/chromeos/policy/login_profile_policy_provider.h',
+        'browser/chromeos/policy/login_screen_power_management_policy.cc',
+        'browser/chromeos/policy/login_screen_power_management_policy.h',
         'browser/chromeos/policy/network_configuration_updater.cc',
         'browser/chromeos/policy/network_configuration_updater.h',
         'browser/chromeos/policy/network_configuration_updater_impl.cc',
@@ -704,6 +706,8 @@
         'browser/chromeos/power/peripheral_battery_observer.h',
         'browser/chromeos/power/power_button_observer.cc',
         'browser/chromeos/power/power_button_observer.h',
+        'browser/chromeos/power/power_prefs.cc',
+        'browser/chromeos/power/power_prefs.h',
         'browser/chromeos/power/resume_observer.cc',
         'browser/chromeos/power/resume_observer.h',
         'browser/chromeos/power/screen_lock_observer.cc',
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index 0fdf621..7394cf7 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1474,6 +1474,8 @@
         'browser/policy/cloud/device_management_service_browsertest.cc',
         'browser/policy/cloud/test_request_interceptor.cc',
         'browser/policy/cloud/test_request_interceptor.h',
+        'browser/policy/mock_policy_service.cc',
+        'browser/policy/mock_policy_service.h',
         'browser/policy/policy_browsertest.cc',
         'browser/policy/policy_prefs_browsertest.cc',
         'browser/policy/test_utils.cc',
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index cae05a2..ecc535c 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -685,11 +685,13 @@
         'browser/chromeos/policy/device_cloud_policy_store_chromeos_unittest.cc',
         'browser/chromeos/policy/device_local_account_policy_service_unittest.cc',
         'browser/chromeos/policy/enterprise_install_attributes_unittest.cc',
+        'browser/chromeos/policy/login_screen_power_management_policy_unittest.cc',
         'browser/chromeos/policy/network_configuration_updater_impl_cros_unittest.cc',
         'browser/chromeos/policy/proxy_policy_provider_unittest.cc',
         'browser/chromeos/policy/recommendation_restorer_unittest.cc',
         'browser/chromeos/policy/user_cloud_policy_manager_chromeos_unittest.cc',
         'browser/chromeos/policy/user_cloud_policy_store_chromeos_unittest.cc',
+        'browser/chromeos/power/power_prefs_unittest.cc',
         'browser/chromeos/preferences_unittest.cc',
         'browser/chromeos/session_length_limiter_unittest.cc',
         'browser/chromeos/proxy_config_service_impl_unittest.cc',
diff --git a/chrome/test/base/testing_profile_manager.cc b/chrome/test/base/testing_profile_manager.cc
index 5a5f620..44bb0b5 100644
--- a/chrome/test/base/testing_profile_manager.cc
+++ b/chrome/test/base/testing_profile_manager.cc
@@ -4,7 +4,6 @@
 
 #include "chrome/test/base/testing_profile_manager.h"
 
-#include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
@@ -104,6 +103,11 @@ void TestingProfileManager::SetLoggedIn(bool logged_in) {
   profile_manager_->logged_in_ = logged_in;
 }
 
+const base::FilePath& TestingProfileManager::profiles_dir() {
+  DCHECK(called_set_up_);
+  return profiles_dir_.path();
+}
+
 ProfileManager* TestingProfileManager::profile_manager() {
   DCHECK(called_set_up_);
   return profile_manager_;
diff --git a/chrome/test/base/testing_profile_manager.h b/chrome/test/base/testing_profile_manager.h
index 7a4205c..99d7458 100644
--- a/chrome/test/base/testing_profile_manager.h
+++ b/chrome/test/base/testing_profile_manager.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "base/compiler_specific.h"
+#include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
@@ -65,6 +66,7 @@ class TestingProfileManager {
   void SetLoggedIn(bool logged_in);
 
   // Helper accessors.
+  const base::FilePath& profiles_dir();
   ProfileManager* profile_manager();
   ProfileInfoCache* profile_info_cache();
 
diff --git a/chrome/test/data/policy/policy_test_cases.json b/chrome/test/data/policy/policy_test_cases.json
index 5fdeee3..1fe75df 100644
--- a/chrome/test/data/policy/policy_test_cases.json
+++ b/chrome/test/data/policy/policy_test_cases.json
@@ -1938,6 +1938,9 @@
   "DeviceLocalAccountAutoLoginBailoutEnabled": {
   },
 
+  "DeviceLoginScreenPowerManagement": {
+  },
+
   "DeviceAllowRedeemChromeOsRegistrationOffers": {
   },
 
diff --git a/chromeos/dbus/power_policy_controller.cc b/chromeos/dbus/power_policy_controller.cc
index 5edc5bd..5d1c8ae 100644
--- a/chromeos/dbus/power_policy_controller.cc
+++ b/chromeos/dbus/power_policy_controller.cc
@@ -157,8 +157,9 @@ void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
   int64 lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
   if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
       (delays->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
-      lock_ms < delays->idle_ms())
+      lock_ms < delays->idle_ms()) {
     delays->set_screen_lock_ms(lock_ms);
+  }
 
   delays = prefs_policy_.mutable_battery_delays();
   delays->set_screen_dim_ms(values.battery_screen_dim_delay_ms);
@@ -170,8 +171,9 @@ void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
   lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
   if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
       (delays->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
-      lock_ms < delays->idle_ms())
+      lock_ms < delays->idle_ms()) {
     delays->set_screen_lock_ms(lock_ms);
+  }
 
   prefs_policy_.set_ac_idle_action(GetProtoAction(values.ac_idle_action));
   prefs_policy_.set_battery_idle_action(
@@ -190,6 +192,13 @@ void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
   SendCurrentPolicy();
 }
 
+void PowerPolicyController::ClearPrefs() {
+  prefs_policy_.Clear();
+  honor_screen_wake_locks_ = true;
+  prefs_were_set_ = false;
+  SendCurrentPolicy();
+}
+
 int PowerPolicyController::AddScreenWakeLock(const std::string& reason) {
   int id = next_wake_lock_id_++;
   screen_wake_locks_[id] = reason;
diff --git a/chromeos/dbus/power_policy_controller.h b/chromeos/dbus/power_policy_controller.h
index b24aa4a..4cf68df 100644
--- a/chromeos/dbus/power_policy_controller.h
+++ b/chromeos/dbus/power_policy_controller.h
@@ -74,6 +74,9 @@ class CHROMEOS_EXPORT PowerPolicyController
   // Updates |prefs_policy_| with |values| and sends an updated policy.
   void ApplyPrefs(const PrefValues& values);
 
+  // Resets |prefs_policy_| to its defaults and sends an updated policy.
+  void ClearPrefs();
+
   // Registers a request to temporarily prevent the screen from getting
   // dimmed or turned off or the system from suspending in response to user
   // inactivity and sends an updated policy.  |reason| is a human-readable
@@ -94,6 +97,8 @@ class CHROMEOS_EXPORT PowerPolicyController
   virtual void PowerManagerRestarted() OVERRIDE;
 
  private:
+  friend class PowerPrefsTest;
+
   typedef std::map<int, std::string> WakeLockMap;
 
   // Sends a policy based on |prefs_policy_| to the power manager.