Add user_prefs::TestPrefServiceSyncable

chrome/browser/search_engines/default_search_manager_unittest.cc

 // Copyright 2014 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/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_pref_service_syncable.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/pref_registry/testing_pref_service_syncable.h"
 #include "components/search_engines/template_url_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 // A dictionary to hold all data related to the Default Search Engine.
 // Eventually, this should replace all the data stored in the
 // default_search_provider.* prefs.
 const char kDefaultSearchProviderData[] =
     "default_search_provider_data.template_url_data";
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(expected->favicon_url, actual->favicon_url);
   EXPECT_EQ(expected->alternate_urls, actual->alternate_urls);
   EXPECT_EQ(expected->show_in_default_list, actual->show_in_default_list);
   EXPECT_EQ(expected->safe_for_autoreplace, actual->safe_for_autoreplace);
   EXPECT_EQ(expected->input_encodings, actual->input_encodings);
   EXPECT_EQ(expected->search_terms_replacement_key,
             actual->search_terms_replacement_key);
 }
 
 // TODO(caitkp): TemplateURLData-ify this.
-void SetOverrides(TestingPrefServiceSyncable* prefs, bool update) {
+void SetOverrides(user_prefs::TestingPrefServiceSyncable* prefs, bool update) {
   prefs->SetUserPref(prefs::kSearchProviderOverridesVersion,
                      base::Value::CreateIntegerValue(1));
   base::ListValue* overrides = new base::ListValue;
   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
 
   entry->SetString("name", update ? "new_foo" : "foo");
   entry->SetString("keyword", update ? "new_fook" : "fook");
   entry->SetString("search_url", "http://foo.com/s?q={searchTerms}");
   entry->SetString("favicon_url", "http://foi.com/favicon.ico");
   entry->SetString("encoding", "UTF-8");
@@ skipping 13 matching lines @@
   entry->SetString("encoding", std::string());
   overrides->Append(entry->DeepCopy());
   entry->SetInteger("id", 1003);
   entry->SetString("name", "baz");
   entry->SetString("keyword", "bazk");
   entry->SetString("encoding", "UTF-8");
   overrides->Append(entry->DeepCopy());
   prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
 }
 
-void SetPolicy(TestingPrefServiceSyncable* prefs,
+void SetPolicy(user_prefs::TestingPrefServiceSyncable* prefs,
                bool enabled,
                TemplateURLData* data) {
   if (enabled) {
     EXPECT_FALSE(data->keyword().empty());
     EXPECT_FALSE(data->url().empty());
   }
   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
   entry->SetString(DefaultSearchManager::kShortName, data->short_name);
   entry->SetString(DefaultSearchManager::kKeyword, data->keyword());
   entry->SetString(DefaultSearchManager::kURL, data->url());
@@ skipping 43 matching lines @@
   return data.Pass();
 }
 
 }  // namespace
 
 class DefaultSearchManagerTest : public testing::Test {
  public:
   DefaultSearchManagerTest() {};
 
   virtual void SetUp() OVERRIDE {
-    pref_service_.reset(new TestingPrefServiceSyncable);
+    pref_service_.reset(new user_prefs::TestingPrefServiceSyncable);
     DefaultSearchManager::RegisterProfilePrefs(pref_service_->registry());
     TemplateURLPrepopulateData::RegisterProfilePrefs(pref_service_->registry());
   }
 
-  TestingPrefServiceSyncable* pref_service() { return pref_service_.get(); }
+  user_prefs::TestingPrefServiceSyncable* pref_service() {
+    return pref_service_.get();
+  }
 
  private:
-  scoped_ptr<TestingPrefServiceSyncable> pref_service_;
+  scoped_ptr<user_prefs::TestingPrefServiceSyncable> pref_service_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultSearchManagerTest);
 };
 
 // Test that a TemplateURLData object is properly written and read from Prefs.
 TEST_F(DefaultSearchManagerTest, ReadAndWritePref) {
   DefaultSearchManager manager(pref_service(),
                                DefaultSearchManager::ObserverCallback());
   TemplateURLData data;
   data.short_name = base::UTF8ToUTF16("name1");
@@ skipping 149 matching lines @@
 
   ExpectSimilar(extension_data_3.get(),
                 manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source);
 
   manager.ClearExtensionControlledDefaultSearchEngine();
 
   ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_USER, source);
 }