Store default search provider data in dictionary pref, and add...

Store default search provider data in dictionary pref, and add DefaultSearchManager class to handle the reading and writing of this pref (DefaultSearchManager will eventually all default search related concerns).

This pref will be used to persist data about user-selected
default search providers. In future CLs, support will be added for default search providers set by policy and sync.

BUG=365762

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=266479

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=266615

R=gab@chromium.org, pkasting@chromium.org

Review URL: https://codereview.chromium.org/229763005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@266891 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/search_engines/default_search_manager.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 "chrome/browser/search_engines/default_search_manager.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/compiler_specific.h"
+#include "base/i18n/case_conversion.h"
+#include "base/prefs/pref_service.h"
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.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/profiles/profile.h"
+#include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/browser/search_engines/util.h"
+#include "chrome/common/pref_names.h"
+#include "components/user_prefs/pref_registry_syncable.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";
+
+}  // namespace
+
+const char DefaultSearchManager::kID[] = "id";
+const char DefaultSearchManager::kShortName[] = "short_name";
+const char DefaultSearchManager::kKeyword[] = "keyword";
+const char DefaultSearchManager::kPrepopulateID[] = "prepopulate_id";
+const char DefaultSearchManager::kSyncGUID[] = "synced_guid";
+
+const char DefaultSearchManager::kURL[] = "url";
+const char DefaultSearchManager::kSuggestionsURL[] = "suggestions_url";
+const char DefaultSearchManager::kInstantURL[] = "instant_url";
+const char DefaultSearchManager::kImageURL[] = "image_url";
+const char DefaultSearchManager::kNewTabURL[] = "new_tab_url";
+const char DefaultSearchManager::kFaviconURL[] = "favicon_url";
+const char DefaultSearchManager::kOriginatingURL[] = "originating_url";
+
+const char DefaultSearchManager::kSearchURLPostParams[] =
+    "search_url_post_params";
+const char DefaultSearchManager::kSuggestionsURLPostParams[] =
+    "suggestions_url_post_params";
+const char DefaultSearchManager::kInstantURLPostParams[] =
+    "instant_url_post_params";
+const char DefaultSearchManager::kImageURLPostParams[] =
+    "image_url_post_params";
+
+const char DefaultSearchManager::kSafeForAutoReplace[] = "safe_for_autoreplace";
+const char DefaultSearchManager::kInputEncodings[] = "input_encodings";
+
+const char DefaultSearchManager::kDateCreated[] = "date_created";
+const char DefaultSearchManager::kLastModified[] = "last_modified";
+
+const char DefaultSearchManager::kUsageCount[] = "usage_count";
+const char DefaultSearchManager::kAlternateURLs[] = "alternate_urls";
+const char DefaultSearchManager::kSearchTermsReplacementKey[] =
+    "search_terms_replacement_key";
+const char DefaultSearchManager::kCreatedByPolicy[] = "created_by_policy";
+
+DefaultSearchManager::DefaultSearchManager(PrefService* pref_service)
+    : pref_service_(pref_service) {
+  DCHECK(pref_service_);
+}
+
+DefaultSearchManager::~DefaultSearchManager() {
+}
+
+// static
+void DefaultSearchManager::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterDictionaryPref(
+      kDefaultSearchProviderData,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+bool DefaultSearchManager::GetDefaultSearchEngine(TemplateURLData* data) {
+  const base::DictionaryValue* url_dict =
+      pref_service_->GetDictionary(kDefaultSearchProviderData);
+
+  if (url_dict->empty())
+    return false;
+
+  std::string search_url;
+  base::string16 keyword;
+  url_dict->GetString(kURL, &search_url);
+  url_dict->GetString(kKeyword, &keyword);
+  if (search_url.empty())
+    return false;
+  if (keyword.empty())
+    keyword = TemplateURLService::GenerateKeyword(GURL(search_url));
+  data->SetKeyword(keyword);
+  data->SetURL(search_url);
+
+  std::string id;
+  url_dict->GetString(kID, &id);
+  base::StringToInt64(id, &data->id);
+  url_dict->GetString(kShortName, &data->short_name);
+  url_dict->GetInteger(kPrepopulateID, &data->prepopulate_id);
+  url_dict->GetString(kSyncGUID, &data->sync_guid);
+
+  url_dict->GetString(kSuggestionsURL, &data->suggestions_url);
+  url_dict->GetString(kInstantURL, &data->instant_url);
+  url_dict->GetString(kImageURL, &data->image_url);
+  url_dict->GetString(kNewTabURL, &data->new_tab_url);
+
+  std::string favicon_url;
+  std::string originating_url;
+  url_dict->GetString(kFaviconURL, &favicon_url);
+  url_dict->GetString(kOriginatingURL, &originating_url);
+  data->favicon_url = GURL(favicon_url);
+  data->originating_url = GURL(originating_url);
+
+  url_dict->GetString(kSearchURLPostParams, &data->search_url_post_params);
+  url_dict->GetString(kSuggestionsURLPostParams,
+                      &data->suggestions_url_post_params);
+  url_dict->GetString(kInstantURLPostParams, &data->instant_url_post_params);
+  url_dict->GetString(kImageURLPostParams, &data->image_url_post_params);
+
+  url_dict->GetBoolean(kSafeForAutoReplace, &data->safe_for_autoreplace);
+
+  double date_created = 0.0;
+  double last_modified = 0.0;
+  url_dict->GetDouble(kDateCreated, &date_created);
+  url_dict->GetDouble(kLastModified, &last_modified);
+  data->date_created = base::Time::FromInternalValue(date_created);
+  data->last_modified = base::Time::FromInternalValue(last_modified);
+
+  url_dict->GetInteger(kUsageCount, &data->usage_count);
+
+  const base::ListValue* alternate_urls;
+  url_dict->GetList(kAlternateURLs, &alternate_urls);
+  data->alternate_urls.clear();
+  for (base::ListValue::const_iterator it = alternate_urls->begin();
+       it != alternate_urls->end(); ++it) {
+    std::string alternate_url;
+    if ((*it)->GetAsString(&alternate_url))
+      data->alternate_urls.push_back(alternate_url);
+  }
+
+  const base::ListValue* encodings;
+  url_dict->GetList(kInputEncodings, &encodings);
+  data->input_encodings.clear();
+  for (base::ListValue::const_iterator it = encodings->begin();
+       it != encodings->end(); ++it) {
+    std::string encoding;
+    if ((*it)->GetAsString(&encoding))
+      data->input_encodings.push_back(encoding);
+  }
+
+  url_dict->GetString(kSearchTermsReplacementKey,
+                      &data->search_terms_replacement_key);
+
+  url_dict->GetBoolean(kCreatedByPolicy, &data->created_by_policy);
+
+  data->show_in_default_list = true;
+
+  return true;
+}
+
+void DefaultSearchManager::SetUserSelectedDefaultSearchEngine(
+    const TemplateURLData& data) {
+  base::DictionaryValue url_dict;
+  url_dict.SetString(kID, base::Int64ToString(data.id));
+  url_dict.SetString(kShortName, data.short_name);
+  url_dict.SetString(kKeyword, data.keyword());
+  url_dict.SetInteger(kPrepopulateID, data.prepopulate_id);
+  url_dict.SetString(kSyncGUID, data.sync_guid);
+
+  url_dict.SetString(kURL, data.url());
+  url_dict.SetString(kSuggestionsURL, data.suggestions_url);
+  url_dict.SetString(kInstantURL, data.instant_url);
+  url_dict.SetString(kImageURL, data.image_url);
+  url_dict.SetString(kNewTabURL, data.new_tab_url);
+  url_dict.SetString(kFaviconURL, data.favicon_url.spec());
+  url_dict.SetString(kOriginatingURL, data.originating_url.spec());
+
+  url_dict.SetString(kSearchURLPostParams, data.search_url_post_params);
+  url_dict.SetString(kSuggestionsURLPostParams,
+                     data.suggestions_url_post_params);
+  url_dict.SetString(kInstantURLPostParams, data.instant_url_post_params);
+  url_dict.SetString(kImageURLPostParams, data.image_url_post_params);
+
+  url_dict.SetBoolean(kSafeForAutoReplace, data.safe_for_autoreplace);
+
+  url_dict.SetDouble(kDateCreated, data.date_created.ToInternalValue());
+  url_dict.SetDouble(kLastModified, data.last_modified.ToInternalValue());
+  url_dict.SetInteger(kUsageCount, data.usage_count);
+
+  scoped_ptr<base::ListValue> alternate_urls(new base::ListValue);
+  for (std::vector<std::string>::const_iterator it =
+           data.alternate_urls.begin();
+       it != data.alternate_urls.end(); ++it) {
+    alternate_urls->AppendString(*it);
+  }
+  url_dict.Set(kAlternateURLs, alternate_urls.release());
+
+  scoped_ptr<base::ListValue> encodings(new base::ListValue);
+  for (std::vector<std::string>::const_iterator it =
+           data.input_encodings.begin();
+       it != data.input_encodings.end(); ++it) {
+    encodings->AppendString(*it);
+  }
+  url_dict.Set(kInputEncodings, encodings.release());
+
+  url_dict.SetString(kSearchTermsReplacementKey,
+                     data.search_terms_replacement_key);
+
+  url_dict.SetBoolean(kCreatedByPolicy, data.created_by_policy);
+
+  pref_service_->Set(kDefaultSearchProviderData, url_dict);
+}
+
+void DefaultSearchManager::ClearUserSelectedDefaultSearchEngine() {
+  pref_service_->ClearPref(kDefaultSearchProviderData);
+}

chrome/browser/search_engines/default_search_manager.h

+// 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.
+
+#ifndef CHROME_BROWSER_SEARCH_ENGINES_DEFAULT_SEARCH_MANAGER_H_
+#define CHROME_BROWSER_SEARCH_ENGINES_DEFAULT_SEARCH_MANAGER_H_
+
+#include "base/macros.h"
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
+class PrefService;
+struct TemplateURLData;
+
+// DefaultSearchManager handles the loading and writing of the user's default
+// search engine selection to and from prefs.
+
+class DefaultSearchManager {
+ public:
+  static const char kID[];
+  static const char kShortName[];
+  static const char kKeyword[];
+  static const char kPrepopulateID[];
+  static const char kSyncGUID[];
+
+  static const char kURL[];
+  static const char kSuggestionsURL[];
+  static const char kInstantURL[];
+  static const char kImageURL[];
+  static const char kNewTabURL[];
+  static const char kFaviconURL[];
+  static const char kOriginatingURL[];
+
+  static const char kSearchURLPostParams[];
+  static const char kSuggestionsURLPostParams[];
+  static const char kInstantURLPostParams[];
+  static const char kImageURLPostParams[];
+
+  static const char kSafeForAutoReplace[];
+  static const char kInputEncodings[];
+
+  static const char kDateCreated[];
+  static const char kLastModified[];
+
+  static const char kUsageCount[];
+  static const char kAlternateURLs[];
+  static const char kSearchTermsReplacementKey[];
+  static const char kCreatedByPolicy[];
+
+  explicit DefaultSearchManager(PrefService* pref_service);
+  ~DefaultSearchManager();
+
+  // Register prefs needed for tracking the default search provider.
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  // Read default search provider data from |pref_service_|.
+  bool GetDefaultSearchEngine(TemplateURLData* url);
+
+  // Write default search provider data to |pref_service_|.
+  void SetUserSelectedDefaultSearchEngine(const TemplateURLData& data);
+
+  // Clear the user's default search provider choice from |pref_service_|.
+  void ClearUserSelectedDefaultSearchEngine();
+
+ private:
+  PrefService* pref_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultSearchManager);
+};
+
+#endif  // CHROME_BROWSER_SEARCH_ENGINES_DEFAULT_SEARCH_MANAGER_H_

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/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.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
+#include "components/user_prefs/pref_registry_syncable.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// Checks that the two TemplateURLs are similar. It does not check the id, the
+// date_created or the last_modified time.  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->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);
+}
+
+}  // namespace
+
+class DefaultSearchManagerTest : public testing::Test {
+ public:
+  DefaultSearchManagerTest() {};
+
+  virtual void SetUp() OVERRIDE {
+    pref_service_.reset(new TestingPrefServiceSyncable);
+    DefaultSearchManager::RegisterProfilePrefs(pref_service_->registry());
+  }
+
+  PrefService* pref_service() { return pref_service_.get(); }
+
+ private:
+  scoped_ptr<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());
+  TemplateURLData data;
+  data.short_name = base::UTF8ToUTF16("name1");
+  data.SetKeyword(base::UTF8ToUTF16("key1"));
+  data.SetURL("http://foo1/{searchTerms}");
+  data.suggestions_url = "http://sugg1";
+  data.alternate_urls.push_back("http://foo1/alt");
+  data.favicon_url = GURL("http://icon1");
+  data.safe_for_autoreplace = true;
+  data.show_in_default_list = true;
+  base::SplitString("UTF-8;UTF-16", ';', &data.input_encodings);
+  data.date_created = base::Time();
+  data.last_modified = base::Time();
+
+  manager.SetUserSelectedDefaultSearchEngine(data);
+  TemplateURLData read_data;
+  manager.GetDefaultSearchEngine(&read_data);
+  ExpectSimilar(&data, &read_data);
+}
+
+// Test that there is no default value set in the pref.
+TEST_F(DefaultSearchManagerTest, ReadDefaultPref) {
+  DefaultSearchManager manager(pref_service());
+  TemplateURLData read_data;
+  EXPECT_FALSE(manager.GetDefaultSearchEngine(&read_data));
+}

