No chrome dependencies in TemplateURLService

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"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#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/search_engines/search_host_to_urls_map.h"
+#include "chrome/browser/search_engines/template_url_service_client.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_factory.h"
 #include "components/rappor/rappor_service.h"
 #include "components/search_engines/search_engines_pref_names.h"
+#include "components/search_engines/search_terms_data.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"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
-#include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 typedef SearchHostToURLsMap::TemplateURLSet TemplateURLSet;
 typedef TemplateURLService::SyncDataMap SyncDataMap;
 
 namespace {
 
 bool IdenticalSyncGUIDs(const TemplateURLData* data, const TemplateURL* turl) {
   if (!data || !turl)
     return !data && !turl;
@@ skipping 120 matching lines @@
                   const KeywordToTemplateMap::value_type& elem2) const {
     return (elem1.second == NULL) ?
         (elem2.first.compare(0, elem1.first.length(), elem1.first) > 0) :
         (elem1.first < elem2.first);
   }
 };
 
 
 // TemplateURLService ---------------------------------------------------------
 
-TemplateURLService::TemplateURLService(Profile* profile,
-                                       rappor::RapporService* rappor_service,
-                                       const base::Closure& dsp_change_callback)
-    : provider_map_(new SearchHostToURLsMap),
-      profile_(profile),
-      prefs_(profile ? profile->GetPrefs() : NULL),
+TemplateURLService::TemplateURLService(
+    PrefService* prefs,
+    scoped_ptr<SearchTermsData> search_terms_data,
+    KeywordWebDataService* web_data_service,
+    scoped_ptr<TemplateURLServiceClient> client,
+    GoogleURLTracker* google_url_tracker,
+    rappor::RapporService* rappor_service,
+    const base::Closure& dsp_change_callback)
+    : prefs_(prefs),
+      search_terms_data_(search_terms_data.Pass()),
+      web_data_service_(web_data_service),
+      client_(client.Pass()),
+      google_url_tracker_(google_url_tracker),
       rappor_service_(rappor_service),
-      search_terms_data_(new UIThreadSearchTermsData(profile)),
       dsp_change_callback_(dsp_change_callback),
+      provider_map_(new SearchHostToURLsMap),
       loaded_(false),
       load_failed_(false),
       load_handle_(0),
       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))) {
-  DCHECK(profile_);
+  DCHECK(search_terms_data_);
   Init(NULL, 0);
 }
 
 TemplateURLService::TemplateURLService(const Initializer* initializers,
                                        const int count)
-    : provider_map_(new SearchHostToURLsMap),
-      profile_(NULL),
-      prefs_(NULL),
+    : prefs_(NULL),
+      search_terms_data_(new SearchTermsData),
+      web_data_service_(NULL),
+      google_url_tracker_(NULL),
       rappor_service_(NULL),
-      search_terms_data_(new UIThreadSearchTermsData(NULL)),
+      provider_map_(new SearchHostToURLsMap),
       loaded_(false),
       load_failed_(false),
       load_handle_(0),
       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_(
@@ skipping 570 matching lines @@
 }
 
 void TemplateURLService::RemoveObserver(TemplateURLServiceObserver* observer) {
   model_observers_.RemoveObserver(observer);
 }
 
 void TemplateURLService::Load() {
   if (loaded_ || load_handle_)
     return;
 
-  if (!web_data_service_) {
-    web_data_service_ = WebDataServiceFactory::GetKeywordWebDataForProfile(
-        profile_, Profile::EXPLICIT_ACCESS);
-  }
-
   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_ ?
@@ skipping 75 matching lines @@
   // 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;
     return template_url->AdjustedShortNameForLocaleDirection();
   }
   *is_omnibox_api_extension_keyword = false;
   return base::string16();
 }
 
