Rename ChromeThread to BrowserThread Part13:

chrome/browser/prefs/pref_value_store_unittest.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 "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/dummy_pref_store.h"
 #include "chrome/browser/prefs/pref_value_store.h"
@@ skipping 115 matching lines @@
                                               Value::TYPE_INTEGER);
     pref_value_store_->RegisterPreferenceType(prefs::kRecommendedPref,
                                               Value::TYPE_BOOLEAN);
     pref_value_store_->RegisterPreferenceType(prefs::kSampleDict,
                                               Value::TYPE_DICTIONARY);
     pref_value_store_->RegisterPreferenceType(prefs::kSampleList,
                                               Value::TYPE_LIST);
     pref_value_store_->RegisterPreferenceType(prefs::kDefaultPref,
                                               Value::TYPE_INTEGER);
 
-    ui_thread_.reset(new ChromeThread(ChromeThread::UI, &loop_));
-    file_thread_.reset(new ChromeThread(ChromeThread::FILE, &loop_));
+    ui_thread_.reset(new BrowserThread(BrowserThread::UI, &loop_));
+    file_thread_.reset(new BrowserThread(BrowserThread::FILE, &loop_));
   }
 
   // Creates a new dictionary and stores some sample user preferences
   // in it.
   DictionaryValue* CreateUserPrefs() {
     DictionaryValue* user_prefs = new DictionaryValue();
     user_prefs->SetBoolean(prefs::kDeleteCache, user_pref::kDeleteCacheValue);
     user_prefs->SetInteger(prefs::kMaxTabs, user_pref::kMaxTabsValue);
     user_prefs->SetString(prefs::kCurrentThemeID,
         user_pref::kCurrentThemeIDValue);
@@ skipping 95 matching lines @@
 
   // Preferences are owned by the individual |DummyPrefStores|.
   DictionaryValue* enforced_prefs_;
   DictionaryValue* extension_prefs_;
   DictionaryValue* command_line_prefs_;
   DictionaryValue* user_prefs_;
   DictionaryValue* recommended_prefs_;
   DictionaryValue* default_prefs_;
 
  private:
-  scoped_ptr<ChromeThread> ui_thread_;
-  scoped_ptr<ChromeThread> file_thread_;
+  scoped_ptr<BrowserThread> ui_thread_;
+  scoped_ptr<BrowserThread> file_thread_;
 };
 
 TEST_F(PrefValueStoreTest, IsReadOnly) {
   enforced_pref_store_->set_read_only(true);
   extension_pref_store_->set_read_only(true);
   command_line_pref_store_->set_read_only(true);
   user_pref_store_->set_read_only(true);
   recommended_pref_store_->set_read_only(true);
   default_pref_store_->set_read_only(true);
   EXPECT_TRUE(pref_value_store_->ReadOnly());
@@ skipping 368 matching lines @@
       pref_value_store_->PrefValueFromDefaultStore(prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, TestPolicyRefresh) {
   // pref_value_store_ is initialized by PrefValueStoreTest to have values
   // in both it's managed and recommended store. By replacing them with
   // dummy stores, all of the paths of the prefs originally managed and
   // recommended stores should change.
   MockPolicyRefreshCallback callback;
   EXPECT_CALL(callback, DoCallback(_)).Times(0);
-  ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
           &PrefValueStore::RefreshPolicyPrefs,
           new DummyPrefStore(),
           new DummyPrefStore(),
           NewCallback(&callback,
                       &MockPolicyRefreshCallback::DoCallback)));
   Mock::VerifyAndClearExpectations(&callback);
   EXPECT_CALL(callback, DoCallback(expected_differing_paths_)).Times(1);
   loop_.RunAllPending();
@@ skipping 56 matching lines @@
   EXPECT_CALL(callback4, DoCallback(expected_differing_paths_)).Times(1);
   pref_value_store_->RefreshPolicyPrefsCompletion(
       new_managed_store.release(),
       new DummyPrefStore(),
       NewCallback(&callback4,
                   &MockPolicyRefreshCallback::DoCallback));
 }
 
 TEST_F(PrefValueStoreTest, TestConcurrentPolicyRefresh) {
   MockPolicyRefreshCallback callback1;
-  ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
           &PrefValueStore::RefreshPolicyPrefs,
           new DummyPrefStore(),
           new DummyPrefStore(),
           NewCallback(&callback1,
                       &MockPolicyRefreshCallback::DoCallback)));
   EXPECT_CALL(callback1, DoCallback(_)).Times(0);
 
   MockPolicyRefreshCallback callback2;
-  ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
           &PrefValueStore::RefreshPolicyPrefs,
           new DummyPrefStore(),
           new DummyPrefStore(),
           NewCallback(&callback2,
                       &MockPolicyRefreshCallback::DoCallback)));
   EXPECT_CALL(callback2, DoCallback(_)).Times(0);
 
   MockPolicyRefreshCallback callback3;
-  ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
           &PrefValueStore::RefreshPolicyPrefs,
           new DummyPrefStore(),
           new DummyPrefStore(),
           NewCallback(&callback3,
                       &MockPolicyRefreshCallback::DoCallback)));
   EXPECT_CALL(callback3, DoCallback(_)).Times(0);
   Mock::VerifyAndClearExpectations(&callback1);
   Mock::VerifyAndClearExpectations(&callback2);
   Mock::VerifyAndClearExpectations(&callback3);
 
   EXPECT_CALL(callback1, DoCallback(expected_differing_paths_)).Times(1);
   std::vector<std::string> no_differing_paths;
   EXPECT_CALL(callback2, DoCallback(no_differing_paths)).Times(1);
   EXPECT_CALL(callback3, DoCallback(no_differing_paths)).Times(1);
   loop_.RunAllPending();
 }