chrome/browser/search_engines/template_url_service.cc

@@ -289,7 +289,8 @@ TemplateURLService::TemplateURLService(Profile* profile)
       models_associated_(false),
       processing_syncer_changes_(false),
       pending_synced_default_search_(false),
-      dsp_change_origin_(DSP_CHANGE_OTHER) {
+      dsp_change_origin_(DSP_CHANGE_OTHER),
+      default_search_manager_(new DefaultSearchManager(GetPrefs())) {
   DCHECK(profile_);
   Init(NULL, 0);
 }
@@ -678,6 +679,12 @@ bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
 void TemplateURLService::SetUserSelectedDefaultSearchProvider(
     TemplateURL* url) {
   SetDefaultSearchProvider(url);
+  if (default_search_manager_) {
+    if (url)
+      default_search_manager_->SetUserSelectedDefaultSearchEngine(url->data());
+    else
+      default_search_manager_->ClearUserSelectedDefaultSearchEngine();
+  }
 }
 
 TemplateURL* TemplateURLService::GetDefaultSearchProvider() {

chrome/browser/search_engines/template_url_service.h

@@ -16,6 +16,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
+#include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/template_url_id.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "components/keyed_service/core/keyed_service.h"
@@ -776,6 +777,10 @@ class TemplateURLService : public WebDataServiceConsumer,
   // Stores a list of callbacks to be run after TemplateURLService has loaded.
   base::CallbackList<void(void)> on_loaded_callbacks_;
 
+  // Helper class to manage the default search engine. This will be NULL when
+  // using the testing-specific constructor.
+  scoped_ptr<DefaultSearchManager> default_search_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 

chrome/browser/search_engines/template_url_service_factory.cc

@@ -10,6 +10,7 @@
 #include "chrome/browser/google/google_url_tracker_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
+#include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/pref_names.h"
@@ -51,6 +52,7 @@ KeyedService* TemplateURLServiceFactory::BuildServiceInstanceFor(
 
 void TemplateURLServiceFactory::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
+  DefaultSearchManager::RegisterProfilePrefs(registry);
   registry->RegisterStringPref(prefs::kSyncedDefaultSearchProviderGUID,
                                std::string(),
                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);

chrome/chrome_browser.gypi

@@ -1957,6 +1957,8 @@
         'browser/search/suggestions/suggestions_service_factory.h',
         'browser/search/suggestions/suggestions_source.cc',
         'browser/search/suggestions/suggestions_source.h',
+        'browser/search_engines/default_search_manager.cc',
+        'browser/search_engines/default_search_manager.h',
         'browser/search_engines/default_search_policy_handler.cc',
         'browser/search_engines/default_search_policy_handler.h',
         'browser/search_engines/search_engine_type.h',

chrome/chrome_tests_unit.gypi

@@ -1244,6 +1244,7 @@
         'browser/search/most_visited_iframe_source_unittest.cc',
         'browser/search/search_unittest.cc',
         'browser/search/suggestions/suggestions_service_unittest.cc',
+        'browser/search_engines/default_search_manager_unittest.cc',
         'browser/search_engines/default_search_policy_handler_unittest.cc',
         'browser/search_engines/search_host_to_urls_map_unittest.cc',
         'browser/search_engines/search_provider_install_data_unittest.cc',