Add ManagedUserSettingsService and a SupervisedUserPrefStore using it.

chrome/browser/prefs/supervised_user_pref_store.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/prefs/supervised_user_pref_store.h"
+
+#include "base/bind.h"
+#include "base/prefs/pref_value_map.h"
+#include "base/values.h"
+#include "chrome/browser/managed_mode/managed_mode_url_filter.h"
+#include "chrome/browser/managed_mode/managed_user_settings.h"
+#include "chrome/browser/managed_mode/managed_user_settings_service.h"
+#include "chrome/browser/prefs/incognito_mode_prefs.h"
+#include "chrome/common/pref_names.h"
+
+using base::FundamentalValue;
+
+SupervisedUserPrefStore::SupervisedUserPrefStore(
+    ManagedUserSettingsService* managed_user_settings_service)
+    : weak_ptr_factory_(this) {

[Pam (message me for reviews), 2013/08/30 13:35:53]

I'd suggest additional indentation here.

[Bernhard Bauer, 2013/08/30 14:54:27]

Like what? Note that this is also how clang-format does it.

[Pam (message me for reviews), 2013/09/02 09:38:41]

Well, OK. IIRC this case is specifically called out as open to different styles
in the guide, but I'm OK with sticking to clang-format's way.

+  managed_user_settings_service->Subscribe(
+      base::Bind(&SupervisedUserPrefStore::OnNewSettingsAvailable,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+bool SupervisedUserPrefStore::GetValue(const std::string& key,
+                                    const base::Value** value) const {
+  DCHECK(prefs_);
+  return prefs_->GetValue(key, value);
+}
+
+void SupervisedUserPrefStore::AddObserver(PrefStore::Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void SupervisedUserPrefStore::RemoveObserver(PrefStore::Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool SupervisedUserPrefStore::HasObservers() const {
+  return observers_.might_have_observers();
+}
+
+bool SupervisedUserPrefStore::IsInitializationComplete() const {
+  return prefs_;

[Pam (message me for reviews), 2013/08/30 13:35:53]

This works, but it makes me itch. It could also lead someone to overlook the
return type. I'd prefer
return (prefs_ != NULL);

[Bernhard Bauer, 2013/08/30 14:54:27]

Well, it'd need to be `prefs_.get() != NULL`. If it's just about making the
conversion to bool implicit, how about `!!prefs_`?

[Pam (message me for reviews), 2013/09/02 09:38:41]

Works for me.

[Bernhard Bauer, 2013/09/02 11:01:07]

Done.

+}
+
+SupervisedUserPrefStore::~SupervisedUserPrefStore() {
+}
+
+void SupervisedUserPrefStore::CopySettingsValue(
+    const base::DictionaryValue* settings,
+    const char* settings_name,
+    const char* pref_name) {
+  const base::Value* value = NULL;
+  if (settings->GetWithoutPathExpansion(settings_name, &value))
+    prefs_->SetValue(pref_name, value->DeepCopy());
+}
+
+void SupervisedUserPrefStore::OnNewSettingsAvailable(
+    const base::DictionaryValue* settings) {
+  scoped_ptr<PrefValueMap> old_prefs = prefs_.Pass();
+  prefs_.reset(new PrefValueMap);
+  if (settings) {
+    // Set hardcoded prefs.
+    prefs_->SetValue(prefs::kAllowDeletingBrowserHistory,
+                     new FundamentalValue(false));
+    prefs_->SetValue(prefs::kDefaultManagedModeFilteringBehavior,
+                     new FundamentalValue(ManagedModeURLFilter::ALLOW));
+    prefs_->SetValue(prefs::kForceSafeSearch, new FundamentalValue(true));
+    prefs_->SetValue(prefs::kHideWebStoreIcon, new FundamentalValue(true));
+    prefs_->SetValue(prefs::kIncognitoModeAvailability,
+                     new FundamentalValue(IncognitoModePrefs::DISABLED));
+    prefs_->SetValue(prefs::kSigninAllowed, new FundamentalValue(false));
+
+    // Copy managed user settings to prefs.

[Pam (message me for reviews), 2013/08/30 13:35:53]

Try a map, like ExtensionPrefStore and others use, to make this more extensible.

[Bernhard Bauer, 2013/08/30 14:54:27]

Done.

+    CopySettingsValue(settings,
+                      managed_users::kContentPackDefaultFilteringBehavior,
+                      prefs::kDefaultManagedModeFilteringBehavior);
+    CopySettingsValue(settings,
+                      managed_users::kContentPackManualBehaviorHosts,
+                      prefs::kManagedModeManualHosts);
+    CopySettingsValue(settings,
+                      managed_users::kContentPackManualBehaviorURLs,
+                      prefs::kManagedModeManualURLs);
+    CopySettingsValue(settings,
+                      managed_users::kForceSafeSearch,
+                      prefs::kForceSafeSearch);
+  }
+
+  if (!old_prefs) {
+    FOR_EACH_OBSERVER(Observer, observers_, OnInitializationCompleted(true));
+    return;
+  }
+
+  std::vector<std::string> changed_prefs;
+  prefs_->GetDifferingKeys(old_prefs.get(), &changed_prefs);
+
+  // Send out change notifications.
+  for (std::vector<std::string>::const_iterator pref(changed_prefs.begin());
+       pref != changed_prefs.end();
+       ++pref) {
+    FOR_EACH_OBSERVER(
+        PrefStore::Observer, observers_, OnPrefValueChanged(*pref));
+  }
+}