Create additional PrefStore for Device Management policy.

chrome/browser/policy/configuration_policy_pref_store.cc

 // Copyright (c) 2010 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/configuration_policy_pref_store.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/policy/dummy_configuration_policy_provider.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/policy_constants.h"
 #include "chrome/common/pref_names.h"
 
 namespace policy {
 
-// Manages the lifecycle of the shared platform-specific policy providers
-// for managed and recommended policy. Instantiated as a Singleton.
+// Manages the lifecycle of the shared platform-specific policy providers for
+// managed platform, device management and recommended policy. Instantiated as a
+// Singleton.
 class ConfigurationPolicyProviderKeeper {
  public:
   ConfigurationPolicyProviderKeeper()
-      : managed_provider_(CreateManagedProvider()),
+      : managed_platform_provider_(CreateManagedPlatformProvider()),
+        device_management_provider_(CreateDeviceManagementProvider()),
         recommended_provider_(CreateRecommendedProvider()) {}
   virtual ~ConfigurationPolicyProviderKeeper() {}
 
-  ConfigurationPolicyProvider* managed_provider() const {
-    return managed_provider_.get();
+  ConfigurationPolicyProvider* managed_platform_provider() const {
+    return managed_platform_provider_.get();
   }
 
-  ConfigurationPolicyProvider* recommended_provider() const {
+  ConfigurationPolicyProvider* device_management_provider() const {
+    return device_management_provider_.get();
+  }
+
+ConfigurationPolicyProvider* recommended_provider() const {
     return recommended_provider_.get();
   }
 
  private:
-  scoped_ptr<ConfigurationPolicyProvider> managed_provider_;
+  scoped_ptr<ConfigurationPolicyProvider> managed_platform_provider_;
+  scoped_ptr<ConfigurationPolicyProvider> device_management_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_provider_;
 
-  static ConfigurationPolicyProvider* CreateManagedProvider();
+  static ConfigurationPolicyProvider* CreateManagedPlatformProvider();
+  static ConfigurationPolicyProvider* CreateDeviceManagementProvider();
   static ConfigurationPolicyProvider* CreateRecommendedProvider();
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderKeeper);
 };
 
 
 ConfigurationPolicyProvider*
-    ConfigurationPolicyProviderKeeper::CreateManagedProvider() {
+    ConfigurationPolicyProviderKeeper::CreateDeviceManagementProvider() {
   const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
       ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
-#ifndef NDEBUG
-  // TODO(danno): This is a temporary solution only, the PrefValueStore needs to
-  // be changed to support two managed PrefStores, the local managed store and
-  // the device management policy store.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDeviceManagementUrl)) {
     return new DeviceManagementPolicyProvider(policy_list);
+  } else {
+    return new DummyConfigurationPolicyProvider(policy_list);
   }
-#endif
+}
+
+ConfigurationPolicyProvider*
+    ConfigurationPolicyProviderKeeper::CreateManagedPlatformProvider() {
+  const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
+      ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_WIN)
   return new ConfigurationPolicyProviderWin(policy_list);
 #elif defined(OS_MACOSX)
   return new ConfigurationPolicyProviderMac(policy_list);
 #elif defined(OS_POSIX)
   FilePath config_dir_path;
   if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
     return new ConfigDirPolicyProvider(
         policy_list,
         config_dir_path.Append(FILE_PATH_LITERAL("managed")));
@@ skipping 238 matching lines @@
                          arraysize(kSimplePolicyMap)))
     return;
 
   // Other policy implementations go here.
   NOTIMPLEMENTED();
   delete value;
 }
 
 // static
 ConfigurationPolicyPrefStore*
-ConfigurationPolicyPrefStore::CreateManagedPolicyPrefStore() {
+ConfigurationPolicyPrefStore::CreateManagedPlatformPolicyPrefStore() {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
-  return new ConfigurationPolicyPrefStore(keeper->managed_provider());
+  return new ConfigurationPolicyPrefStore(keeper->managed_platform_provider());
 }
 
 // static
+ConfigurationPolicyPrefStore*
+ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore() {
+  ConfigurationPolicyProviderKeeper* keeper =
+      Singleton<ConfigurationPolicyProviderKeeper>::get();
+  return new ConfigurationPolicyPrefStore(
+      keeper->device_management_provider());
+}
+
+// static
 ConfigurationPolicyPrefStore*
 ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore() {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
   return new ConfigurationPolicyPrefStore(keeper->recommended_provider());
 }
 
 // static
 void ConfigurationPolicyPrefStore::GetProxyPreferenceSet(
     ProxyPreferenceSet* proxy_pref_set) {
@@ skipping 248 matching lines @@
                         std::string());
       return;
     }
   }
   // Required entries are not there.  Remove any related entries.
   RemovePreferencesOfMap(kDefaultSearchPolicyMap,
                          arraysize(kDefaultSearchPolicyMap));
 }
 
 }  // namespace policy