Store default search provider data in dictionary pref.

chrome/browser/search_engines/template_url_service.cc

 // Copyright (c) 2012 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/template_url_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 39 matching lines @@
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "ui/base/l10n/l10n_util.h"
 
 typedef SearchHostToURLsMap::TemplateURLSet TemplateURLSet;
 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)
     return true;
   return (url1 != NULL) && (url2 != NULL) &&
       (url1->short_name() == url2->short_name()) &&
       url1->HasSameKeywordAs(*url2) &&
       (url1->url() == url2->url()) &&
       (url1->suggestions_url() == url2->suggestions_url()) &&
       (url1->instant_url() == url2->instant_url()) &&
@@ skipping 2675 matching lines @@
           new_dse = *i;
           break;
         }
       }
     }
   }
   if (!new_dse)
     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);
+}