Move DeviceManagementPolicyProvider into the profile.

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"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/profile.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #if defined(OS_WIN)
 #include "chrome/browser/policy/configuration_policy_provider_win.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/policy/configuration_policy_provider_mac.h"
 #elif defined(OS_POSIX)
 #include "chrome/browser/policy/config_dir_policy_provider.h"
 #endif
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/dummy_configuration_policy_provider.h"
@@ skipping 18 matching lines @@
   virtual ~ConfigurationPolicyProviderKeeper() {}
 
   ConfigurationPolicyProvider* managed_platform_provider() const {
     return managed_platform_provider_.get();
   }
 
   ConfigurationPolicyProvider* device_management_provider() const {
     return device_management_provider_.get();
   }
 
-ConfigurationPolicyProvider* recommended_provider() const {
+  ConfigurationPolicyProvider* recommended_provider() const {
     return recommended_provider_.get();
   }
 
  private:
   scoped_ptr<ConfigurationPolicyProvider> managed_platform_provider_;
   scoped_ptr<ConfigurationPolicyProvider> device_management_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_provider_;
 
   static ConfigurationPolicyProvider* CreateManagedPlatformProvider();
   static ConfigurationPolicyProvider* CreateDeviceManagementProvider();
   static ConfigurationPolicyProvider* CreateRecommendedProvider();
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderKeeper);
 };
 
-
-ConfigurationPolicyProvider*
-    ConfigurationPolicyProviderKeeper::CreateDeviceManagementProvider() {
-  const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
-      ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDeviceManagementUrl)) {
-    return new DeviceManagementPolicyProvider(policy_list);
-  } else {
-    return new DummyConfigurationPolicyProvider(policy_list);
-  }
-}
-
 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")));
   } else {
     return new DummyConfigurationPolicyProvider(policy_list);
   }
 #else
   return new DummyConfigurationPolicyProvider(policy_list);
 #endif
 }
 
 ConfigurationPolicyProvider*
+    ConfigurationPolicyProviderKeeper::CreateDeviceManagementProvider() {
+  return new DummyConfigurationPolicyProvider(
+      ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList());
+}
+
+ConfigurationPolicyProvider*
     ConfigurationPolicyProviderKeeper::CreateRecommendedProvider() {
   const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
       ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   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("recommended")));
   } else {
@@ skipping 252 matching lines @@
 // static
 ConfigurationPolicyPrefStore*
 ConfigurationPolicyPrefStore::CreateManagedPlatformPolicyPrefStore() {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
   return new ConfigurationPolicyPrefStore(keeper->managed_platform_provider());
 }
 
 // static
 ConfigurationPolicyPrefStore*
-ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore() {
+ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore(
+    Profile* profile) {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
-  return new ConfigurationPolicyPrefStore(
-      keeper->device_management_provider());
+  ConfigurationPolicyProvider* provider = NULL;
+  if (profile)
+    provider = profile->GetDeviceManagementPolicyProvider();
+  if (!provider)
+    provider = keeper->device_management_provider();
+  return new ConfigurationPolicyPrefStore(provider);
 }
 
 // static
 ConfigurationPolicyPrefStore*
 ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore() {
   ConfigurationPolicyProviderKeeper* keeper =
       Singleton<ConfigurationPolicyProviderKeeper>::get();
   return new ConfigurationPolicyPrefStore(keeper->recommended_provider());
 }
 
@@ skipping 251 matching lines @@
                         std::string());
       return;
     }
   }
   // Required entries are not there.  Remove any related entries.
   RemovePreferencesOfMap(kDefaultSearchPolicyMap,
                          arraysize(kDefaultSearchPolicyMap));
 }
 
 }  // namespace policy