Add device policies to control accessibility settings on the login screen

chrome/browser/chromeos/policy/login_profile_policy_provider.cc

+// Copyright (c) 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/policy/policy_bundle.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) {
+  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());
+  }
+}
+
+}  // namespace
+
+LoginProfilePolicyProvider::LoginProfilePolicyProvider(
+    PolicyService* device_policy_service)
+    : device_policy_service_(device_policy_service),
+      weak_factory_(this) {
+}
+
+LoginProfilePolicyProvider::~LoginProfilePolicyProvider() {
+}
+
+void LoginProfilePolicyProvider::Init() {
+  ConfigurationPolicyProvider::Init();
+  device_policy_service_->AddObserver(POLICY_DOMAIN_CHROME, this);
+  if (device_policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME))
+    UpdateFromDevicePolicy();
+}
+
+void LoginProfilePolicyProvider::Shutdown() {
+  device_policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, this);
+  weak_factory_.InvalidateWeakPtrs();
+  ConfigurationPolicyProvider::Shutdown();
+}
+
+bool LoginProfilePolicyProvider::IsInitializationComplete(
+    PolicyDomain domain) const {
+  if (domain == POLICY_DOMAIN_CHROME)
+    return device_policy_service_->IsInitializationComplete(domain);

[Mattias Nissler (ping if slow), 2013/06/12 13:55:16]

This might hold startup, have you checked?

[bartfab (slow), 2013/06/12 18:57:49]

Removed so that ConfigurationPolicyProvider::IsInitializationComplete(), which
always returns true, gets called.

+  return true;
+}
+
+void LoginProfilePolicyProvider::RefreshPolicies() {
+  device_policy_service_->RefreshPolicies(base::Bind(
+      &LoginProfilePolicyProvider::UpdateFromDevicePolicy,
+      weak_factory_.GetWeakPtr()));

[Mattias Nissler (ping if slow), 2013/06/12 13:55:16]

The contract is that if you receive a RefreshPolicies() call, the next
UpdatePolicy() needs to contain the changes pulled in via that. So you should
probably check weak_factory_.HasWeakPtrs() in UpdateFromDevicePolicy() and only
perform the update once the actual callback runs. You'll also want to do a
weak_factory_.InvalidateWeakPtrs() here.

[bartfab (slow), 2013/06/12 18:57:49]

Done. The correct implementation is slightly different: Checking for
HasWeakPtrs() is not correct because when the callback finally runs, a last weak
pointer still exists. Also, UpdateFromDevicePolicy() needs to be able to tell
whether it was invoked through the callback or via another code path. I modeled
the implementation after your DeviceLocalAccountPolicyProvider, using a bool to
keep track of the status.

+}
+
+void LoginProfilePolicyProvider::OnPolicyUpdated(const PolicyNamespace& ns,
+                                                 const PolicyMap& previous,
+                                                 const PolicyMap& current) {
+  if (ns == PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
+    UpdateFromDevicePolicy();
+}
+
+void LoginProfilePolicyProvider::OnPolicyServiceInitialized(
+    PolicyDomain domain) {
+  if (domain == POLICY_DOMAIN_CHROME)
+    UpdateFromDevicePolicy();
+}
+
+void LoginProfilePolicyProvider::UpdateFromDevicePolicy() {
+  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::kLoginScreenDefaultLargeCursorEnabled,
+                    key::kLargeCursorEnabled,
+                    device_policy_map, &user_policy_map);
+  ApplyDevicePolicy(key::kLoginScreenDefaultSpokenFeedbackEnabled,
+                    key::kSpokenFeedbackEnabled,
+                    device_policy_map, &user_policy_map);
+  ApplyDevicePolicy(key::kLoginScreenDefaultHighContrastEnabled,
+                    key::kHighContrastEnabled,
+                    device_policy_map, &user_policy_map);
+  ApplyDevicePolicy(key::kLoginScreenDefaultScreenMagnifierType,
+                    key::kScreenMagnifierType,
+                    device_policy_map, &user_policy_map);
+  UpdatePolicy(bundle.Pass());
+}
+
+}  // namespace policy