Removed the PolicyDefinitionList from the ConfigurationPolicyProvider interface.

chrome/browser/policy/user_cloud_policy_manager.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/user_cloud_policy_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "chrome/browser/policy/cloud_policy_refresh_scheduler.h"
 #include "chrome/browser/policy/cloud_policy_service.h"
 #include "chrome/browser/policy/policy_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
-#include "policy/policy_constants.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/policy/user_cloud_policy_store_chromeos.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #endif
 
 namespace policy {
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 // Paths for the legacy policy caches in the profile directory.
 // TODO(mnissler): Remove once the number of pre-M20 clients becomes negligible.
 
 // Subdirectory in the user's profile for storing user policies.
 const FilePath::CharType kPolicyDir[] = FILE_PATH_LITERAL("Device Management");
 // File in the above directory for stroing user policy dmtokens.
 const FilePath::CharType kTokenCacheFile[] = FILE_PATH_LITERAL("Token");
 // File in the above directory for storing user policy data.
 const FilePath::CharType kPolicyCacheFile[] = FILE_PATH_LITERAL("Policy");
 #endif
 
 }  // namespace
 
 UserCloudPolicyManager::UserCloudPolicyManager(
-    const PolicyDefinitionList* policy_list,
     scoped_ptr<CloudPolicyStore> store,
     bool wait_for_policy_fetch)
-    : ConfigurationPolicyProvider(policy_list),
-      wait_for_policy_fetch_(wait_for_policy_fetch),
+    : wait_for_policy_fetch_(wait_for_policy_fetch),
       wait_for_policy_refresh_(false),
       store_(store.Pass()) {
   store_->Load();
   store_->AddObserver(this);
 }
 
 UserCloudPolicyManager::~UserCloudPolicyManager() {
   Shutdown();
   store_->RemoveObserver(this);
 }
@@ skipping 10 matching lines @@
           .Append(command_line->GetSwitchValuePath(switches::kLoginProfile))
           .Append(kPolicyDir);
   const FilePath policy_cache_file = policy_dir.Append(kPolicyCacheFile);
   const FilePath token_cache_file = policy_dir.Append(kTokenCacheFile);
 
   scoped_ptr<CloudPolicyStore> store(
       new UserCloudPolicyStoreChromeOS(
           chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
           token_cache_file, policy_cache_file));
   return scoped_ptr<UserCloudPolicyManager>(
-      new UserCloudPolicyManager(GetChromePolicyDefinitionList(),
-                                 store.Pass(), wait_for_policy_fetch));
+      new UserCloudPolicyManager(store.Pass(), wait_for_policy_fetch));
 }
 #endif
 
 void UserCloudPolicyManager::Initialize(PrefService* prefs,
                                         DeviceManagementService* service,
                                         UserAffiliation user_affiliation) {
   DCHECK(!service_.get());
   prefs_ = prefs;
   scoped_ptr<CloudPolicyClient> client(
       new CloudPolicyClient(std::string(), std::string(), user_affiliation,
@@ skipping 100 matching lines @@
 void UserCloudPolicyManager::OnInitialPolicyFetchComplete() {
   CancelWaitForPolicyFetch();
 }
 
 void UserCloudPolicyManager::OnRefreshComplete() {
   wait_for_policy_refresh_ = false;
   CheckAndPublishPolicy();
 }
 
 }  // namespace policy