Enable Chrome to tweak search engines for some locales

components/search_engines/template_url_service.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/template_url_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 171 matching lines @@
   // The meaningful keyword length is the length of any portion before the
   // registry ("co.uk") and its preceding dot.
   return keyword.length() - (registry_length ? (registry_length + 1) : 0);
 }
 
 bool Contains(TemplateURLService::OwnedTemplateURLVector* template_urls,
               TemplateURL* turl) {
   return FindTemplateURL(template_urls, turl) != template_urls->end();
 }
 
+bool IsCreatedByExtension(TemplateURL* template_url) {
+  return template_url->type() ==
+             TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION ||
+         template_url->type() == TemplateURL::OMNIBOX_API_EXTENSION;
+}
+
 }  // namespace
 
 // TemplateURLService::LessWithPrefix -----------------------------------------
 
 class TemplateURLService::LessWithPrefix {
  public:
   // We want to find the set of keywords that begin with a prefix.  The STL
   // algorithms will return the set of elements that are "equal to" the
   // prefix, where "equal(x, y)" means "!(cmp(x, y) || cmp(y, x))".  When
   // cmp() is the typical std::less<>, this results in lexicographic equality;
@@ skipping 262 matching lines @@
   return Add(std::move(template_url));
 }
 
 TemplateURL* TemplateURLService::AddExtensionControlledTURL(
     std::unique_ptr<TemplateURL> template_url,
     std::unique_ptr<TemplateURL::AssociatedExtensionInfo> info) {
   DCHECK(loaded_);
   DCHECK(template_url);
   DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
   DCHECK(info);
-  DCHECK_NE(TemplateURL::NORMAL, info->type);
+  DCHECK_NE(TemplateURL::NORMAL, template_url->type());
   DCHECK_EQ(info->wants_to_be_default_engine,
             template_url->show_in_default_list());
-  DCHECK(!FindTemplateURLForExtension(info->extension_id, info->type));
+  DCHECK(
+      !FindTemplateURLForExtension(info->extension_id, template_url->type()));
   template_url->extension_info_.swap(info);
 
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   TemplateURL* template_url_ptr = AddNoNotify(std::move(template_url), true);
   if (template_url_ptr) {
     if (template_url_ptr->extension_info_->wants_to_be_default_engine) {
       UpdateExtensionDefaultSearchEngine();
     }
     NotifyObservers();
   }
@@ skipping 66 matching lines @@
 
   if (FindTemplateURLForExtension(extension_id,
                                   TemplateURL::OMNIBOX_API_EXTENSION))
     return;
 
   TemplateURLData data;
   data.SetShortName(base::UTF8ToUTF16(extension_name));
   data.SetKeyword(base::UTF8ToUTF16(keyword));
   data.SetURL(template_url_string);
   std::unique_ptr<TemplateURL::AssociatedExtensionInfo> info(
-      new TemplateURL::AssociatedExtensionInfo(
-          TemplateURL::OMNIBOX_API_EXTENSION, extension_id));
-  AddExtensionControlledTURL(base::MakeUnique<TemplateURL>(data),
-                             std::move(info));
+      new TemplateURL::AssociatedExtensionInfo(extension_id));
+  AddExtensionControlledTURL(
+      base::MakeUnique<TemplateURL>(data, TemplateURL::OMNIBOX_API_EXTENSION),
+      std::move(info));
 }
 
 TemplateURLService::TemplateURLVector TemplateURLService::GetTemplateURLs() {
   TemplateURLVector result;
   for (const auto& turl : template_urls_)
     result.push_back(turl.get());
   return result;
 }
 
 void TemplateURLService::IncrementUsageCount(TemplateURL* url) {
   DCHECK(url);
   // Extension-controlled search engines are not persisted.
-  if (url->GetType() != TemplateURL::NORMAL)
+  if (url->type() != TemplateURL::NORMAL)
     return;
   if (!Contains(&template_urls_, url))
     return;
   ++url->data_.usage_count;
 
   if (web_data_service_.get())
     web_data_service_->UpdateKeyword(url->data());
 }
 
 void TemplateURLService::ResetTemplateURL(TemplateURL* url,
                                           const base::string16& title,
                                           const base::string16& keyword,
                                           const std::string& search_url) {
   if (ResetTemplateURLNoNotify(url, title, keyword, search_url))
     NotifyObservers();
 }
 
 bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
   return
       ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
        (default_search_provider_source_ ==
         DefaultSearchManager::FROM_FALLBACK)) &&
       (url != GetDefaultSearchProvider()) &&
       url->url_ref().SupportsReplacement(search_terms_data()) &&
