Add ManagedModePolicyProvider and extension API to get and set policies.

chrome/browser/policy/managed_mode_policy_provider.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/policy/managed_mode_policy_provider.h"
+
+#include "chrome/browser/policy/policy_bundle.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/json_pref_store.h"
+#include "chrome/common/chrome_constants.h"
+#include "content/public/browser/browser_thread.h"
+#include "policy/policy_constants.h"
+
+using content::BrowserThread;
+
+namespace policy {
+
+static const char kPolicies[] = "policies";
+
+ManagedModePolicyProvider::ManagedModePolicyProvider(Profile* profile)
+    : store_(new JsonPrefStore(profile->GetPath().Append(
+                                   chrome::kManagedModePolicyFilename),
+                               BrowserThread::GetMessageLoopProxyForThread(
+                                   BrowserThread::FILE))) {
+  store_->AddObserver(this);
+  store_->ReadPrefsAsync(NULL);
+}
+
+ManagedModePolicyProvider::~ManagedModePolicyProvider() {
+  store_->RemoveObserver(this);
+}
+
+const base::Value* ManagedModePolicyProvider::GetPolicy(
+    const std::string& key) const {
+  base::DictionaryValue* dict = GetCachedPolicy();
+  base::Value* value = NULL;
+  dict->GetWithoutPathExpansion(key, &value);
+  return value;
+}
+
+void ManagedModePolicyProvider::SetPolicy(const std::string& key,
+                                          const base::Value* value) {
+  base::DictionaryValue* dict = GetCachedPolicy();
+  dict->SetWithoutPathExpansion(key, value->DeepCopy());
+  store_->ReportValueChanged(kPolicies);
+  UpdatePolicyFromCache();
+}
+
+void ManagedModePolicyProvider::RefreshPolicies() {
+  UpdatePolicyFromCache();
+}
+
+bool ManagedModePolicyProvider::IsInitializationComplete() const {
+  return store_->IsInitializationComplete();
+}
+
+void ManagedModePolicyProvider::OnPrefValueChanged(const std::string& key) {}
+
+void ManagedModePolicyProvider::OnInitializationCompleted(bool success) {
+  DCHECK(success);
+  UpdatePolicyFromCache();
+}
+
+base::DictionaryValue* ManagedModePolicyProvider::GetCachedPolicy() const {
+  base::Value* value = NULL;
+  base::DictionaryValue* dict = NULL;
+  PrefStore::ReadResult result = store_->GetMutableValue(kPolicies, &value);
+  if (result == PrefStore::READ_NO_VALUE) {
+    dict = new base::DictionaryValue;
+    store_->SetValue(kPolicies, dict);
+  } else if (result == PrefStore::READ_OK) {
+    bool success = value->GetAsDictionary(&dict);
+    DCHECK(success);
+  } else {
+    NOTREACHED();
+  }
+
+  return dict;
+}
+
+void ManagedModePolicyProvider::UpdatePolicyFromCache() {
+  const base::DictionaryValue* dict = GetCachedPolicy();
+  scoped_ptr<PolicyBundle> policy_bundle(new PolicyBundle);
+  PolicyMap* policy_map =
+      &policy_bundle->Get(POLICY_DOMAIN_CHROME, std::string());
+  policy_map->LoadFrom(dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
+  UpdatePolicy(policy_bundle.Pass());
+}
+
+}  // namespace policy