Make extensions DSE persistent in browser prefs

components/search_engines/util.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/util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 
 base::string16 GetDefaultSearchEngineName(TemplateURLService* service) {
   DCHECK(service);
   const TemplateURL* const default_provider =
       service->GetDefaultSearchProvider();
@@ skipping 341 matching lines @@
 }
 
 TemplateURLService::OwnedTemplateURLVector::iterator FindTemplateURL(
     TemplateURLService::OwnedTemplateURLVector* urls,
     const TemplateURL* url) {
   return std::find_if(urls->begin(), urls->end(),
                       [url](const std::unique_ptr<TemplateURL>& ptr) {
                         return ptr.get() == url;
                       });
 }
+
+std::unique_ptr<TemplateURLData> TemplateUrlDataFromDictionary(
+    const base::DictionaryValue& dict) {
+  std::unique_ptr<TemplateURLData> result(base::MakeUnique<TemplateURLData>());
+
+  std::string search_url;
+  base::string16 keyword;
+  dict.GetString(DefaultSearchManager::kURL, &search_url);
+  dict.GetString(DefaultSearchManager::kKeyword, &keyword);
+
+  result->SetKeyword(keyword);
+  result->SetURL(search_url);
+
+  std::string id;
+  dict.GetString(DefaultSearchManager::kID, &id);
+  base::StringToInt64(id, &result->id);
+  base::string16 short_name;
+  dict.GetString(DefaultSearchManager::kShortName, &short_name);
+  result->SetShortName(short_name);
+  dict.GetInteger(DefaultSearchManager::kPrepopulateID,
+                  &result->prepopulate_id);
+  dict.GetString(DefaultSearchManager::kSyncGUID,
+                 &result->sync_guid);
+  dict.GetString(DefaultSearchManager::kSuggestionsURL,
+                 &result->suggestions_url);
+  dict.GetString(DefaultSearchManager::kInstantURL,
+                 &result->instant_url);
+  dict.GetString(DefaultSearchManager::kImageURL, &result->image_url);
+  dict.GetString(DefaultSearchManager::kNewTabURL, &result->new_tab_url);
+
+  std::string favicon_url;
+  std::string originating_url;
+  dict.GetString(DefaultSearchManager::kFaviconURL, &favicon_url);
+  dict.GetString(DefaultSearchManager::kOriginatingURL, &originating_url);
+  result->favicon_url = GURL(favicon_url);
+  result->originating_url = GURL(originating_url);
+
+  dict.GetString(DefaultSearchManager::kSearchURLPostParams,
+                 &result->search_url_post_params);
+  dict.GetString(DefaultSearchManager::kSuggestionsURLPostParams,
+      &result->suggestions_url_post_params);
+  dict.GetString(DefaultSearchManager::kInstantURLPostParams,
+                 &result->instant_url_post_params);
+  dict.GetString(DefaultSearchManager::kImageURLPostParams,
+                 &result->image_url_post_params);
+  dict.GetBoolean(DefaultSearchManager::kSafeForAutoReplace,
+                  &result->safe_for_autoreplace);
+
+  std::string date_created_str;
+  std::string last_modified_str;
+  dict.GetString(DefaultSearchManager::kDateCreated, &date_created_str);
+  dict.GetString(DefaultSearchManager::kLastModified, &last_modified_str);
+
+  int64_t date_created = 0;
+  if (base::StringToInt64(date_created_str, &date_created)) {
+    result->date_created = base::Time::FromInternalValue(date_created);
+  }
+
+  int64_t last_modified = 0;
+  if (base::StringToInt64(date_created_str, &last_modified)) {
+    result->last_modified = base::Time::FromInternalValue(last_modified);
+  }
+
+  dict.GetInteger(DefaultSearchManager::kUsageCount, &result->usage_count);
+
+  const base::ListValue* alternate_urls = NULL;
+  if (dict.GetList(DefaultSearchManager::kAlternateURLs, &alternate_urls)) {
+    for (const auto& it : *alternate_urls) {
+      std::string alternate_url;
+      if (it->GetAsString(&alternate_url))
+        result->alternate_urls.push_back(alternate_url);
+    }
+  }
+
+  const base::ListValue* encodings = NULL;
+  if (dict.GetList(DefaultSearchManager::kInputEncodings, &encodings)) {
+    for (const auto& it : *encodings) {
+      std::string encoding;
+      if (it->GetAsString(&encoding))
+        result->input_encodings.push_back(encoding);
+    }
+  }
+
+  dict.GetString(DefaultSearchManager::kSearchTermsReplacementKey,
+                 &result->search_terms_replacement_key);
+  dict.GetBoolean(DefaultSearchManager::kCreatedByPolicy,
+                  &result->created_by_policy);
+
+  result->show_in_default_list = true;
+  return result;
+}
+
+std::unique_ptr<base::DictionaryValue> TemplateUrlDataToDictionary(
+    const TemplateURLData& data) {
+  std::unique_ptr<base::DictionaryValue> url_dict(
+      base::MakeUnique<base::DictionaryValue>());
+
+  url_dict->SetString(DefaultSearchManager::kID, base::Int64ToString(data.id));
+  url_dict->SetString(DefaultSearchManager::kShortName, data.short_name());
+  url_dict->SetString(DefaultSearchManager::kKeyword, data.keyword());
+  url_dict->SetInteger(DefaultSearchManager::kPrepopulateID,
+                       data.prepopulate_id);
+  url_dict->SetString(DefaultSearchManager::kSyncGUID, data.sync_guid);
+
+  url_dict->SetString(DefaultSearchManager::kURL, data.url());
+  url_dict->SetString(DefaultSearchManager::kSuggestionsURL,
+                      data.suggestions_url);
+  url_dict->SetString(DefaultSearchManager::kInstantURL, data.instant_url);
+  url_dict->SetString(DefaultSearchManager::kImageURL, data.image_url);
+  url_dict->SetString(DefaultSearchManager::kNewTabURL, data.new_tab_url);
+  url_dict->SetString(DefaultSearchManager::kFaviconURL,
+                      data.favicon_url.spec());
+  url_dict->SetString(DefaultSearchManager::kOriginatingURL,
+                      data.originating_url.spec());
+
+  url_dict->SetString(DefaultSearchManager::kSearchURLPostParams,
+                      data.search_url_post_params);
+  url_dict->SetString(DefaultSearchManager::kSuggestionsURLPostParams,
+                     data.suggestions_url_post_params);
+  url_dict->SetString(DefaultSearchManager::kInstantURLPostParams,
+                      data.instant_url_post_params);
+  url_dict->SetString(DefaultSearchManager::kImageURLPostParams,
+                      data.image_url_post_params);
+
+  url_dict->SetBoolean(DefaultSearchManager::kSafeForAutoReplace,
+                       data.safe_for_autoreplace);
+
+  url_dict->SetString(DefaultSearchManager::kDateCreated,
+                     base::Int64ToString(data.date_created.ToInternalValue()));
+  url_dict->SetString(DefaultSearchManager::kLastModified,
+                     base::Int64ToString(data.last_modified.ToInternalValue()));
+  url_dict->SetInteger(DefaultSearchManager::kUsageCount, data.usage_count);
+
+  std::unique_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(DefaultSearchManager::kAlternateURLs, alternate_urls.release());
+
+  std::unique_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(DefaultSearchManager::kInputEncodings, encodings.release());
+
+  url_dict->SetString(DefaultSearchManager::kSearchTermsReplacementKey,
+                     data.search_terms_replacement_key);
+
+  url_dict->SetBoolean(DefaultSearchManager::kCreatedByPolicy,
+                       data.created_by_policy);
+  return url_dict;
+}