Revert of Componentize TemplateURLService

chrome/browser/search_engines/util.cc

Index: chrome/browser/search_engines/util.cc
diff --git a/chrome/browser/search_engines/util.cc b/chrome/browser/search_engines/util.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7cb976cbdc683730ac935e667c244b1da8c94b1c
--- /dev/null
+++ b/chrome/browser/search_engines/util.cc
@@ -0,0 +1,389 @@
+// 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/util.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/memory/scoped_vector.h"
+#include "base/prefs/pref_service.h"
+#include "base/time/time.h"
+#include "chrome/browser/search_engines/template_url_service.h"
+#include "components/search_engines/template_url.h"
+#include "components/search_engines/template_url_prepopulate_data.h"
+
+base::string16 GetDefaultSearchEngineName(TemplateURLService* service) {
+  DCHECK(service);
+  const TemplateURL* const default_provider =
+      service->GetDefaultSearchProvider();
+  if (!default_provider) {
+    // TODO(cpu): bug 1187517. It is possible to have no default provider.
+    // returning an empty string is a stopgap measure for the crash
+    // http://code.google.com/p/chromium/issues/detail?id=2573
+    return base::string16();
+  }
+  return default_provider->short_name();
+}
+
+GURL GetDefaultSearchURLForSearchTerms(TemplateURLService* service,
+                                       const base::string16& terms) {
+  DCHECK(service);
+  const TemplateURL* default_provider = service->GetDefaultSearchProvider();
+  if (!default_provider)
+    return GURL();
+  const TemplateURLRef& search_url = default_provider->url_ref();
+  DCHECK(search_url.SupportsReplacement(service->search_terms_data()));
+  TemplateURLRef::SearchTermsArgs search_terms_args(terms);
+  search_terms_args.append_extra_query_params = true;
+  return GURL(search_url.ReplaceSearchTerms(search_terms_args,
+                                            service->search_terms_data()));
+}
+
+void RemoveDuplicatePrepopulateIDs(
+    KeywordWebDataService* service,
+    const ScopedVector<TemplateURLData>& prepopulated_urls,
+    TemplateURL* default_search_provider,
+    TemplateURLService::TemplateURLVector* template_urls,
+    const SearchTermsData& search_terms_data,
+    std::set<std::string>* removed_keyword_guids) {
+  DCHECK(template_urls);
+
+  // For convenience construct an ID->TemplateURL* map from |prepopulated_urls|.
+  typedef std::map<int, TemplateURLData*> PrepopulatedURLMap;
+  PrepopulatedURLMap prepopulated_url_map;
+  for (std::vector<TemplateURLData*>::const_iterator i(
+           prepopulated_urls.begin());
+       i != prepopulated_urls.end();
+       ++i)
+    prepopulated_url_map[(*i)->prepopulate_id] = *i;
+
+  // Separate |template_urls| into prepopulated and non-prepopulated groups.
+  typedef std::multimap<int, TemplateURL*> UncheckedURLMap;
+  UncheckedURLMap unchecked_urls;
+  TemplateURLService::TemplateURLVector checked_urls;
+  for (TemplateURLService::TemplateURLVector::iterator i(
+       template_urls->begin()); i != template_urls->end(); ++i) {
+    TemplateURL* turl = *i;
+    int prepopulate_id = turl->prepopulate_id();
+    if (prepopulate_id)
+      unchecked_urls.insert(std::make_pair(prepopulate_id, turl));
+    else
+      checked_urls.push_back(turl);
+  }
+
+  // For each group of prepopulated URLs with one ID, find the best URL to use
+  // and add it to the (initially all non-prepopulated) URLs we've already OKed.
+  // Delete the others from the service and from memory.
+  while (!unchecked_urls.empty()) {
+    // Find the best URL.
+    int prepopulate_id = unchecked_urls.begin()->first;
+    PrepopulatedURLMap::const_iterator prepopulated_url =
+        prepopulated_url_map.find(prepopulate_id);
+    UncheckedURLMap::iterator end = unchecked_urls.upper_bound(prepopulate_id);
+    UncheckedURLMap::iterator best = unchecked_urls.begin();
+    bool matched_keyword = false;
+    for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) {
+      // If the user-selected DSE is a prepopulated engine its properties will
+      // either come from the prepopulation origin or from the user preferences
+      // file (see DefaultSearchManager). Those properties will end up
+      // overwriting whatever we load now anyway. If we are eliminating
+      // duplicates, then, we err on the side of keeping the thing that looks
+      // more like the value we will end up with in the end.
+      if (default_search_provider &&
+          (default_search_provider->prepopulate_id() ==
+              i->second->prepopulate_id()) &&
+          default_search_provider->HasSameKeywordAs(i->second->data(),
+                                                    search_terms_data)) {
+        best = i;
+        break;
+      }
+
+      // Otherwise, a URL is best if it matches the prepopulated data's keyword;
+      // if none match, just fall back to using the one with the lowest ID.
+      if (matched_keyword)
+        continue;
+      if ((prepopulated_url != prepopulated_url_map.end()) &&
+          i->second->HasSameKeywordAs(*prepopulated_url->second,
+                                      search_terms_data)) {
+        best = i;
+        matched_keyword = true;
+      } else if (i->second->id() < best->second->id()) {
+        best = i;
+      }
+    }
+
+    // Add the best URL to the checked group and delete the rest.
+    checked_urls.push_back(best->second);
+    for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) {
+      if (i == best)
+        continue;
+      if (service) {
+        service->RemoveKeyword(i->second->id());
+        if (removed_keyword_guids)
+          removed_keyword_guids->insert(i->second->sync_guid());
+      }
+      delete i->second;
+    }
+
+    // Done with this group.
+    unchecked_urls.erase(unchecked_urls.begin(), end);
+  }
+
+  // Return the checked URLs.
+  template_urls->swap(checked_urls);
+}
+
+// Returns the TemplateURL with id specified from the list of TemplateURLs.
+// If not found, returns NULL.
+TemplateURL* GetTemplateURLByID(
+    const TemplateURLService::TemplateURLVector& template_urls,
+    int64 id) {
+  for (TemplateURLService::TemplateURLVector::const_iterator i(
+       template_urls.begin()); i != template_urls.end(); ++i) {
+    if ((*i)->id() == id) {
+      return *i;
+    }
+  }
+  return NULL;
+}
+
+TemplateURL* FindURLByPrepopulateID(
+    const TemplateURLService::TemplateURLVector& template_urls,
+    int prepopulate_id) {
+  for (std::vector<TemplateURL*>::const_iterator i = template_urls.begin();
+       i < template_urls.end(); ++i) {
+    if ((*i)->prepopulate_id() == prepopulate_id)
+      return *i;
+  }
+  return NULL;
+}
+
+void MergeIntoPrepopulatedEngineData(const TemplateURL* original_turl,
+                                     TemplateURLData* prepopulated_url) {
+  DCHECK_EQ(original_turl->prepopulate_id(), prepopulated_url->prepopulate_id);
+  if (!original_turl->safe_for_autoreplace()) {
+    prepopulated_url->safe_for_autoreplace = false;
+    prepopulated_url->SetKeyword(original_turl->keyword());
+    prepopulated_url->short_name = original_turl->short_name();
+  }
+  prepopulated_url->id = original_turl->id();
+  prepopulated_url->sync_guid = original_turl->sync_guid();
+  prepopulated_url->date_created = original_turl->date_created();
+  prepopulated_url->last_modified = original_turl->last_modified();
+}
+
+ActionsFromPrepopulateData::ActionsFromPrepopulateData() {}
+
+ActionsFromPrepopulateData::~ActionsFromPrepopulateData() {}
+
+// This is invoked when the version of the prepopulate data changes.
+// If |removed_keyword_guids| is not NULL, the Sync GUID of each item removed
+// from the DB will be added to it.  Note that this function will take
+// ownership of |prepopulated_urls| and will clear the vector.
+void MergeEnginesFromPrepopulateData(
+    KeywordWebDataService* service,
+    ScopedVector<TemplateURLData>* prepopulated_urls,
+    size_t default_search_index,
+    TemplateURLService::TemplateURLVector* template_urls,
+    TemplateURL* default_search_provider,
+    std::set<std::string>* removed_keyword_guids) {
+  DCHECK(prepopulated_urls);
+  DCHECK(template_urls);
+
+  ActionsFromPrepopulateData actions(CreateActionsFromCurrentPrepopulateData(
+      prepopulated_urls, *template_urls, default_search_provider));
+
+  // Remove items.
+  for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
+       i < actions.removed_engines.end(); ++i) {
+    scoped_ptr<TemplateURL> template_url(*i);
+    TemplateURLService::TemplateURLVector::iterator j =
+        std::find(template_urls->begin(), template_urls->end(), template_url);
+    DCHECK(j != template_urls->end());
+    DCHECK(!default_search_provider ||
+           (*j)->prepopulate_id() != default_search_provider->prepopulate_id());
+    template_urls->erase(j);
+    if (service) {
+      service->RemoveKeyword(template_url->id());
+      if (removed_keyword_guids)
+        removed_keyword_guids->insert(template_url->sync_guid());
+    }
+  }
+
+  // Edit items.
+  for (EditedEngines::iterator i(actions.edited_engines.begin());
+       i < actions.edited_engines.end(); ++i) {
+    TemplateURLData& data = i->second;
+    scoped_ptr<TemplateURL> existing_url(i->first);
+    if (service)
+      service->UpdateKeyword(data);
+
+    // Replace the entry in |template_urls| with the updated one.
+    TemplateURLService::TemplateURLVector::iterator j = std::find(
+        template_urls->begin(), template_urls->end(), existing_url.get());
+    *j = new TemplateURL(data);
+  }
+
+  // Add items.
+  for (std::vector<TemplateURLData>::const_iterator it =
+           actions.added_engines.begin();
+       it != actions.added_engines.end();
+       ++it) {
+    template_urls->push_back(new TemplateURL(*it));
+  }
+}
+
+ActionsFromPrepopulateData CreateActionsFromCurrentPrepopulateData(
+    ScopedVector<TemplateURLData>* prepopulated_urls,
+    const TemplateURLService::TemplateURLVector& existing_urls,
+    const TemplateURL* default_search_provider) {
+  // Create a map to hold all provided |template_urls| that originally came from
+  // prepopulate data (i.e. have a non-zero prepopulate_id()).
+  typedef std::map<int, TemplateURL*> IDMap;
+  IDMap id_to_turl;
+  for (TemplateURLService::TemplateURLVector::const_iterator i(
+       existing_urls.begin()); i != existing_urls.end(); ++i) {
+    int prepopulate_id = (*i)->prepopulate_id();
+    if (prepopulate_id > 0)
+      id_to_turl[prepopulate_id] = *i;
+  }
+
+  // For each current prepopulated URL, check whether |template_urls| contained
+  // a matching prepopulated URL.  If so, update the passed-in URL to match the
+  // current data.  (If the passed-in URL was user-edited, we persist the user's
+  // name and keyword.)  If not, add the prepopulated URL.
+  ActionsFromPrepopulateData actions;
+  for (size_t i = 0; i < prepopulated_urls->size(); ++i) {
+    // We take ownership of |prepopulated_urls[i]|.
+    scoped_ptr<TemplateURLData> prepopulated_url((*prepopulated_urls)[i]);
+    const int prepopulated_id = prepopulated_url->prepopulate_id;
+    DCHECK_NE(0, prepopulated_id);
+
+    IDMap::iterator existing_url_iter(id_to_turl.find(prepopulated_id));
+    if (existing_url_iter != id_to_turl.end()) {
+      // Update the data store with the new prepopulated data. Preserve user
+      // edits to the name and keyword.
+      TemplateURL* existing_url(existing_url_iter->second);
+      id_to_turl.erase(existing_url_iter);
+      MergeIntoPrepopulatedEngineData(existing_url, prepopulated_url.get());
+      // Update last_modified to ensure that if this entry is later merged with
+      // entries from Sync, the conflict resolution logic knows that this was
+      // updated and propagates the new values to the server.
+      prepopulated_url->last_modified = base::Time::Now();
+      actions.edited_engines.push_back(
+          std::make_pair(existing_url, *prepopulated_url));
+    } else {
+      actions.added_engines.push_back(*prepopulated_url);
+    }
+  }
+  // The above loop takes ownership of all the contents of prepopulated_urls.
+  // Clear the pointers.
+  prepopulated_urls->weak_erase(prepopulated_urls->begin(),
+                                prepopulated_urls->end());
+
+  // The block above removed all the URLs from the |id_to_turl| map that were
+  // found in the prepopulate data.  Any remaining URLs that haven't been
+  // user-edited or made default can be removed from the data store.
+  // We assume that this entry is equivalent to the DSE if its prepopulate ID
+  // and keyword both match. If the prepopulate ID _does_ match all properties
+  // will be replaced with those from |default_search_provider| anyway.
+  for (IDMap::iterator i(id_to_turl.begin()); i != id_to_turl.end(); ++i) {
+    TemplateURL* template_url = i->second;
+    if ((template_url->safe_for_autoreplace()) &&
+        (!default_search_provider ||
+         (template_url->prepopulate_id() !=
+             default_search_provider->prepopulate_id()) ||
+         (template_url->keyword() != default_search_provider->keyword())))
+      actions.removed_engines.push_back(template_url);
+  }
+
+  return actions;
+}
+
+void GetSearchProvidersUsingKeywordResult(
+    const WDTypedResult& result,
+    KeywordWebDataService* service,
+    PrefService* prefs,
+    TemplateURLService::TemplateURLVector* template_urls,
+    TemplateURL* default_search_provider,
+    const SearchTermsData& search_terms_data,
+    int* new_resource_keyword_version,
+    std::set<std::string>* removed_keyword_guids) {
+  DCHECK(template_urls);
+  DCHECK(template_urls->empty());
+  DCHECK_EQ(KEYWORDS_RESULT, result.GetType());
+  DCHECK(new_resource_keyword_version);
+
+  WDKeywordsResult keyword_result = reinterpret_cast<
+      const WDResult<WDKeywordsResult>*>(&result)->GetValue();
+
+  for (KeywordTable::Keywords::iterator i(keyword_result.keywords.begin());
+       i != keyword_result.keywords.end(); ++i) {
+    // Fix any duplicate encodings in the local database.  Note that we don't
+    // adjust the last_modified time of this keyword; this way, we won't later
+    // overwrite any changes on the sync server that happened to this keyword
+    // since the last time we synced.  Instead, we also run a de-duping pass on
+    // the server-provided data in
+    // TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData() and
+    // update the server with the merged, de-duped results at that time.  We
+    // still fix here, though, to correct problems in clients that have disabled
+    // search engine sync, since in that case that code will never be reached.
+    if (DeDupeEncodings(&i->input_encodings) && service)
+      service->UpdateKeyword(*i);
+    template_urls->push_back(new TemplateURL(*i));
+  }
+
+  *new_resource_keyword_version = keyword_result.builtin_keyword_version;
+  GetSearchProvidersUsingLoadedEngines(service, prefs, template_urls,
+                                       default_search_provider,
+                                       search_terms_data,
+                                       new_resource_keyword_version,
+                                       removed_keyword_guids);
+}
+
+void GetSearchProvidersUsingLoadedEngines(
+    KeywordWebDataService* service,
+    PrefService* prefs,
+    TemplateURLService::TemplateURLVector* template_urls,
+    TemplateURL* default_search_provider,
+    const SearchTermsData& search_terms_data,
+    int* resource_keyword_version,
+    std::set<std::string>* removed_keyword_guids) {
+  DCHECK(template_urls);
+  DCHECK(resource_keyword_version);
+  size_t default_search_index;
+  ScopedVector<TemplateURLData> prepopulated_urls =
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs,
+                                                         &default_search_index);
+  RemoveDuplicatePrepopulateIDs(service, prepopulated_urls,
+                                default_search_provider, template_urls,
+                                search_terms_data, removed_keyword_guids);
+
+  const int prepopulate_resource_keyword_version =
+      TemplateURLPrepopulateData::GetDataVersion(prefs);
+  if (*resource_keyword_version < prepopulate_resource_keyword_version) {
+    MergeEnginesFromPrepopulateData(
+        service, &prepopulated_urls, default_search_index, template_urls,
+        default_search_provider, removed_keyword_guids);
+    *resource_keyword_version = prepopulate_resource_keyword_version;
+  } else {
+    *resource_keyword_version = 0;
+  }
+}
+
+bool DeDupeEncodings(std::vector<std::string>* encodings) {
+  std::vector<std::string> deduped_encodings;
+  std::set<std::string> encoding_set;
+  for (std::vector<std::string>::const_iterator i(encodings->begin());
+       i != encodings->end(); ++i) {
+    if (encoding_set.insert(*i).second)
+      deduped_encodings.push_back(*i);
+  }
+  encodings->swap(deduped_encodings);
+  return encodings->size() != deduped_encodings.size();
+}