Split keyword related parts of WebDataService as KeywordWebDataService

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 13 matching lines @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_url_tracker_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/search_engines/search_host_to_urls_map.h"
 #include "chrome/browser/search_engines/template_url_service_observer.h"
 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
 #include "chrome/browser/search_engines/util.h"
-#include "chrome/browser/webdata/web_data_service.h"
+#include "chrome/browser/webdata/web_data_service_factory.h"
 #include "components/rappor/rappor_service.h"
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/url_fixer/url_fixer.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sync/api/sync_change.h"
@@ skipping 168 matching lines @@
 TemplateURLService::TemplateURLService(const Initializer* initializers,
                                        const int count)
     : provider_map_(new SearchHostToURLsMap),
       profile_(NULL),
       prefs_(NULL),
       rappor_service_(NULL),
       search_terms_data_(new UIThreadSearchTermsData(NULL)),
       loaded_(false),
       load_failed_(false),
       load_handle_(0),
-      service_(NULL),
       default_search_provider_(NULL),
       next_id_(kInvalidTemplateURLID + 1),
       time_provider_(&base::Time::Now),
       models_associated_(false),
       processing_syncer_changes_(false),
       dsp_change_origin_(DSP_CHANGE_OTHER),
       default_search_manager_(
           prefs_,
           base::Bind(&TemplateURLService::OnDefaultSearchChange,
                      base::Unretained(this))) {
   Init(initializers, count);
 }
 
 TemplateURLService::~TemplateURLService() {
-  // |service_| should be deleted during Shutdown().
-  DCHECK(!service_);
+  // |web_data_service_| should be deleted during Shutdown().
+  DCHECK(!web_data_service_);
   STLDeleteElements(&template_urls_);
 }
 
 // static
 bool TemplateURLService::LoadDefaultSearchProviderFromPrefs(
     PrefService* prefs,
     scoped_ptr<TemplateURLData>* default_provider_data,
     bool* is_managed) {
   if (!prefs || !prefs->HasPrefPath(prefs::kDefaultSearchProviderSearchURL) ||
       !prefs->HasPrefPath(prefs::kDefaultSearchProviderKeyword))
@@ skipping 281 matching lines @@
   if (loaded_)
     return provider_map_->GetTemplateURLForHost(host);
   TemplateURL* initial_dsp = initial_default_search_provider_.get();
   if (!initial_dsp)
     return NULL;
   return (initial_dsp->GenerateSearchURL(search_terms_data()).host() == host) ?
       initial_dsp : NULL;
 }
 
 bool TemplateURLService::Add(TemplateURL* template_url) {
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   if (!AddNoNotify(template_url, true))
     return false;
   NotifyObservers();
   return true;
 }
 
 void TemplateURLService::AddWithOverrides(TemplateURL* template_url,
                                           const base::string16& short_name,
                                           const base::string16& keyword,
                                           const std::string& url) {
@@ skipping 11 matching lines @@
   DCHECK(loaded_);
   DCHECK(template_url);
   DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
   DCHECK(info);
   DCHECK_NE(TemplateURL::NORMAL, info->type);
   DCHECK_EQ(info->wants_to_be_default_engine,
             template_url->show_in_default_list());
   DCHECK(!FindTemplateURLForExtension(info->extension_id, info->type));
   template_url->extension_info_.swap(info);
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   if (AddNoNotify(template_url, true)) {
     if (template_url->extension_info_->wants_to_be_default_engine)
       UpdateExtensionDefaultSearchEngine();
     NotifyObservers();
   }
 }
 
 void TemplateURLService::Remove(TemplateURL* template_url) {
   RemoveNoNotify(template_url);
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveExtensionControlledTURL(
     const std::string& extension_id,
     TemplateURL::Type type) {
   DCHECK(loaded_);
   TemplateURL* url = FindTemplateURLForExtension(extension_id, type);
   if (!url)
     return;
   // NULL this out so that we can call RemoveNoNotify.
   // UpdateExtensionDefaultSearchEngine will cause it to be reset.
   if (default_search_provider_ == url)
     default_search_provider_ = NULL;
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   RemoveNoNotify(url);
   UpdateExtensionDefaultSearchEngine();
   NotifyObservers();
 }
 
 void TemplateURLService::RemoveAutoGeneratedSince(base::Time created_after) {
   RemoveAutoGeneratedBetween(created_after, base::Time());
 }
 
 void TemplateURLService::RemoveAutoGeneratedBetween(base::Time created_after,
                                                     base::Time created_before) {
   RemoveAutoGeneratedForOriginBetween(GURL(), created_after, created_before);
 }
 
 void TemplateURLService::RemoveAutoGeneratedForOriginBetween(
     const GURL& origin,
     base::Time created_after,
     base::Time created_before) {
   GURL o(origin.GetOrigin());
   bool should_notify = false;
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   for (size_t i = 0; i < template_urls_.size();) {
     if (template_urls_[i]->date_created() >= created_after &&
         (created_before.is_null() ||
          template_urls_[i]->date_created() < created_before) &&
         CanReplace(template_urls_[i]) &&
         (o.is_empty() ||
          template_urls_[i]->GenerateSearchURL(
              search_terms_data()).GetOrigin() == o)) {
       RemoveNoNotify(template_urls_[i]);
       should_notify = true;
@@ skipping 34 matching lines @@
 void TemplateURLService::IncrementUsageCount(TemplateURL* url) {
   DCHECK(url);
   // Extension-controlled search engines are not persisted.
   if (url->GetType() == TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)
     return;
   if (std::find(template_urls_.begin(), template_urls_.end(), url) ==
       template_urls_.end())
     return;
   ++url->data_.usage_count;
 
-  if (service_)
-    service_->UpdateKeyword(url->data());
+  if (web_data_service_)
+    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();
 }
 
@@ skipping 61 matching lines @@
   }
 
   size_t default_search_provider_index = 0;
   ScopedVector<TemplateURLData> prepopulated_urls =
       TemplateURLPrepopulateData::GetPrepopulatedEngines(
           prefs_, &default_search_provider_index);
   DCHECK(!prepopulated_urls.empty());
   ActionsFromPrepopulateData actions(CreateActionsFromCurrentPrepopulateData(
       &prepopulated_urls, template_urls_, default_search_provider_));
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   // Remove items.
   for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
        i < actions.removed_engines.end(); ++i)
     RemoveNoNotify(*i);
 
   // Edit items.
   for (EditedEngines::iterator i(actions.edited_engines.begin());
        i < actions.edited_engines.end(); ++i) {
     TemplateURL new_values(i->second);
@@ skipping 34 matching lines @@
 }
 
 void TemplateURLService::RemoveObserver(TemplateURLServiceObserver* observer) {
   model_observers_.RemoveObserver(observer);
 }
 
 void TemplateURLService::Load() {
   if (loaded_ || load_handle_)
     return;
 
-  if (!service_)
-    service_ = WebDataService::FromBrowserContext(profile_);
+  if (!web_data_service_) {
+    web_data_service_ = WebDataServiceFactory::GetKeywordWebDataForProfile(
+        profile_, Profile::EXPLICIT_ACCESS);
+  }
 
-  if (service_)
-    load_handle_ = service_->GetKeywords(this);
+  if (web_data_service_)
+    load_handle_ = web_data_service_->GetKeywords(this);
   else
     ChangeToLoadedState();
 }
 
 scoped_ptr<TemplateURLService::Subscription>
     TemplateURLService::RegisterOnLoadedCallback(
         const base::Closure& callback) {
   return loaded_ ?
       scoped_ptr<TemplateURLService::Subscription>() :
       on_loaded_callbacks_.Add(callback);
 }
 
 void TemplateURLService::OnWebDataServiceRequestDone(
-    WebDataService::Handle h,
+    KeywordWebDataService::Handle h,
     const WDTypedResult* result) {
   // Reset the load_handle so that we don't try and cancel the load in
   // the destructor.
   load_handle_ = 0;
 
   if (!result) {
     // Results are null if the database went away or (most likely) wasn't
     // loaded.
     load_failed_ = true;
-    service_ = NULL;
+    web_data_service_ = NULL;
     ChangeToLoadedState();
     return;
   }
 
   TemplateURLVector template_urls;
   int new_resource_keyword_version = 0;
   GetSearchProvidersUsingKeywordResult(
       *result,
-      service_.get(),
+      web_data_service_.get(),
       prefs_,
       &template_urls,
       (default_search_provider_source_ == DefaultSearchManager::FROM_USER) ?
           initial_default_search_provider_.get() : NULL,
       search_terms_data(),
       &new_resource_keyword_version,
       &pre_sync_deletes_);
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   PatchMissingSyncGUIDs(&template_urls);
   SetTemplateURLs(&template_urls);
 
   // This initializes provider_map_ which should be done before
   // calling UpdateKeywordSearchTermsForURL.
   // This also calls NotifyObservers.
   ChangeToLoadedState();
 
   // Index any visits that occurred before we finished loading.
   for (size_t i = 0; i < visits_to_add_.size(); ++i)
     UpdateKeywordSearchTermsForURL(visits_to_add_[i]);
   visits_to_add_.clear();
 
   if (new_resource_keyword_version)
-    service_->SetBuiltinKeywordVersion(new_resource_keyword_version);
+    web_data_service_->SetBuiltinKeywordVersion(new_resource_keyword_version);
 
   if (default_search_provider_) {
     UMA_HISTOGRAM_ENUMERATION(
         "Search.DefaultSearchProviderType",
         TemplateURLPrepopulateData::GetEngineType(
             *default_search_provider_, search_terms_data()),
         SEARCH_ENGINE_MAX);
 
     if (rappor_service_) {
       rappor_service_->RecordSample(
@@ skipping 28 matching lines @@
   DCHECK_EQ(type, chrome::NOTIFICATION_HISTORY_URL_VISITED);
   content::Details<history::URLVisitedDetails> visit_details(details);
   if (!loaded_)
     visits_to_add_.push_back(*visit_details.ptr());
   else
     UpdateKeywordSearchTermsForURL(*visit_details.ptr());
 }
 
 void TemplateURLService::Shutdown() {
   // This check has to be done at Shutdown() instead of in the dtor to ensure
-  // that no clients of WebDataService are holding ptrs to it after the first
-  // phase of the KeyedService Shutdown() process.
+  // that no clients of KeywordWebDataService are holding ptrs to it after the
+  // first phase of the KeyedService Shutdown() process.
   if (load_handle_) {
-    DCHECK(service_.get());
-    service_->CancelRequest(load_handle_);
+    DCHECK(web_data_service_.get());
+    web_data_service_->CancelRequest(load_handle_);
   }
-  service_ = NULL;
+  web_data_service_ = NULL;
 }
 
 syncer::SyncDataList TemplateURLService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::SEARCH_ENGINES, type);
 
   syncer::SyncDataList current_data;
   for (TemplateURLVector::const_iterator iter = template_urls_.begin();
       iter != template_urls_.end(); ++iter) {
     // We don't sync keywords managed by policy.
@@ skipping 21 matching lines @@
   DCHECK(loaded_);
 
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   // We've started syncing, so set our origin member to the base Sync value.
   // As we move through Sync Code, we may set this to increasingly specific
   // origins so we can tell what exactly caused a DSP change.
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(&dsp_change_origin_,
       DSP_CHANGE_SYNC_UNINTENTIONAL);
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   syncer::SyncChangeList new_changes;
   syncer::SyncError error;
   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
       iter != change_list.end(); ++iter) {
     DCHECK_EQ(syncer::SEARCH_ENGINES, iter->sync_data().GetDataType());
 
     std::string guid =
         iter->sync_data().GetSpecifics().search_engine().sync_guid();
     TemplateURL* existing_turl = GetTemplateURLForGUID(guid);
@@ skipping 138 matching lines @@
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(&dsp_change_origin_,
       DSP_CHANGE_SYNC_UNINTENTIONAL);
 
   syncer::SyncChangeList new_changes;
 
   // Build maps of our sync GUIDs to syncer::SyncData.
   SyncDataMap local_data_map = CreateGUIDToSyncDataMap(
       GetAllSyncData(syncer::SEARCH_ENGINES));
   SyncDataMap sync_data_map = CreateGUIDToSyncDataMap(initial_sync_data);
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
 
   merge_result.set_num_items_before_association(local_data_map.size());
   for (SyncDataMap::const_iterator iter = sync_data_map.begin();
       iter != sync_data_map.end(); ++iter) {
     TemplateURL* local_turl = GetTemplateURLForGUID(iter->first);
     scoped_ptr<TemplateURL> sync_turl(
         CreateTemplateURLFromTemplateURLAndSyncData(
             prefs_, search_terms_data(), local_turl, iter->second,
             &new_changes));
     if (!sync_turl.get())
@@ skipping 312 matching lines @@
   TemplateURLData* dse =
       default_search_manager_.GetDefaultSearchEngine(&source);
   ApplyDefaultSearchChange(dse, source);
 
   if (num_initializers > 0) {
     // This path is only hit by test code and is used to simulate a loaded
     // TemplateURLService.
     ChangeToLoadedState();
 
     // Add specific initializers, if any.
-    WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+    KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
     for (int i(0); i < num_initializers; ++i) {
       DCHECK(initializers[i].keyword);
       DCHECK(initializers[i].url);
       DCHECK(initializers[i].content);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
       TemplateURLData data;
       data.short_name = base::UTF8ToUTF16(initializers[i].content);
       data.SetKeyword(base::UTF8ToUTF16(initializers[i].keyword));
@@ skipping 218 matching lines @@
         RemoveNoNotify(existing_keyword_turl);
       } else {
         existing_turl->data_.SetKeyword(old_keyword);
         keyword_to_template_map_[old_keyword] = existing_turl;
       }
     }
   }
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_[existing_turl->sync_guid()] = existing_turl;
 
-  if (service_)
-    service_->UpdateKeyword(existing_turl->data());
+  if (web_data_service_)
+    web_data_service_->UpdateKeyword(existing_turl->data());
 
   // Inform sync of the update.
   ProcessTemplateURLChange(
       FROM_HERE, existing_turl, syncer::SyncChange::ACTION_UPDATE);
 
   if (default_search_provider_ == existing_turl &&
       default_search_provider_source_ == DefaultSearchManager::FROM_USER) {
     default_search_manager_.SetUserSelectedDefaultSearchEngine(
         default_search_provider_->data());
   }
@@ skipping 82 matching lines @@
 
   // Synthesize a visit for the keyword. This ensures the url for the keyword is
   // autocompleted even if the user doesn't type the url in directly.
   history->AddPage(url, base::Time::Now(), NULL, 0, GURL(),
                    history::RedirectList(),
                    content::PAGE_TRANSITION_KEYWORD_GENERATED,
                    history::SOURCE_BROWSED, false);
 }
 
 void TemplateURLService::GoogleBaseURLChanged() {
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   bool something_changed = false;
   for (TemplateURLVector::iterator i(template_urls_.begin());
        i != template_urls_.end(); ++i) {
     TemplateURL* t_url = *i;
     if (t_url->HasGoogleBaseURLs(search_terms_data())) {
       TemplateURL updated_turl(t_url->data());
       updated_turl.ResetKeywordIfNecessary(search_terms_data(), false);
       KeywordToTemplateMap::const_iterator existing_entry =
           keyword_to_template_map_.find(updated_turl.keyword());
       if ((existing_entry != keyword_to_template_map_.end()) &&
@@ skipping 76 matching lines @@
   // NULL due to policy. We'll never actually get recursion with data == NULL.
   if (source == default_search_provider_source_ && data != NULL &&
       TemplateURL::MatchesData(default_search_provider_, data,
                                search_terms_data()))
     return false;
 
   // This may be deleted later. Use exclusively for pointer comparison to detect
   // a change.
   TemplateURL* previous_default_search_engine = default_search_provider_;
 
-  WebDataService::KeywordBatchModeScoper keyword_scoper(service_.get());
+  KeywordWebDataService::BatchModeScoper scoper(web_data_service_.get());
   if (default_search_provider_source_ == DefaultSearchManager::FROM_POLICY ||
       source == DefaultSearchManager::FROM_POLICY) {
     // We do this both to remove any no-longer-applicable policy-defined DSE as
     // well as to add the new one, if appropriate.
     UpdateProvidersCreatedByPolicy(
         &template_urls_,
         source == DefaultSearchManager::FROM_POLICY ? data : NULL);
   }
 
   if (!data) {
@@ skipping 109 matching lines @@
                                existing_keyword_turl->short_name(), new_keyword,
                                existing_keyword_turl->url());
     }
   }
   template_urls_.push_back(template_url);
   AddToMaps(template_url);
 
   if (newly_adding &&
       (template_url->GetType() !=
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)) {
-    if (service_)
-      service_->AddKeyword(template_url->data());
+    if (web_data_service_)
+      web_data_service_->AddKeyword(template_url->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_template_map_.
     ProcessTemplateURLChange(FROM_HERE,
                              template_url,
                              syncer::SyncChange::ACTION_ADD);
   }
 
   return true;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   DCHECK(template_url != default_search_provider_);
 
   TemplateURLVector::iterator i =
       std::find(template_urls_.begin(), template_urls_.end(), template_url);
   if (i == template_urls_.end())
     return;
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   template_urls_.erase(i);
 
   if (template_url->GetType() != TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION) {
-    if (service_)
-      service_->RemoveKeyword(template_url->id());
+    if (web_data_service_)
+      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 61 matching lines @@
         // database and the |default_search_provider|.
         default_search_provider_ = template_url;
         // Prevent us from saving any other entries, or creating a new one.
         default_from_prefs = NULL;
         ++i;
         continue;
       }
 
       RemoveFromMaps(template_url);
       i = template_urls->erase(i);
-      if (service_)
-        service_->RemoveKeyword(template_url->id());
+      if (web_data_service_)
+        web_data_service_->RemoveKeyword(template_url->id());
       delete template_url;
     } else {
       ++i;
     }
   }
 
   if (default_from_prefs) {
     default_search_provider_ = NULL;
     default_search_provider_source_ = DefaultSearchManager::FROM_POLICY;
     TemplateURLData new_data(*default_from_prefs);
@@ skipping 171 matching lines @@
     TemplateURLVector* template_urls) {
   DCHECK(template_urls);
   for (TemplateURLVector::iterator i = template_urls->begin();
        i != template_urls->end(); ++i) {
     TemplateURL* template_url = *i;
     DCHECK(template_url);
     if (template_url->sync_guid().empty() &&
         (template_url->GetType() !=
             TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION)) {
       template_url->data_.sync_guid = base::GenerateGUID();
-      if (service_)
-        service_->UpdateKeyword(template_url->data());
+      if (web_data_service_)
+        web_data_service_->UpdateKeyword(template_url->data());
     }
   }
 }
 
 void TemplateURLService::OnSyncedDefaultSearchProviderGUIDChanged() {
   base::AutoReset<DefaultSearchChangeOrigin> change_origin(
       &dsp_change_origin_, DSP_CHANGE_SYNC_PREF);
 
   std::string new_guid =
       prefs_->GetString(prefs::kSyncedDefaultSearchProviderGUID);
@@ skipping 58 matching lines @@
 
   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();
   }
 }