Refactoring after comments in https://codereview.chromium.org/2639153002

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 413 matching lines @@
   TemplateURL* initial_dsp = initial_default_search_provider_.get();
   return (initial_dsp &&
           (initial_dsp->GenerateSearchURL(search_terms_data()).host_piece() ==
            host))
              ? initial_dsp
              : nullptr;
 }
 
 TemplateURL* TemplateURLService::Add(
     std::unique_ptr<TemplateURL> template_url) {
+  DCHECK(template_url);
+  DCHECK(
+      !IsCreatedByExtension(template_url.get()) ||
+      (!FindTemplateURLForExtension(template_url->extension_info_->extension_id,
+                                    template_url->type()) &&
+       template_url->id() == kInvalidTemplateURLID));
+
   KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   TemplateURL* template_url_ptr = AddNoNotify(std::move(template_url), true);
   if (template_url_ptr)
     NotifyObservers();
   return template_url_ptr;
 }
 
 TemplateURL* TemplateURLService::AddWithOverrides(
     std::unique_ptr<TemplateURL> template_url,
     const base::string16& short_name,
     const base::string16& keyword,
     const std::string& url) {
   DCHECK(!short_name.empty());
   DCHECK(!keyword.empty());
   DCHECK(!url.empty());
   template_url->data_.SetShortName(short_name);
   template_url->data_.SetKeyword(keyword);
   template_url->SetURL(url);
   return Add(std::move(template_url));
 }
 
-TemplateURL* TemplateURLService::AddExtensionControlledTURL(
-    std::unique_ptr<TemplateURL> template_url,
-    std::unique_ptr<TemplateURL::AssociatedExtensionInfo> info) {
-  DCHECK(template_url);
-  DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
-  DCHECK(info);
-  DCHECK_NE(TemplateURL::NORMAL, template_url->type());
-  DCHECK(
-      !FindTemplateURLForExtension(info->extension_id, template_url->type()));
-
-  template_url->extension_info_.swap(info);
-
-  return Add(std::move(template_url));
-}
-
 void TemplateURLService::Remove(TemplateURL* template_url) {
   RemoveNoNotify(template_url);
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveExtensionControlledTURL(
     const std::string& extension_id,
     TemplateURL::Type type) {
   TemplateURL* url = FindTemplateURLForExtension(extension_id, type);
   if (!url)
@@ skipping 47 matching lines @@
   DCHECK(loaded_);
 
   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(extension_id));
-  info->install_time = extension_install_time;
-  AddExtensionControlledTURL(
-      base::MakeUnique<TemplateURL>(data, TemplateURL::OMNIBOX_API_EXTENSION),
-      std::move(info));
+  Add(base::MakeUnique<TemplateURL>(data, TemplateURL::OMNIBOX_API_EXTENSION,
+                                    extension_id, extension_install_time,
+                                    false));
 }
 
 TemplateURLService::TemplateURLVector TemplateURLService::GetTemplateURLs() {
   TemplateURLVector result;
   for (const auto& turl : template_urls_)
     result.push_back(turl.get());
   return result;
 }
 
 void TemplateURLService::IncrementUsageCount(TemplateURL* url) {
@@ skipping 1419 matching lines @@
         update_data.SetKeyword(default_search_provider_->keyword());
         update_data.SetShortName(default_search_provider_->short_name());
       }
       UpdateNoNotify(default_search_provider_, TemplateURL(update_data));
     } else {
       // Normally the prepopulated fallback should be present in
       // |template_urls_|, but in a few cases it might not be:
       // (1) Tests that initialize the TemplateURLService in peculiar ways.
       // (2) If the user deleted the pre-populated default and we subsequently
       // lost their user-selected value.
-      std::unique_ptr<TemplateURL> new_dse_ptr =
-          base::MakeUnique<TemplateURL>(*data);
-      TemplateURL* new_dse = new_dse_ptr.get();
-      if (AddNoNotify(std::move(new_dse_ptr), true))
-        default_search_provider_ = new_dse;
+      default_search_provider_ =
+          AddNoNotify(base::MakeUnique<TemplateURL>(*data), true);
     }
   } else if (source == DefaultSearchManager::FROM_USER) {
     default_search_provider_ = GetTemplateURLForGUID(data->sync_guid);
     if (!default_search_provider_ && data->prepopulate_id) {
       default_search_provider_ =
           FindPrepopulatedTemplateURL(data->prepopulate_id);
     }
     TemplateURLData new_data(*data);
     if (default_search_provider_) {
       UpdateNoNotify(default_search_provider_, TemplateURL(new_data));
     } else {
       new_data.id = kInvalidTemplateURLID;
-      std::unique_ptr<TemplateURL> new_dse_ptr =
-          base::MakeUnique<TemplateURL>(new_data);
-      TemplateURL* new_dse = new_dse_ptr.get();
-      if (AddNoNotify(std::move(new_dse_ptr), true))
-        default_search_provider_ = new_dse;
+      default_search_provider_ =
+          AddNoNotify(base::MakeUnique<TemplateURL>(new_data), true);
     }
     if (default_search_provider_ && prefs_) {
       prefs_->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                         default_search_provider_->sync_guid());
     }
   }
 
   bool changed = default_search_provider_ != previous_default_search_engine;
   if (changed)
     RequestGoogleURLTrackerServerCheckIfNecessary();
@@ skipping 466 matching lines @@
     if (!IsCreatedByExtension(template_url.get())) {
       if (keyword_to_template_url.find(template_url->keyword()) !=
           keyword_to_template_url.end()) {
         return true;
       }
       keyword_to_template_url[template_url->keyword()] = template_url.get();
     }
   }
   return false;
 }