-void TemplateURLService::Observe(int type,
-                                 const content::NotificationSource& source,
-                                 const content::NotificationDetails& details) {
-  DCHECK_EQ(type, chrome::NOTIFICATION_HISTORY_URL_VISITED);
-  content::Details<history::URLVisitedDetails> visit_details(details);
+void TemplateURLService::OnHistoryURLVisited(const URLVisitedDetails& details) {
   if (!loaded_)
-    visits_to_add_.push_back(*visit_details.ptr());
+    visits_to_add_.push_back(details);
   else
-    UpdateKeywordSearchTermsForURL(*visit_details.ptr());
+    UpdateKeywordSearchTermsForURL(details);
 }
 
 void TemplateURLService::Shutdown() {
   // This check has to be done at Shutdown() instead of in the dtor to ensure
   // that no clients of KeywordWebDataService are holding ptrs to it after the
   // first phase of the KeyedService Shutdown() process.
   if (load_handle_) {
     DCHECK(web_data_service_.get());
     web_data_service_->CancelRequest(load_handle_);
   }
@@ skipping 476 matching lines @@
        i != sync_data.end();
        ++i)
     data_map[i->GetSpecifics().search_engine().sync_guid()] = *i;
   return data_map;
 }
 
 void TemplateURLService::SetKeywordSearchTermsForURL(
     const TemplateURL* t_url,
     const GURL& url,
     const base::string16& term) {
-  HistoryService* history = profile_  ?
-      HistoryServiceFactory::GetForProfile(profile_,
-                                           Profile::EXPLICIT_ACCESS) :
-      NULL;
-  if (!history)
-    return;
-  history->SetKeywordSearchTermsForURL(url, t_url->id(), term);
+  if (client_)
+    client_->SetKeywordSearchTermsForURL(url, t_url->id(), term);
 }
 
 void TemplateURLService::Init(const Initializer* initializers,
                               int num_initializers) {
-  // Register for notifications.
-  if (profile_) {
-    // TODO(sky): bug 1166191. The keywords should be moved into the history
-    // db, which will mean we no longer need this notification and the history
-    // backend can handle automatically adding the search terms as the user
-    // navigates.
-    content::Source<Profile> profile_source(profile_->GetOriginalProfile());
-    notification_registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URL_VISITED,
-                                profile_source);
-    GoogleURLTracker* google_url_tracker =
-        GoogleURLTrackerFactory::GetForProfile(profile_);
+  if (client_)
+    client_->SetOwner(this);
 
-    // GoogleURLTracker is not created in tests.
-    if (google_url_tracker) {
-      google_url_updated_subscription_ =
-          google_url_tracker->RegisterCallback(base::Bind(
-              &TemplateURLService::OnGoogleURLUpdated, base::Unretained(this)));
-    }
+  // GoogleURLTracker is not created in tests.
+  if (google_url_tracker_) {
+    google_url_updated_subscription_ =
+        google_url_tracker_->RegisterCallback(base::Bind(
+            &TemplateURLService::OnGoogleURLUpdated, base::Unretained(this)));
+  }
+
+  if (prefs_) {
     pref_change_registrar_.Init(prefs_);
     pref_change_registrar_.Add(
         prefs::kSyncedDefaultSearchProviderGUID,
         base::Bind(
             &TemplateURLService::OnSyncedDefaultSearchProviderGUIDChanged,
             base::Unretained(this)));
   }
 
   DefaultSearchManager::Source source = DefaultSearchManager::FROM_USER;
   TemplateURLData* dse =
@@ skipping 22 matching lines @@
       AddNoNotify(template_url, true);
 
       // Set the first provided identifier to be the default.
       if (i == 0)
         default_search_manager_.SetUserSelectedDefaultSearchEngine(data);
     }
   }
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine.
-  TemplateURL* default_search_provider = GetDefaultSearchProvider();
-  if (profile_ && default_search_provider &&
-      default_search_provider->HasGoogleBaseURLs(search_terms_data())) {
-    GoogleURLTracker* tracker =
-        GoogleURLTrackerFactory::GetForProfile(profile_);
-    if (tracker)
-      tracker->RequestServerCheck(false);
-  }
+  RequestGoogleURLTrackerServerCheckIfNecessary();
 }
 
 void TemplateURLService::RemoveFromMaps(TemplateURL* template_url) {
   const base::string16& keyword = template_url->keyword();
   DCHECK_NE(0U, keyword_to_template_map_.count(keyword));
   if (keyword_to_template_map_[keyword] == template_url) {
     // We need to check whether the keyword can now be provided by another
     // TemplateURL.  See the comments in AddToMaps() for more information on
     // extension keywords and how they can coexist with non-extension keywords.
     // In the case of more than one extension, we use the most recently
@@ skipping 234 matching lines @@
 void TemplateURLService::MaybeUpdateDSEAfterSync(TemplateURL* synced_turl) {
   if (prefs_ &&
       (synced_turl->sync_guid() ==
           prefs_->GetString(prefs::kSyncedDefaultSearchProviderGUID))) {
     default_search_manager_.SetUserSelectedDefaultSearchEngine(
         synced_turl->data());
   }
 }
 
 void TemplateURLService::UpdateKeywordSearchTermsForURL(
-    const history::URLVisitedDetails& details) {
-  const history::URLRow& row = details.row;
-  if (!row.url().is_valid())
+    const URLVisitedDetails& details) {
+  if (!details.url.is_valid())
     return;
 
   const TemplateURLSet* urls_for_host =
-      provider_map_->GetURLsForHost(row.url().host());
+      provider_map_->GetURLsForHost(details.url.host());
   if (!urls_for_host)
     return;
 
   for (TemplateURLSet::const_iterator i = urls_for_host->begin();
        i != urls_for_host->end(); ++i) {
     base::string16 search_terms;
-    if ((*i)->ExtractSearchTermsFromURL(row.url(), search_terms_data(),
+    if ((*i)->ExtractSearchTermsFromURL(details.url, search_terms_data(),
                                         &search_terms) &&
         !search_terms.empty()) {
-      if (content::PageTransitionStripQualifier(details.transition) ==
-          content::PAGE_TRANSITION_KEYWORD) {
+      if (details.is_keyword_transition) {
         // The visit is the result of the user entering a keyword, generate a
         // KEYWORD_GENERATED visit for the KEYWORD so that the keyword typed
         // count is boosted.
         AddTabToSearchVisit(**i);
       }
-      SetKeywordSearchTermsForURL(*i, row.url(), search_terms);
+      SetKeywordSearchTermsForURL(*i, details.url, search_terms);
     }
   }
 }
 
 void TemplateURLService::AddTabToSearchVisit(const TemplateURL& t_url) {
   // Only add visits for entries the user hasn't modified. If the user modified
   // the entry the keyword may no longer correspond to the host name. It may be
   // possible to do something more sophisticated here, but it's so rare as to
   // not be worth it.
   if (!t_url.safe_for_autoreplace())
     return;
 
-  if (!profile_)
-    return;
-
-  HistoryService* history =
-      HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
-  if (!history)
+  if (!client_)
     return;
 
   GURL url(
       url_fixer::FixupURL(base::UTF16ToUTF8(t_url.keyword()), std::string()));
   if (!url.is_valid())
     return;
 
   // 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);
+  client_->AddKeywordGeneratedVisit(url);
+}
+
+void TemplateURLService::RequestGoogleURLTrackerServerCheckIfNecessary() {
+  if (default_search_provider_ &&
+      default_search_provider_->HasGoogleBaseURLs(search_terms_data()) &&
+      google_url_tracker_)
+    google_url_tracker_->RequestServerCheck(false);
 }
 
 void TemplateURLService::GoogleBaseURLChanged() {
   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());
@@ skipping 140 matching lines @@
     if (default_search_provider_ && prefs_) {
       prefs_->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                         default_search_provider_->sync_guid());
     }
 
   }
 
   default_search_provider_source_ = source;
 
   bool changed = default_search_provider_ != previous_default_search_engine;
-
-  if (profile_ && changed && default_search_provider_ &&
-      default_search_provider_->HasGoogleBaseURLs(search_terms_data())) {
-    GoogleURLTracker* tracker =
-        GoogleURLTrackerFactory::GetForProfile(profile_);
-    if (tracker)
-      tracker->RequestServerCheck(false);
-  }
+  if (changed)
+    RequestGoogleURLTrackerServerCheckIfNecessary();
 
   NotifyObservers();
 
   return changed;
 }
 
 bool TemplateURLService::AddNoNotify(TemplateURL* template_url,
                                      bool newly_adding) {
   DCHECK(template_url);
 
@@ skipping 78 matching lines @@
 
     // 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);
   }
 
-  if (loaded_ && profile_) {
-    HistoryService* history = HistoryServiceFactory::GetForProfile(
-        profile_, Profile::EXPLICIT_ACCESS);
-    if (history)
-      history->DeleteAllSearchTermsForKeyword(template_url->id());
-  }
+  if (loaded_ && client_)
+    client_->DeleteAllSearchTermsForKeyword(template_url->id());
 
   // We own the TemplateURL and need to delete it.
   delete template_url;
 }
 
 bool TemplateURLService::ResetTemplateURLNoNotify(
     TemplateURL* url,
     const base::string16& title,
     const base::string16& keyword,
     const std::string& search_url) {
@@ skipping 318 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();
   }
 }