Rename ChromeThread to BrowserThread Part13:

chrome/browser/prefs/pref_value_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/prefs/pref_value_store.h"
 
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
@@ skipping 28 matching lines @@
     Profile* profile,
     bool user_only) {
   using policy::ConfigurationPolicyPrefStore;
   ConfigurationPolicyPrefStore* managed = NULL;
   ExtensionPrefStore* extension = NULL;
   CommandLinePrefStore* command_line = NULL;
   ConfigurationPolicyPrefStore* recommended = NULL;
 
   JsonPrefStore* user = new JsonPrefStore(
       pref_filename,
-      ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE));
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   DefaultPrefStore* default_store = new DefaultPrefStore();
 
   if (!user_only) {
     managed = ConfigurationPolicyPrefStore::CreateManagedPolicyPrefStore();
     extension = new ExtensionPrefStore(profile, PrefNotifier::EXTENSION_STORE);
     command_line = new CommandLinePrefStore(CommandLine::ForCurrentProcess());
     recommended =
         ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore();
   }
   return new PrefValueStore(managed, extension, command_line, user,
@@ skipping 219 matching lines @@
                  changed_paths.begin());
   changed_paths.resize(last_insert - changed_paths.begin());
 
   pref_stores_[PrefNotifier::MANAGED_STORE].reset(new_managed_pref_store);
   pref_stores_[PrefNotifier::RECOMMENDED_STORE].reset(
       new_recommended_pref_store);
   callback->Run(changed_paths);
 }
 
 void PrefValueStore::RefreshPolicyPrefsOnFileThread(
-    ChromeThread::ID calling_thread_id,
+    BrowserThread::ID calling_thread_id,
     PrefStore* new_managed_pref_store,
     PrefStore* new_recommended_pref_store,
     AfterRefreshCallback* callback_pointer) {
   scoped_ptr<AfterRefreshCallback> callback(callback_pointer);
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   scoped_ptr<PrefStore> managed_pref_store(new_managed_pref_store);
   scoped_ptr<PrefStore> recommended_pref_store(new_recommended_pref_store);
 
   PrefStore::PrefReadError read_error = new_managed_pref_store->ReadPrefs();
   if (read_error != PrefStore::PREF_READ_ERROR_NONE) {
     LOG(ERROR) << "refresh of managed policy failed: PrefReadError = "
                << read_error;
     return;
   }
 
   read_error = new_recommended_pref_store->ReadPrefs();
   if (read_error != PrefStore::PREF_READ_ERROR_NONE) {
     LOG(ERROR) << "refresh of recommended policy failed: PrefReadError = "
                << read_error;
     return;
   }
 
-  ChromeThread::PostTask(
+  BrowserThread::PostTask(
       calling_thread_id, FROM_HERE,
       NewRunnableMethod(this,
                         &PrefValueStore::RefreshPolicyPrefsCompletion,
                         managed_pref_store.release(),
                         recommended_pref_store.release(),
                         callback.release()));
 }
 
 void PrefValueStore::RefreshPolicyPrefs(
     PrefStore* new_managed_pref_store,
     PrefStore* new_recommended_pref_store,
     AfterRefreshCallback* callback) {
-  ChromeThread::ID current_thread_id;
-  CHECK(ChromeThread::GetCurrentThreadIdentifier(&current_thread_id));
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
+  BrowserThread::ID current_thread_id;
+  CHECK(BrowserThread::GetCurrentThreadIdentifier(&current_thread_id));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &PrefValueStore::RefreshPolicyPrefsOnFileThread,
                         current_thread_id,
                         new_managed_pref_store,
                         new_recommended_pref_store,
                         callback));
 }
 
 PrefValueStore::PrefValueStore(PrefStore* managed_prefs,
                                PrefStore* extension_prefs,
                                PrefStore* command_line_prefs,
                                PrefStore* user_prefs,
                                PrefStore* recommended_prefs,
                                PrefStore* default_prefs) {
   // NULL default pref store is usually bad, but may be OK for some unit tests.
   if (!default_prefs)
     LOG(WARNING) << "default pref store is null";
   pref_stores_[PrefNotifier::MANAGED_STORE].reset(managed_prefs);
   pref_stores_[PrefNotifier::EXTENSION_STORE].reset(extension_prefs);
   pref_stores_[PrefNotifier::COMMAND_LINE_STORE].reset(command_line_prefs);
   pref_stores_[PrefNotifier::USER_STORE].reset(user_prefs);
   pref_stores_[PrefNotifier::RECOMMENDED_STORE].reset(recommended_prefs);
   pref_stores_[PrefNotifier::DEFAULT_STORE].reset(default_prefs);
 }