Refactored ConfigurationPolicyPrefStore to not depend on chrome/.

chrome/browser/policy/configuration_policy_pref_store.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/configuration_policy_pref_store.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_value_map.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/configuration_policy_handler_list.h"
 #include "chrome/browser/policy/policy_error_map.h"
-#include "content/public/browser/browser_thread.h"
 #include "policy/policy_constants.h"
 
-using content::BrowserThread;
-
 namespace policy {
 
 namespace {
 
 // Policies are loaded early on startup, before PolicyErrorMaps are ready to
 // be retrieved. This function is posted to UI to log any errors found on
 // Refresh below.
 void LogErrors(PolicyErrorMap* errors) {
   PolicyErrorMap::const_iterator iter;
   for (iter = errors->begin(); iter != errors->end(); ++iter) {
     string16 policy = ASCIIToUTF16(iter->first);
     DLOG(WARNING) << "Policy " << policy << ": " << iter->second;
   }
 }
 
 }  // namespace
 
 ConfigurationPolicyPrefStore::ConfigurationPolicyPrefStore(
     PolicyService* service,
+    const ConfigurationPolicyHandlerList* handler_list,
     PolicyLevel level)
     : policy_service_(service),
+      handler_list_(handler_list),
       level_(level) {
   // Read initial policy.
   prefs_.reset(CreatePreferencesFromPolicies());
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, this);
 }
 
 void ConfigurationPolicyPrefStore::AddObserver(PrefStore::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 31 matching lines @@
 }
 
 void ConfigurationPolicyPrefStore::OnPolicyServiceInitialized(
     PolicyDomain domain) {
   if (domain == POLICY_DOMAIN_CHROME) {
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted(true));
   }
 }
 
-// static
-ConfigurationPolicyPrefStore*
-ConfigurationPolicyPrefStore::CreateMandatoryPolicyPrefStore(
-    PolicyService* policy_service) {
-  return new ConfigurationPolicyPrefStore(policy_service,
-                                          POLICY_LEVEL_MANDATORY);
-}
-
-// static
-ConfigurationPolicyPrefStore*
-ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore(
-    PolicyService* policy_service) {
-  return new ConfigurationPolicyPrefStore(policy_service,
-                                          POLICY_LEVEL_RECOMMENDED);
-}
-
 ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() {
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, this);
 }
 
 void ConfigurationPolicyPrefStore::Refresh() {
   scoped_ptr<PrefValueMap> new_prefs(CreatePreferencesFromPolicies());
   std::vector<std::string> changed_prefs;
   new_prefs->GetDifferingKeys(prefs_.get(), &changed_prefs);
   prefs_.swap(new_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));
   }
 }
 
 PrefValueMap* ConfigurationPolicyPrefStore::CreatePreferencesFromPolicies() {
   scoped_ptr<PrefValueMap> prefs(new PrefValueMap);
   PolicyMap filtered_policies;
   filtered_policies.CopyFrom(policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())));
   filtered_policies.FilterLevel(level_);
 
   scoped_ptr<PolicyErrorMap> errors(new PolicyErrorMap);
 
-  const ConfigurationPolicyHandlerList* handler_list =
-      g_browser_process->browser_policy_connector()->GetHandlerList();
-  handler_list->ApplyPolicySettings(filtered_policies,
-                                    prefs.get(),
-                                    errors.get());
+  handler_list_->ApplyPolicySettings(filtered_policies,
+                                     prefs.get(),
+                                     errors.get());
 
   // Retrieve and log the errors once the UI loop is ready. This is only an
   // issue during startup.
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&LogErrors,
-                                     base::Owned(errors.release())));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&LogErrors, base::Owned(errors.release())));
 
   return prefs.release();
 }
 
 }  // namespace policy