Store default search provider data in dictionary pref.

chrome/browser/search_engines/template_url_service.cc

Index: chrome/browser/search_engines/template_url_service.cc
diff --git a/chrome/browser/search_engines/template_url_service.cc b/chrome/browser/search_engines/template_url_service.cc
index 1fa3c2a79824b900baea8869d9dd6f379504ac43..812dbeb8a490e7eb1fe4b3c7d673fd440611a8d7 100644
--- a/chrome/browser/search_engines/template_url_service.cc
+++ b/chrome/browser/search_engines/template_url_service.cc
@@ -57,6 +57,36 @@ typedef TemplateURLService::SyncDataMap SyncDataMap;
 
 namespace {
 
+// Keys for kDefaultSearchProviderData Pref.
+const char kID[] = "id";
+const char kShortName[] = "short_name";
+const char kKeyword[] = "keyword";
+const char kPrepopulateID[] = "prepopulate_id";
+const char kSyncGUID[] = "sync_guid";

[gab, 2014/04/11 20:27:46]

Shouldn't this be "synced_guid"?

[Cait (Slow), 2014/04/14 15:20:35]

Done.

[Cait (Slow), 2014/04/14 15:28:01]

Actually, looking closer at this, TemplateURLData calls this field sync_guid and
I think for the time being it makes sense to keep our dictionary keys as close
to TemplateURLData's member variable names as possible, for consistency reasons
-- how about a TODO to update all of them at a later date?

On 2014/04/14 15:20:35, Cait Phillips wrote:

[gab, 2014/04/14 15:30:16]

Ah ok, then let's keep it as "sync_guid".

No need for a TODO; synced_guid will be a legacy pref in M36 and removed a few
milestones later.

+
+const char kURL[] = "url";
+const char kSuggestionsURL[] = "suggestions_url";
+const char kInstantURL[] = "instant_url";
+const char kImageURL[] = "image_url";
+const char kNewTabURL[] = "new_tab_url";
+const char kFaviconURL[] = "favicon_url";
+const char kOriginatingURL[] = "originating_url";
+
+const char kSearchURLPostParams[] = "search_url_post_params";
+const char kSuggestionsURLPostParams[] = "suggestions_url_post_params";
+const char kInstantURLPostParams[] = "instant_url_post_params";
+const char kImageURLPostParams[] = "image_url_post_params";
+
+const char kSafeForAutoReplace[] = "safe_for_autoreplace";
+const char kInputEncodings[] = "input_encodings";
+
+const char kDateCreated[] = "date_created";
+const char kLastModified[] = "last_modified";
+
+const char kUsageCount[] = "usage_count";
+const char kAlternateURLs[] = "alternate_urls";
+const char kSearchTermsReplacementKey[] = "search_terms_replacement_key";
+
 bool TemplateURLsHaveSamePrefs(const TemplateURL* url1,
                                const TemplateURL* url2) {
   if (url1 == url2)
@@ -2752,3 +2782,130 @@ void TemplateURLService::
     new_dse = FindNewDefaultSearchProvider();
   SetDefaultSearchProviderNoNotify(new_dse);
 }
+
+bool TemplateURLService::ReadDataFromPrefsDictionary(TemplateURL* url) {
+  PrefService* prefs = GetPrefs();
+  if (!prefs || !prefs->HasPrefPath(prefs::kDefaultSearchProviderData))

[gab, 2014/04/11 20:27:46]

I don't think we want to check HasPrefPath() here.

It will return false if there is only a default value available.

Instead we want to let GetDictionary() below handle getting the default value if
there is no user value (or whatever else there may be in the hierarchy of stores
being checked).

[Cait (Slow), 2014/04/14 15:20:35]

Done.

+    return false;
+
+  const base::DictionaryValue* url_dict =
+      prefs->GetDictionary(prefs::kDefaultSearchProviderData);
+  if (!url_dict)
+    return false;
+
+  TemplateURLData data;
+  std::string search_url;
+  base::string16 keyword;
+
+  url_dict->GetString(kKeyword, &keyword);
+  url_dict->GetString(kURL, &search_url);
+
+  DCHECK(!keyword.empty());
+  DCHECK(!search_url.empty());
+
+  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);
+
+  std::string encodings;
+  url_dict->GetString(kInputEncodings, &encodings);
+  base::SplitString(encodings, ';', &data.input_encodings);
+
+  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 = new base::ListValue;
+  url_dict->GetList(prefs::kDefaultSearchProviderAlternateURLs,
+      &alternate_urls);
+  data.alternate_urls.clear();
+  for (size_t i = 0; i < alternate_urls->GetSize(); ++i) {
+    std::string alternate_url;
+    if (alternate_urls->GetString(i, &alternate_url))
+      data.alternate_urls.push_back(alternate_url);
+  }
+
+  url_dict->GetString(kSearchTermsReplacementKey,
+      &data.search_terms_replacement_key);
+
+  data.show_in_default_list = true;
+
+  url = new TemplateURL(profile_, data);
+
+  return true;
+}
+
+void TemplateURLService::WriteDataToPrefsDictionary(const TemplateURL* url) {
+  PrefService* prefs = GetPrefs();
+  if (!prefs)
+    return;
+
+  base::DictionaryValue* url_dict = new base::DictionaryValue;
+  url_dict->SetString(kID, base::Int64ToString(url->id()));
+  url_dict->SetString(kShortName, url->short_name());
+  url_dict->SetString(kKeyword, url->keyword());
+  url_dict->SetInteger(kPrepopulateID, url->prepopulate_id());
+  url_dict->SetString(kSyncGUID, url->sync_guid());
+
+  url_dict->SetString(kURL, url->url());
+  url_dict->SetString(kSuggestionsURL, url->suggestions_url());
+  url_dict->SetString(kInstantURL, url->instant_url());
+  url_dict->SetString(kImageURL, url->image_url());
+  url_dict->SetString(kNewTabURL, url->new_tab_url());
+  url_dict->SetString(kFaviconURL, url->favicon_url().spec());
+  url_dict->SetString(kOriginatingURL, url->originating_url().spec());
+
+  url_dict->SetString(kSearchURLPostParams, url->search_url_post_params());
+  url_dict->SetString(kSuggestionsURLPostParams,
+      url->suggestions_url_post_params());
+  url_dict->SetString(kInstantURLPostParams,
+      url->instant_url_post_params());
+  url_dict->SetString(kImageURLPostParams, url->image_url_post_params());
+
+  url_dict->SetBoolean(kSafeForAutoReplace, url->safe_for_autoreplace());
+  url_dict->SetString(kInputEncodings, JoinString(url->input_encodings(), ';'));
+
+  url_dict->SetDouble(kDateCreated, url->date_created().ToInternalValue());
+  url_dict->SetDouble(kLastModified, url->last_modified().ToInternalValue());
+  url_dict->SetInteger(kUsageCount, url->usage_count());
+
+  base::ListValue alternate_urls;
+  for (size_t i = 0; i < url->alternate_urls().size(); ++i)
+      alternate_urls.AppendString(url->alternate_urls()[i]);
+  url_dict->Set(kAlternateURLs, &alternate_urls);
+
+  url_dict->SetString(kSearchTermsReplacementKey,
+      url->search_terms_replacement_key());
+  prefs->Set(prefs::kDefaultSearchProviderData, *url_dict);
+}