-      (url->GetType() == TemplateURL::NORMAL);
+      (url->type() == TemplateURL::NORMAL);
 }
 
 void TemplateURLService::SetUserSelectedDefaultSearchProvider(
     TemplateURL* url) {
   // Omnibox keywords cannot be made default. Extension-controlled search
   // engines can be made default only by the extension itself because they
   // aren't persisted.
-  DCHECK(!url || (url->GetType() == TemplateURL::NORMAL));
+  DCHECK(!url || !IsCreatedByExtension(url));
   if (load_failed_) {
     // Skip the DefaultSearchManager, which will persist to user preferences.
     if ((default_search_provider_source_ == DefaultSearchManager::FROM_USER) ||
         (default_search_provider_source_ ==
          DefaultSearchManager::FROM_FALLBACK)) {
       ApplyDefaultSearchChange(url ? &url->data() : nullptr,
                                DefaultSearchManager::FROM_USER);
     }
   } else {
     // We rely on the DefaultSearchManager to call OnDefaultSearchChange if, in
@@ skipping 236 matching lines @@
 
 base::string16 TemplateURLService::GetKeywordShortName(
     const base::string16& keyword,
     bool* is_omnibox_api_extension_keyword) {
   const TemplateURL* template_url = GetTemplateURLForKeyword(keyword);
 
   // TODO(sky): Once LocationBarView adds a listener to the TemplateURLService
   // to track changes to the model, this should become a DCHECK.
   if (template_url) {
     *is_omnibox_api_extension_keyword =
-        template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION;
+        template_url->type() == TemplateURL::OMNIBOX_API_EXTENSION;
     return template_url->AdjustedShortNameForLocaleDirection();
   }
   *is_omnibox_api_extension_keyword = false;
   return base::string16();
 }
 
 void TemplateURLService::OnHistoryURLVisited(const URLVisitedDetails& details) {
   if (!loaded_)
     visits_to_add_.push_back(details);
   else
@@ skipping 16 matching lines @@
 syncer::SyncDataList TemplateURLService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::SEARCH_ENGINES, type);
 
   syncer::SyncDataList current_data;
   for (const auto& turl : template_urls_) {
     // We don't sync keywords managed by policy.
     if (turl->created_by_policy())
       continue;
     // We don't sync extension-controlled search engines.
-    if (turl->GetType() != TemplateURL::NORMAL)
+    if (turl->type() != TemplateURL::NORMAL)
       continue;
     current_data.push_back(CreateSyncDataFromTemplateURL(*turl));
   }
 
   return current_data;
 }
 
 syncer::SyncError TemplateURLService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
@@ skipping 285 matching lines @@
     return;  // Not syncing.
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us. Ignore.
 
   // Avoid syncing keywords managed by policy.
   if (turl->created_by_policy())
     return;
 
   // Avoid syncing extension-controlled search engines.
-  if (turl->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)
+  if (turl->type() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)
     return;
 
   syncer::SyncChangeList changes;
 
   syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
   changes.push_back(syncer::SyncChange(from_here,
                                        type,
                                        sync_data));
 
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
@@ skipping 120 matching lines @@
   UpdateTemplateURLIfPrepopulated(turl.get(), prefs);
 
   // We used to sync keywords associated with omnibox extensions, but no longer
   // want to.  However, if we delete these keywords from sync, we'll break any
   // synced old versions of Chrome which were relying on them.  Instead, for now
   // we simply ignore these.
   // TODO(vasilii): After a few Chrome versions, change this to go ahead and
   // delete these from sync.
   DCHECK(client);
   client->RestoreExtensionInfoIfNecessary(turl.get());
-  if (turl->GetType() == TemplateURL::OMNIBOX_API_EXTENSION)
+  if (turl->type() == TemplateURL::OMNIBOX_API_EXTENSION)
     return nullptr;
 
-  DCHECK_EQ(TemplateURL::NORMAL, turl->GetType());
+  DCHECK_EQ(TemplateURL::NORMAL, turl->type());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(search_terms_data, true);
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
     change_list->push_back(syncer::SyncChange(FROM_HERE,
                                               syncer::SyncChange::ACTION_UPDATE,
                                               sync_data));
   } else if (turl->IsGoogleSearchURLWithReplaceableKeyword(search_terms_data)) {
     if (!existing_turl) {
       // We're adding a new TemplateURL that uses the Google base URL, so set
@@ skipping 90 matching lines @@
     // extension keywords and how they can coexist with non-extension keywords.
     // In the case of more than one extension, we use the most recently
     // installed (which will be the most recently added, which will have the
     // highest ID).
     TemplateURL* best_fallback = nullptr;
     for (const auto& turl : template_urls_) {
       // This next statement relies on the fact that there can only be one
       // non-Omnibox API TemplateURL with a given keyword.
       if ((turl.get() != template_url) && (turl->keyword() == keyword) &&
           (!best_fallback ||
-           (best_fallback->GetType() != TemplateURL::OMNIBOX_API_EXTENSION) ||
-           ((turl->GetType() == TemplateURL::OMNIBOX_API_EXTENSION) &&
+           (best_fallback->type() != TemplateURL::OMNIBOX_API_EXTENSION) ||
+           ((turl->type() == TemplateURL::OMNIBOX_API_EXTENSION) &&
             (turl->id() > best_fallback->id()))))
         best_fallback = turl.get();
     }
     RemoveFromDomainMap(template_url);
     if (best_fallback) {
       AddToMap(best_fallback);
       AddToDomainMap(best_fallback);
     } else {
       keyword_to_turl_and_length_.erase(keyword);
     }
   }
 
-  if (template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION)
+  if (template_url->type() == TemplateURL::OMNIBOX_API_EXTENSION)
     return;
 
   if (!template_url->sync_guid().empty())
     guid_to_turl_.erase(template_url->sync_guid());
   // |provider_map_| is only initialized after loading has completed.
   if (loaded_) {
     provider_map_->Remove(template_url);
   }
 }
 
 void TemplateURLService::AddToMaps(TemplateURL* template_url) {
   bool template_url_is_omnibox_api =
-      template_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION;
+      template_url->type() == TemplateURL::OMNIBOX_API_EXTENSION;
   const base::string16& keyword = template_url->keyword();
   KeywordToTURLAndMeaningfulLength::const_iterator i =
       keyword_to_turl_and_length_.find(keyword);
   if (i == keyword_to_turl_and_length_.end()) {
     AddToMap(template_url);
     AddToDomainMap(template_url);
   } else {
     const TemplateURL* existing_url = i->second.first;
     // We should only have overlapping keywords when at least one comes from
     // an extension.  In that case, the ranking order is:
     //   Manually-modified keywords > extension keywords > replaceable keywords
     // When there are multiple extensions, the last-added wins.
     bool existing_url_is_omnibox_api =
-        existing_url->GetType() == TemplateURL::OMNIBOX_API_EXTENSION;
+        existing_url->type() == TemplateURL::OMNIBOX_API_EXTENSION;
     DCHECK(existing_url_is_omnibox_api || template_url_is_omnibox_api);
     if (existing_url_is_omnibox_api ?
         !CanReplace(template_url) : CanReplace(existing_url)) {
       RemoveFromDomainMap(existing_url);
       AddToMap(template_url);
       AddToDomainMap(template_url);
     }
   }
 
   if (template_url_is_omnibox_api)
@@ skipping 113 matching lines @@
 }
 
 bool TemplateURLService::CanReplace(const TemplateURL* t_url) {
   return (t_url != default_search_provider_ && !t_url->show_in_default_list() &&
           t_url->safe_for_autoreplace());
 }
 
 TemplateURL* TemplateURLService::FindNonExtensionTemplateURLForKeyword(
     const base::string16& keyword) {
   TemplateURL* keyword_turl = GetTemplateURLForKeyword(keyword);
-  if (!keyword_turl || (keyword_turl->GetType() == TemplateURL::NORMAL))
+  if (!keyword_turl || (keyword_turl->type() == TemplateURL::NORMAL))
     return keyword_turl;
   // The extension keyword in the model may be hiding a replaceable
   // non-extension keyword.  Look for it.
   for (const auto& turl : template_urls_) {
-    if ((turl->GetType() == TemplateURL::NORMAL) &&
+    if ((turl->type() == TemplateURL::NORMAL) &&
         (turl->keyword() == keyword))
       return turl.get();
   }
   return nullptr;
 }
 
 bool TemplateURLService::UpdateNoNotify(TemplateURL* existing_turl,
                                         const TemplateURL& new_values) {
   DCHECK(existing_turl);
   if (!Contains(&template_urls_, existing_turl))
     return false;
 
-  DCHECK_NE(TemplateURL::OMNIBOX_API_EXTENSION, existing_turl->GetType());
+  DCHECK_NE(TemplateURL::OMNIBOX_API_EXTENSION, existing_turl->type());
 
   base::string16 old_keyword(existing_turl->keyword());
   keyword_to_turl_and_length_.erase(old_keyword);
   RemoveFromDomainMap(existing_turl);
   if (!existing_turl->sync_guid().empty())
     guid_to_turl_.erase(existing_turl->sync_guid());
 
   // |provider_map_| is only initialized after loading has completed.
   if (loaded_)
     provider_map_->Remove(existing_turl);
@@ skipping 15 matching lines @@
   } else {
     // We can theoretically reach here in two cases:
     //   * There is an existing extension keyword and sync brings in a rename of
     //     a non-extension keyword to match.  In this case we just need to pick
     //     which keyword has priority to update the keyword map.
     //   * Autogeneration of the keyword for a Google default search provider
     //     at load time causes it to conflict with an existing keyword.  In this
     //     case we delete the existing keyword if it's replaceable, or else undo
     //     the change in keyword for |existing_turl|.
     TemplateURL* existing_keyword_turl = i->second.first;
-    if (existing_keyword_turl->GetType() != TemplateURL::NORMAL) {
+    if (existing_keyword_turl->type() != TemplateURL::NORMAL) {
       if (!CanReplace(existing_turl)) {
         AddToMap(existing_turl);
         AddToDomainMap(existing_turl);
       }
     } else {
       if (CanReplace(existing_keyword_turl)) {
         RemoveNoNotify(existing_keyword_turl);
       } else {
         existing_turl->data_.SetKeyword(old_keyword);
         AddToMap(existing_turl);
@@ skipping 299 matching lines @@
 
   // Check whether |template_url|'s keyword conflicts with any already in the
   // model.  Note that we can reach here during the loading phase while
   // processing the template URLs from the web data service.  In this case,
   // GetTemplateURLForKeyword() will look not only at what's already in the
   // model, but at the |initial_default_search_provider_|.  Since this engine
   // will presumably also be present in the web data, we need to double-check
   // that any "pre-existing" entries we find are actually coming from
   // |template_urls_|, lest we detect a "conflict" between the
   // |initial_default_search_provider_| and the web data version of itself.
-  if (template_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION &&
+  if (template_url->type() != TemplateURL::OMNIBOX_API_EXTENSION &&
       existing_keyword_turl &&
-      existing_keyword_turl->GetType() != TemplateURL::OMNIBOX_API_EXTENSION &&
+      existing_keyword_turl->type() != TemplateURL::OMNIBOX_API_EXTENSION &&
       Contains(&template_urls_, existing_keyword_turl)) {
     DCHECK_NE(existing_keyword_turl, template_url.get());
     // Only replace one of the TemplateURLs if they are either both extensions,
     // or both not extensions.
-    bool are_same_type = existing_keyword_turl->GetType() ==
-        template_url->GetType();
+    bool are_same_type = IsCreatedByExtension(existing_keyword_turl) ==
+                         IsCreatedByExtension(template_url.get());
     if (CanReplace(existing_keyword_turl) && are_same_type) {
       RemoveNoNotify(existing_keyword_turl);
     } else if (CanReplace(template_url.get()) && are_same_type) {
       return nullptr;
     } else {
       base::string16 new_keyword =
           UniquifyKeyword(*existing_keyword_turl, false);
       ResetTemplateURLNoNotify(existing_keyword_turl,
                                existing_keyword_turl->short_name(), new_keyword,
                                existing_keyword_turl->url());
     }
   }
   TemplateURL* template_url_ptr = template_url.get();
   template_urls_.push_back(std::move(template_url));
   AddToMaps(template_url_ptr);
 
-  if (newly_adding && (template_url_ptr->GetType() == TemplateURL::NORMAL)) {
+  if (newly_adding && (template_url_ptr->type() == TemplateURL::NORMAL)) {
     if (web_data_service_.get())
       web_data_service_->AddKeyword(template_url_ptr->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_turl_.
     ProcessTemplateURLChange(FROM_HERE, template_url_ptr,
                              syncer::SyncChange::ACTION_ADD);
   }
 
   return template_url_ptr;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   DCHECK(template_url != default_search_provider_);
 
   auto i = FindTemplateURL(&template_urls_, template_url);
   if (i == template_urls_.end())
     return;
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   std::unique_ptr<TemplateURL> scoped_turl = std::move(*i);
   template_urls_.erase(i);
 
-  if (template_url->GetType() == TemplateURL::NORMAL) {
+  if (template_url->type() == TemplateURL::NORMAL) {
     if (web_data_service_.get())
       web_data_service_->RemoveKeyword(template_url->id());
 
     // Inform sync of the deletion.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_DELETE);
 
     UMA_HISTOGRAM_ENUMERATION(kDeleteSyncedEngineHistogramName,
                               DELETE_ENGINE_USER_ACTION, DELETE_ENGINE_MAX);
@@ skipping 99 matching lines @@
                                                    bool force) {
   if (!force) {
     // Already unique.
     if (!GetTemplateURLForKeyword(turl.keyword()))
       return turl.keyword();
 
     // First, try to return the generated keyword for the TemplateURL (except
     // for extensions, as their keywords are not associated with their URLs).
     GURL gurl(turl.url());
     if (gurl.is_valid() &&
-        (turl.GetType() != TemplateURL::OMNIBOX_API_EXTENSION)) {
+        (turl.type() != TemplateURL::OMNIBOX_API_EXTENSION)) {
       base::string16 keyword_candidate = TemplateURL::GenerateKeyword(gurl);
       if (!GetTemplateURLForKeyword(keyword_candidate))
         return keyword_candidate;
     }
   }
 
   // We try to uniquify the keyword by appending a special character to the end.
   // This is a best-effort approach where we try to preserve the original
   // keyword and let the user do what they will after our attempt.
   base::string16 keyword_candidate(turl.keyword());
@@ skipping 15 matching lines @@
 
 void TemplateURLService::ResolveSyncKeywordConflict(
     TemplateURL* unapplied_sync_turl,
     TemplateURL* applied_sync_turl,
     syncer::SyncChangeList* change_list) {
   DCHECK(loaded_);
   DCHECK(unapplied_sync_turl);
   DCHECK(applied_sync_turl);
   DCHECK(change_list);
   DCHECK_EQ(applied_sync_turl->keyword(), unapplied_sync_turl->keyword());
-  DCHECK_EQ(TemplateURL::NORMAL, applied_sync_turl->GetType());
+  DCHECK_EQ(TemplateURL::NORMAL, applied_sync_turl->type());
 
   // Both |unapplied_sync_turl| and |applied_sync_turl| are known to Sync, so
   // don't delete either of them. Instead, determine which is "better" and
   // uniquify the other one, sending an update to the server for the updated
   // entry.
   const bool applied_turl_is_better =
       IsLocalTemplateURLBetter(applied_sync_turl, unapplied_sync_turl);
   TemplateURL* loser = applied_turl_is_better ?
       unapplied_sync_turl : applied_sync_turl;
   base::string16 new_keyword = UniquifyKeyword(*loser, false);
@@ skipping 124 matching lines @@
     merge_result->set_num_items_added(merge_result->num_items_added() + 1);
   }
 }
 
 void TemplateURLService::PatchMissingSyncGUIDs(
     OwnedTemplateURLVector* template_urls) {
   DCHECK(template_urls);
   for (auto& template_url : *template_urls) {
     DCHECK(template_url);
     if (template_url->sync_guid().empty() &&
-        (template_url->GetType() == TemplateURL::NORMAL)) {
+        (template_url->type() == TemplateURL::NORMAL)) {
       template_url->data_.sync_guid = base::GenerateGUID();
       if (web_data_service_.get())
         web_data_service_->UpdateKeyword(template_url->data());
     }
   }
 }
 
 void TemplateURLService::OnSyncedDefaultSearchProviderGUIDChanged() {
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(
       &dsp_change_origin_, DSP_CHANGE_SYNC_PREF);
@@ skipping 46 matching lines @@
       return turl.get();
   }
   return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindTemplateURLForExtension(
     const std::string& extension_id,
     TemplateURL::Type type) {
   DCHECK_NE(TemplateURL::NORMAL, type);
   for (const auto& turl : template_urls_) {
-    if (turl->GetType() == type && turl->GetExtensionId() == extension_id)
+    if (turl->type() == type && turl->GetExtensionId() == extension_id)
       return turl.get();
   }
   return nullptr;
 }
 
 TemplateURL* TemplateURLService::FindMatchingExtensionTemplateURL(
     const TemplateURLData& data,
     TemplateURL::Type type) {
   DCHECK_NE(TemplateURL::NORMAL, type);
   for (const auto& turl : template_urls_) {
-    if (turl->GetType() == type &&
+    if (turl->type() == type &&
         TemplateURL::MatchesData(turl.get(), &data, search_terms_data()))
       return turl.get();
   }
   return nullptr;
 }
 
 void TemplateURLService::UpdateExtensionDefaultSearchEngine() {
   TemplateURL* most_recently_intalled_default = nullptr;
   for (const auto& turl : template_urls_) {
-    if ((turl->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) &&
+    if ((turl->type() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) &&
         turl->extension_info_->wants_to_be_default_engine &&
         turl->SupportsReplacement(search_terms_data()) &&
         (!most_recently_intalled_default ||
          (most_recently_intalled_default->extension_info_->install_time <
           turl->extension_info_->install_time)))
       most_recently_intalled_default = turl.get();
   }
 
   if (most_recently_intalled_default) {
     base::AutoReset<DefaultSearchChangeOrigin> change_origin(
         &dsp_change_origin_, DSP_CHANGE_OVERRIDE_SETTINGS_EXTENSION);
     default_search_manager_.SetExtensionControlledDefaultSearchEngine(
         most_recently_intalled_default->data());
   } else {
     default_search_manager_.ClearExtensionControlledDefaultSearchEngine();
   }
 }