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

chrome/browser/chromeos/policy/login_profile_policy_provider.cc

 // 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_profile_policy_provider.h"
 
 #include <string>
 
 #include "base/bind.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/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"
 
 namespace policy {
 
 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,
                          POLICY_LEVEL_RECOMMENDED,
                          POLICY_SCOPE_USER,
                          value->DeepCopy());
   }
 }
 
+// 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());
+  }
+}
+
 }  // namespace
 
 LoginProfilePolicyProvider::LoginProfilePolicyProvider(
     PolicyService* device_policy_service)
     : device_policy_service_(device_policy_service),
       waiting_for_device_policy_refresh_(false),
       weak_factory_(this) {
 }
 
 LoginProfilePolicyProvider::~LoginProfilePolicyProvider() {
@@ skipping 42 matching lines @@
   // If a policy refresh is in progress, wait for it to finish.
   if (waiting_for_device_policy_refresh_)
     return;
 
   const PolicyNamespace chrome_namespaces(POLICY_DOMAIN_CHROME, std::string());
   const PolicyMap& device_policy_map =
       device_policy_service_->GetPolicies(chrome_namespaces);
   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);
+
+  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(),

[Mattias Nissler (ping if slow), 2013/07/08 17:36:57]

I guess we eventually want to switch to a dictionary-valued pref as well, would
you agree?

We can do that when converting the profile pref to that format as well. File a
bug and put a TODO here?

[bartfab (slow), 2013/07/09 10:02:33]

Done. For reference, making that additional switch now would be a bad idea: The
'dict' policy type is still aliased to a string for now. This means that the
device policy would need to be expressed as a string-valued user policy. Since
some power management settings are allowed in user policy but not in device
policy, the work flow would be as follows:

* Decode device policy from JSON string to DictionaryValue
* Remove any power management settings not allowed on the login screen
* Re-encode the settings from Dictionary Value to JSON string
* Set the string as user policy for the login profile
* Decode user policy from JSON string to DictionaryValue

We would end up decoding, encoding, decoding JSON - hardly elegant or efficient.
Once both user and device policy are actually dict-valued, we will be able to do
this much more smoothly.

+                                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());
 }
 
 }  // namespace policy