chrome/browser/chromeos/policy/login_profile_policy_provider.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/policy/login_profile_policy_provider.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/chromeos/policy/login_screen_power_management_policy.h"
  14 #include "components/policy/core/browser/policy_error_map.h"
  15 #include "components/policy/core/common/external_data_fetcher.h"
  16 #include "components/policy/core/common/policy_bundle.h"
  17 #include "components/policy/core/common/policy_map.h"
  18 #include "components/policy/core/common/policy_types.h"
  19 #include "policy/policy_constants.h"
  20
  21 namespace policy {
  22
  23 namespace {
  24
  25 // Applies the value of |device_policy| in |device_policy_map| as the
  26 // recommended value of |user_policy| in |user_policy_map|. If the value of
  27 // |device_policy| is unset, does nothing.
  28 void ApplyDevicePolicyAsRecommendedPolicy(const std::string& device_policy,
  29                                           const std::string& user_policy,
  30                                           const PolicyMap& device_policy_map,
  31                                           PolicyMap* user_policy_map) {
  32   const base::Value* value = device_policy_map.GetValue(device_policy);
  33   if (value) {
  34     user_policy_map->Set(user_policy,
  35                          POLICY_LEVEL_RECOMMENDED,
  36                          POLICY_SCOPE_USER,
  37                          value->DeepCopy(),
  38                          NULL);
  39   }
  40 }
  41
  42 // Applies |value| as the mandatory value of |user_policy| in |user_policy_map|.
  43 // If |value| is NULL, does nothing.
  44 void ApplyValueAsMandatoryPolicy(const base::Value* value,
  45                                  const std::string& user_policy,
  46                                  PolicyMap* user_policy_map) {
  47   if (value) {
  48     user_policy_map->Set(user_policy,
  49                          POLICY_LEVEL_MANDATORY,
  50                          POLICY_SCOPE_USER,
  51                          value->DeepCopy(),
  52                          NULL);
  53   }
  54 }
  55
  56 }  // namespace
  57
  58 LoginProfilePolicyProvider::LoginProfilePolicyProvider(
  59     PolicyService* device_policy_service)
  60     : device_policy_service_(device_policy_service),
  61       waiting_for_device_policy_refresh_(false),
  62       weak_factory_(this) {
  63 }
  64
  65 LoginProfilePolicyProvider::~LoginProfilePolicyProvider() {
  66 }
  67
  68 void LoginProfilePolicyProvider::Init(SchemaRegistry* registry) {
  69   ConfigurationPolicyProvider::Init(registry);
  70   device_policy_service_->AddObserver(POLICY_DOMAIN_CHROME, this);
  71   if (device_policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME))
  72     UpdateFromDevicePolicy();
  73 }
  74
  75 void LoginProfilePolicyProvider::Shutdown() {
  76   device_policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, this);
  77   weak_factory_.InvalidateWeakPtrs();
  78   ConfigurationPolicyProvider::Shutdown();
  79 }
  80
  81 void LoginProfilePolicyProvider::RefreshPolicies() {
  82   waiting_for_device_policy_refresh_ = true;
  83   weak_factory_.InvalidateWeakPtrs();
  84   device_policy_service_->RefreshPolicies(base::Bind(
  85       &LoginProfilePolicyProvider::OnDevicePolicyRefreshDone,
  86       weak_factory_.GetWeakPtr()));
  87 }
  88
  89 void LoginProfilePolicyProvider::OnPolicyUpdated(const PolicyNamespace& ns,
  90                                                  const PolicyMap& previous,
  91                                                  const PolicyMap& current) {
  92   if (ns == PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
  93     UpdateFromDevicePolicy();
  94 }
  95
  96 void LoginProfilePolicyProvider::OnPolicyServiceInitialized(
  97     PolicyDomain domain) {
  98   if (domain == POLICY_DOMAIN_CHROME)
  99     UpdateFromDevicePolicy();
 100 }
 101
 102 void LoginProfilePolicyProvider::OnDevicePolicyRefreshDone() {
 103   waiting_for_device_policy_refresh_ = false;
 104   UpdateFromDevicePolicy();
 105 }
 106
 107 void LoginProfilePolicyProvider::UpdateFromDevicePolicy() {
 108   // If a policy refresh is in progress, wait for it to finish.
 109   if (waiting_for_device_policy_refresh_)
 110     return;
 111
 112   const PolicyNamespace chrome_namespaces(POLICY_DOMAIN_CHROME, std::string());
 113   const PolicyMap& device_policy_map =
 114       device_policy_service_->GetPolicies(chrome_namespaces);
 115   scoped_ptr<PolicyBundle> bundle(new PolicyBundle);
 116   PolicyMap& user_policy_map = bundle->Get(chrome_namespaces);
 117
 118   ApplyDevicePolicyAsRecommendedPolicy(
 119       key::kDeviceLoginScreenDefaultLargeCursorEnabled,
 120       key::kLargeCursorEnabled,
 121       device_policy_map, &user_policy_map);
 122   ApplyDevicePolicyAsRecommendedPolicy(
 123       key::kDeviceLoginScreenDefaultSpokenFeedbackEnabled,
 124       key::kSpokenFeedbackEnabled,
 125       device_policy_map, &user_policy_map);
 126   ApplyDevicePolicyAsRecommendedPolicy(
 127       key::kDeviceLoginScreenDefaultHighContrastEnabled,
 128       key::kHighContrastEnabled,
 129       device_policy_map, &user_policy_map);
 130   ApplyDevicePolicyAsRecommendedPolicy(
 131       key::kDeviceLoginScreenDefaultScreenMagnifierType,
 132       key::kScreenMagnifierType,
 133       device_policy_map, &user_policy_map);
 134
 135   // TODO(bartfab): Consolidate power management user policies into a single
 136   // JSON policy, allowing the value of the device policy to be simply forwarded
 137   // here. http://crbug.com/258339
 138   const base::Value* value =
 139       device_policy_map.GetValue(key::kDeviceLoginScreenPowerManagement);
 140   std::string json;
 141   if (value && value->GetAsString(&json)) {
 142     LoginScreenPowerManagementPolicy power_management_policy;
 143     power_management_policy.Init(json, NULL);
 144     ApplyValueAsMandatoryPolicy(power_management_policy.GetScreenDimDelayAC(),
 145                                 key::kScreenDimDelayAC,
 146                                 &user_policy_map);
 147     ApplyValueAsMandatoryPolicy(power_management_policy.GetScreenOffDelayAC(),
 148                                 key::kScreenOffDelayAC,
 149                                 &user_policy_map);
 150     ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleDelayAC(),
 151                                 key::kIdleDelayAC,
 152                                 &user_policy_map);
 153     ApplyValueAsMandatoryPolicy(
 154         power_management_policy.GetScreenDimDelayBattery(),
 155         key::kScreenDimDelayBattery,
 156         &user_policy_map);
 157     ApplyValueAsMandatoryPolicy(
 158         power_management_policy.GetScreenOffDelayBattery(),
 159         key::kScreenOffDelayBattery,
 160         &user_policy_map);
 161     ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleDelayBattery(),
 162                                 key::kIdleDelayBattery,
 163                                 &user_policy_map);
 164     ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleActionAC(),
 165                                 key::kIdleActionAC,
 166                                 &user_policy_map);
 167     ApplyValueAsMandatoryPolicy(power_management_policy.GetIdleActionBattery(),
 168                                 key::kIdleActionBattery,
 169                                 &user_policy_map);
 170     ApplyValueAsMandatoryPolicy(power_management_policy.GetLidCloseAction(),
 171                                 key::kLidCloseAction,
 172                                 &user_policy_map);
 173     ApplyValueAsMandatoryPolicy(
 174         power_management_policy.GetUserActivityScreenDimDelayScale(),
 175         key::kUserActivityScreenDimDelayScale,
 176         &user_policy_map);
 177   }
 178
 179   UpdatePolicy(bundle.Pass());
 180 }
 181
 182 }  // namespace policy