Add initial device policy infrastructure.

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2011 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/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 86 matching lines @@
   // with NFS/AFS.
   // TODO(evanm): remove this once we've collected state.
   file_util::FileSystemType fstype;
   if (file_util::GetFileSystemType(pref_filename.DirName(), &fstype)) {
     UMA_HISTOGRAM_ENUMERATION("PrefService.FileSystemType",
                               static_cast<int>(fstype),
                               file_util::FILE_SYSTEM_TYPE_COUNT);
   }
 #endif
 
-  ConfigurationPolicyPrefStore* managed =
+  ConfigurationPolicyPrefStore* managed_platform =
       ConfigurationPolicyPrefStore::CreateManagedPlatformPolicyPrefStore();
-  ConfigurationPolicyPrefStore* device_management =
-      ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore(
-          profile);
+  ConfigurationPolicyPrefStore* managed_cloud =
+      ConfigurationPolicyPrefStore::CreateManagedCloudPolicyPrefStore(profile);
   CommandLinePrefStore* command_line =
       new CommandLinePrefStore(CommandLine::ForCurrentProcess());
   JsonPrefStore* user = new JsonPrefStore(
       pref_filename,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
-  ConfigurationPolicyPrefStore* recommended =
-      ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore();
+  ConfigurationPolicyPrefStore* recommended_platform =
+      ConfigurationPolicyPrefStore::CreateRecommendedPlatformPolicyPrefStore();
+  ConfigurationPolicyPrefStore* recommended_cloud =
+      ConfigurationPolicyPrefStore::CreateRecommendedCloudPolicyPrefStore(
+          profile);
   DefaultPrefStore* default_pref_store = new DefaultPrefStore();
 
-  return new PrefService(managed, device_management, extension_prefs,
-                         command_line, user, recommended, default_pref_store);
+  return new PrefService(managed_platform, managed_cloud, extension_prefs,
+                         command_line, user, recommended_platform,
+                         recommended_cloud, default_pref_store);
 }
 
 PrefService* PrefService::CreateIncognitoPrefService(
     PrefStore* incognito_extension_prefs) {
   return new PrefService(*this, incognito_extension_prefs);
 }
 
 PrefService::PrefService(PrefStore* managed_platform_prefs,
-                         PrefStore* device_management_prefs,
+                         PrefStore* managed_cloud_prefs,
                          PrefStore* extension_prefs,
                          PrefStore* command_line_prefs,
                          PersistentPrefStore* user_prefs,
-                         PrefStore* recommended_prefs,
+                         PrefStore* recommended_platform_prefs,
+                         PrefStore* recommended_cloud_prefs,
                          DefaultPrefStore* default_store)
     : user_pref_store_(user_prefs),
       default_store_(default_store) {
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(
       new PrefValueStore(managed_platform_prefs,
-                         device_management_prefs,
+                         managed_cloud_prefs,
                          extension_prefs,
                          command_line_prefs,
                          user_pref_store_,
-                         recommended_prefs,
+                         recommended_platform_prefs,
+                         recommended_cloud_prefs,
                          default_store,
                          pref_notifier_.get()));
   InitFromStorage();
 }
 
 PrefService::PrefService(const PrefService& original,
                          PrefStore* incognito_extension_prefs)
       : user_pref_store_(
             new OverlayPersistentPrefStore(original.user_pref_store_.get())),
         default_store_(original.default_store_.get()){
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(original.pref_value_store_->CloneAndSpecialize(
       NULL, // managed_platform_prefs
-      NULL, // device_management_prefs
+      NULL, // managed_cloud_prefs
       incognito_extension_prefs,
       NULL, // command_line_prefs
       user_pref_store_.get(),
-      NULL, // recommended_prefs
+      NULL, // recommended_platform_prefs
+      NULL, // recommended_cloud_prefs
       default_store_.get(),
       pref_notifier_.get()));
   InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
 
@@ skipping 470 matching lines @@
     DCHECK(found_value->IsType(type_));
     return found_value;
   }
 
   // Every registered preference has at least a default value.
   NOTREACHED() << "no valid value found for registered pref " << name_;
   return NULL;
 }
 
 bool PrefService::Preference::IsManaged() const {
-  PrefValueStore* pref_value_store = pref_service_->pref_value_store_.get();
-  return pref_value_store->PrefValueInManagedPlatformStore(name_.c_str()) ||
-      pref_value_store->PrefValueInDeviceManagementStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueInManagedStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::HasExtensionSetting() const {
-  return pref_service_->pref_value_store_->
-      PrefValueInExtensionStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueInExtensionStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::HasUserSetting() const {
-  return pref_service_->pref_value_store_->
-      PrefValueInUserStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueInUserStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionControlled() const {
-  return pref_service_->pref_value_store_->
-      PrefValueFromExtensionStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueFromExtensionStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::IsUserControlled() const {
-  return pref_service_->pref_value_store_->
-      PrefValueFromUserStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueFromUserStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::IsDefaultValue() const {
-  return pref_service_->pref_value_store_->
-      PrefValueFromDefaultStore(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueFromDefaultStore(
+             name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
-  return pref_service_->pref_value_store_->
-      PrefValueUserModifiable(name_.c_str());
+  return pref_service_->pref_value_store_->PrefValueUserModifiable(
+             name_.c_str());
 }