Refactor useful test helpers to separate files.

components/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 "components/search_engines/default_search_manager.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.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 "components/pref_registry/pref_registry_syncable.h"
+#include "components/search_engines/default_search_manager.h"
 #include "components/search_engines/search_engines_pref_names.h"
+#include "components/search_engines/search_engines_test_util.h"
 #include "components/search_engines/template_url_data.h"
 #include "components/search_engines/template_url_data_util.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/sync_preferences/testing_pref_service_syncable.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";
-
-// Checks that the two TemplateURLs are similar. Does not check the id or
-// any time-related fields.  Neither pointer should be null.
-void ExpectSimilar(const TemplateURLData* expected,
-                   const TemplateURLData* actual) {
-  ASSERT_TRUE(expected != NULL);
-  ASSERT_TRUE(actual != NULL);
-
-  EXPECT_EQ(expected->short_name(), actual->short_name());
-  EXPECT_EQ(expected->keyword(), actual->keyword());
-  EXPECT_EQ(expected->url(), actual->url());
-  EXPECT_EQ(expected->suggestions_url, actual->suggestions_url);
-  EXPECT_EQ(expected->favicon_url, actual->favicon_url);
-  EXPECT_EQ(expected->alternate_urls, actual->alternate_urls);
-  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(sync_preferences::TestingPrefServiceSyncable* prefs,
                   bool update) {
   prefs->SetUserPref(prefs::kSearchProviderOverridesVersion,
                      new base::FundamentalValue(1));
   base::ListValue* overrides = new base::ListValue;
   std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
 
   entry->SetString("name", update ? "new_foo" : "foo");
@@ skipping 27 matching lines @@
 void SetPolicy(sync_preferences::TestingPrefServiceSyncable* prefs,
                bool enabled,
                TemplateURLData* data) {
   if (enabled) {
     EXPECT_FALSE(data->keyword().empty());
     EXPECT_FALSE(data->url().empty());
   }
   std::unique_ptr<base::DictionaryValue> entry(
       TemplateURLDataToDictionary(*data));
   entry->SetBoolean(DefaultSearchManager::kDisabledByPolicy, !enabled);
-  prefs->SetManagedPref(kDefaultSearchProviderData, entry.release());
-}
-
-std::unique_ptr<TemplateURLData> GenerateDummyTemplateURLData(
-    const std::string& type) {
-  std::unique_ptr<TemplateURLData> data(new TemplateURLData());
-  data->SetShortName(base::UTF8ToUTF16(std::string(type).append("name")));
-  data->SetKeyword(base::UTF8ToUTF16(std::string(type).append("key")));
-  data->SetURL(std::string("http://").append(type).append("foo/{searchTerms}"));
-  data->suggestions_url = std::string("http://").append(type).append("sugg");
-  data->alternate_urls.push_back(
-      std::string("http://").append(type).append("foo/alt"));
-  data->favicon_url = GURL("http://icon1");
-  data->safe_for_autoreplace = true;
-  data->input_encodings = base::SplitString(
-      "UTF-8;UTF-16", ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  data->date_created = base::Time();
-  data->last_modified = base::Time();
-  data->last_visited = base::Time();
-  return data;
+  prefs->SetManagedPref(
+      DefaultSearchManager::kDefaultSearchProviderDataPrefName,
+      entry.release());
 }
 
 }  // namespace
 
 class DefaultSearchManagerTest : public testing::Test {
  public:
   DefaultSearchManagerTest() {};
 
   void SetUp() override {
     pref_service_.reset(new sync_preferences::TestingPrefServiceSyncable);
@@ skipping 120 matching lines @@
   SetPolicy(pref_service(), true, policy_data.get());
 
   ExpectSimilar(policy_data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source);
 
   TemplateURLData null_policy_data;
   SetPolicy(pref_service(), false, &null_policy_data);
   EXPECT_EQ(NULL, manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source);
 
-  pref_service()->RemoveManagedPref(kDefaultSearchProviderData);
+  pref_service()->RemoveManagedPref(
+      DefaultSearchManager::kDefaultSearchProviderDataPrefName);
   ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_USER, source);
 }
 
 // Test DefaultSearchManager handles extension-controlled DSEs correctly.
 TEST_F(DefaultSearchManagerTest, DefaultSearchSetByExtension) {
   DefaultSearchManager manager(pref_service(),
                                DefaultSearchManager::ObserverCallback());
   std::unique_ptr<TemplateURLData> data = GenerateDummyTemplateURLData("user");
   manager.SetUserSelectedDefaultSearchEngine(*data);
@@ skipping 11 matching lines @@
                 manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source);
 
   // Policy trumps extension:
   std::unique_ptr<TemplateURLData> policy_data =
       GenerateDummyTemplateURLData("policy");
   SetPolicy(pref_service(), true, policy_data.get());
 
   ExpectSimilar(policy_data.get(), manager.GetDefaultSearchEngine(&source));
   EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source);
-  pref_service()->RemoveManagedPref(kDefaultSearchProviderData);
+  pref_service()->RemoveManagedPref(
+      DefaultSearchManager::kDefaultSearchProviderDataPrefName);
 
   // Extensions trump each other:
   std::unique_ptr<TemplateURLData> extension_data_2 =
       GenerateDummyTemplateURLData("ext2");
   std::unique_ptr<TemplateURLData> extension_data_3 =
       GenerateDummyTemplateURLData("ext3");
   manager.SetExtensionControlledDefaultSearchEngine(*extension_data_2);
   manager.SetExtensionControlledDefaultSearchEngine(*extension_data_3);
 
   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);
 }