Move the URL string from TemplateURLRef onto the owning TemplateURL. This will make it easier to m…

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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 53 matching lines @@
 const char kReplacementTerm[] = "blah.blah.blah.blah.blah";
 
 bool TemplateURLsHaveSamePrefs(const TemplateURL* url1,
                                const TemplateURL* url2) {
   if (url1 == url2)
     return true;
   return NULL != url1 &&
       NULL != url2 &&
       url1->short_name() == url2->short_name() &&
       url1->keyword() == url2->keyword() &&
-      TemplateURLRef::SameUrlRefs(url1->url(), url2->url()) &&
-      TemplateURLRef::SameUrlRefs(url1->suggestions_url(),
-                                  url2->suggestions_url()) &&
+      url1->url() == url2->url() &&
+      url1->suggestions_url() == url2->suggestions_url() &&
+      url1->instant_url() == url2->instant_url() &&
       url1->favicon_url() == url2->favicon_url() &&
       url1->safe_for_autoreplace() == url2->safe_for_autoreplace() &&
       url1->show_in_default_list() == url2->show_in_default_list() &&
       url1->input_encodings() == url2->input_encodings();
 }
 
 }  // namespace
 
 
 class TemplateURLService::LessWithPrefix {
@@ skipping 125 matching lines @@
   DCHECK(t_url);
   UIThreadSearchTermsData search_terms_data;
   return GenerateSearchURLUsingTermsData(t_url, search_terms_data);
 }
 
 // static
 GURL TemplateURLService::GenerateSearchURLUsingTermsData(
     const TemplateURL* t_url,
     const SearchTermsData& search_terms_data) {
   DCHECK(t_url);
-  const TemplateURLRef* search_ref = t_url->url();
+  const TemplateURLRef& search_ref = t_url->url_ref();
   // Extension keywords don't have host-based search URLs.
-  if (!search_ref || !search_ref->IsValidUsingTermsData(search_terms_data) ||
+  if (!search_ref.IsValidUsingTermsData(search_terms_data) ||
       t_url->IsExtensionKeyword())
     return GURL();
 
-  if (!search_ref->SupportsReplacementUsingTermsData(search_terms_data))
-    return GURL(search_ref->url());
+  if (!search_ref.SupportsReplacementUsingTermsData(search_terms_data))
+    return GURL(t_url->url());
 
-  return GURL(search_ref->ReplaceSearchTermsUsingTermsData(
+  return GURL(search_ref.ReplaceSearchTermsUsingTermsData(
       ASCIIToUTF16(kReplacementTerm), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
       string16(), search_terms_data));
 }
 
 bool TemplateURLService::CanReplaceKeyword(
     const string16& keyword,
     const GURL& url,
     const TemplateURL** template_url_to_replace) {
   DCHECK(!keyword.empty());  // This should only be called for non-empty
                              // keywords. If we need to support empty kewords
@@ skipping 36 matching lines @@
   const std::pair<KeywordToTemplateMap::const_iterator,
                   KeywordToTemplateMap::const_iterator> match_range(
       std::equal_range(
           keyword_to_template_map_.begin(), keyword_to_template_map_.end(),
           KeywordToTemplateMap::value_type(prefix, kNullTemplateURL),
           LessWithPrefix()));
 
   // Return vector of matching keywords.
   for (KeywordToTemplateMap::const_iterator i(match_range.first);
        i != match_range.second; ++i) {
-    DCHECK(i->second->url());
-    if (!support_replacement_only || i->second->url()->SupportsReplacement())
+    DCHECK(!i->second->url().empty());
+    if (!support_replacement_only || i->second->url_ref().SupportsReplacement())
       matches->push_back(i->first);
   }
 }
 
 const TemplateURL* TemplateURLService::GetTemplateURLForKeyword(
     const string16& keyword) const {
   KeywordToTemplateMap::const_iterator elem(
       keyword_to_template_map_.find(keyword));
   return (elem == keyword_to_template_map_.end()) ? NULL : elem->second;
 }
@@ skipping 91 matching lines @@
     const Extension* extension) {
   const TemplateURL* url = GetTemplateURLForExtension(extension);
   if (url)
     Remove(url);
 }
 
 const TemplateURL* TemplateURLService::GetTemplateURLForExtension(
     const Extension* extension) const {
   for (TemplateURLVector::const_iterator i = template_urls_.begin();
        i != template_urls_.end(); ++i) {
-    if ((*i)->IsExtensionKeyword() && (*i)->url()->GetHost() == extension->id())
+    if ((*i)->IsExtensionKeyword() &&
+        ((*i)->url_ref().GetHost() == extension->id()))
       return *i;
   }
 
   return NULL;
 }
 
 std::vector<const TemplateURL*> TemplateURLService::GetTemplateURLs() const {
   return template_urls_;
 }
 
 void TemplateURLService::IncrementUsageCount(const TemplateURL* url) {
   DCHECK(url && std::find(template_urls_.begin(), template_urls_.end(), url) !=
          template_urls_.end());
   const_cast<TemplateURL*>(url)->set_usage_count(url->usage_count() + 1);
   if (service_.get())
     service_.get()->UpdateKeyword(*url);
 }
 
 void TemplateURLService::ResetTemplateURL(const TemplateURL* url,
                                           const string16& title,
                                           const string16& keyword,
                                           const std::string& search_url) {
   TemplateURL new_url(*url);
   new_url.set_short_name(title);
   new_url.set_keyword(keyword);
-  if ((new_url.url() && search_url.empty()) ||
-      (!new_url.url() && !search_url.empty()) ||
-      (new_url.url() && new_url.url()->url() != search_url)) {
+  if (new_url.url() != search_url) {
     new_url.SetURL(search_url);
     // The urls have changed, reset the favicon url.
     new_url.set_favicon_url(GURL());
   }
   new_url.set_safe_for_autoreplace(false);
   new_url.set_last_modified(time_provider_());
   UpdateNoNotify(url, new_url);
   NotifyObservers();
 }
 
 bool TemplateURLService::CanMakeDefault(const TemplateURL* url) {
   return url != GetDefaultSearchProvider() &&
-      url->url() &&
-      url->url()->SupportsReplacement() &&
-      !is_default_search_managed();
+      url->url_ref().SupportsReplacement() && !is_default_search_managed();
 }
 
 void TemplateURLService::SetDefaultSearchProvider(const TemplateURL* url) {
   if (is_default_search_managed_) {
     NOTREACHED();
     return;
   }
   // Always persist the setting in the database, that way if the backup
   // signature has changed out from under us it gets reset correctly.
   SetDefaultSearchProviderNoNotify(url);
@@ skipping 515 matching lines @@
 
 // static
 SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
     const TemplateURL& turl) {
   sync_pb::EntitySpecifics specifics;
   sync_pb::SearchEngineSpecifics* se_specifics =
       specifics.mutable_search_engine();
   se_specifics->set_short_name(UTF16ToUTF8(turl.short_name()));
   se_specifics->set_keyword(UTF16ToUTF8(turl.keyword()));
   se_specifics->set_favicon_url(turl.favicon_url().spec());
-  se_specifics->set_url(turl.url() ? turl.url()->url() : std::string());
+  se_specifics->set_url(turl.url());
   se_specifics->set_safe_for_autoreplace(turl.safe_for_autoreplace());
   se_specifics->set_originating_url(turl.originating_url().spec());
   se_specifics->set_date_created(turl.date_created().ToInternalValue());
   se_specifics->set_input_encodings(JoinString(turl.input_encodings(), ';'));
   se_specifics->set_show_in_default_list(turl.show_in_default_list());
-  se_specifics->set_suggestions_url(turl.suggestions_url() ?
-      turl.suggestions_url()->url() : std::string());
+  se_specifics->set_suggestions_url(turl.suggestions_url());
   se_specifics->set_prepopulate_id(turl.prepopulate_id());
   se_specifics->set_autogenerate_keyword(turl.autogenerate_keyword());
-  se_specifics->set_instant_url(turl.instant_url() ?
-      turl.instant_url()->url() : std::string());
+  se_specifics->set_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(turl.sync_guid());
   return SyncData::CreateLocalData(se_specifics->sync_guid(),
                                    se_specifics->keyword(),
                                    specifics);
 }
 
 // static
 TemplateURL* TemplateURLService::CreateTemplateURLFromSyncData(
     const SyncData& sync_data) {
@@ skipping 66 matching lines @@
       template_url->SetURL(osd_url);
       AddNoNotify(template_url);
     }
   }
 
   // Initialize default search.
   UpdateDefaultSearch();
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine, not in headless mode and not in Chrome Frame.
-  if (initial_default_search_provider_.get()) {
-    const TemplateURLRef* default_provider_ref =
-        initial_default_search_provider_->url();
-    if (default_provider_ref && default_provider_ref->HasGoogleBaseURLs()) {
-      scoped_ptr<base::Environment> env(base::Environment::Create());
-      if (!env->HasVar(env_vars::kHeadless) &&
-          !CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame))
-        GoogleURLTracker::RequestServerCheck();
-    }
+  if (initial_default_search_provider_.get() &&
+    initial_default_search_provider_->url_ref().HasGoogleBaseURLs()) {
+    scoped_ptr<base::Environment> env(base::Environment::Create());
+    if (!env->HasVar(env_vars::kHeadless) &&
+        !CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame))
+      GoogleURLTracker::RequestServerCheck();
   }
 }
 
 void TemplateURLService::RemoveFromMaps(const TemplateURL* template_url) {
   if (!template_url->keyword().empty())
     keyword_to_template_map_.erase(template_url->keyword());
   if (!template_url->sync_guid().empty())
     guid_to_template_map_.erase(template_url->sync_guid());
   if (loaded_)
     provider_map_.Remove(template_url);
@@ skipping 84 matching lines @@
   std::string suggest_url;
   std::string instant_url;
   std::string icon_url;
   std::string encodings;
   std::string short_name;
   std::string keyword;
   std::string id_string;
   std::string prepopulate_id;
   if (t_url) {
     enabled = true;
-    if (t_url->url())
-      search_url = t_url->url()->url();
-    if (t_url->suggestions_url())
-      suggest_url = t_url->suggestions_url()->url();
-    if (t_url->instant_url())
-      instant_url = t_url->instant_url()->url();
+    search_url = t_url->url();
+    suggest_url = t_url->suggestions_url();
+    instant_url = t_url->instant_url();
     GURL icon_gurl = t_url->favicon_url();
     if (!icon_gurl.is_empty())
       icon_url = icon_gurl.spec();
     encodings = JoinString(t_url->input_encodings(), ';');
     short_name = UTF16ToUTF8(t_url->short_name());
     keyword = UTF16ToUTF8(t_url->keyword());
     id_string = base::Int64ToString(t_url->id());
     prepopulate_id = base::Int64ToString(t_url->prepopulate_id());
   }
   prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, enabled);
@@ skipping 144 matching lines @@
   if (!urls_for_host)
     return;
 
   QueryTerms query_terms;
   bool built_terms = false;  // Most URLs won't match a TemplateURLs host;
                              // so we lazily build the query_terms.
   const std::string path = row.url().path();
 
   for (TemplateURLSet::const_iterator i = urls_for_host->begin();
        i != urls_for_host->end(); ++i) {
-    const TemplateURLRef* search_ref = (*i)->url();
+    const TemplateURLRef& search_ref = (*i)->url_ref();
 
     // Count the URL against a TemplateURL if the host and path of the
     // visited URL match that of the TemplateURL as well as the search term's
     // key of the TemplateURL occurring in the visited url.
     //
     // NOTE: Even though we're iterating over TemplateURLs indexed by the host
     // of the URL we still need to call GetHost on the search_ref. In
     // particular, GetHost returns an empty string if search_ref doesn't support
     // replacement or isn't valid for use in keyword search terms.
 
-    if (search_ref && search_ref->GetHost() == row.url().host() &&
-        search_ref->GetPath() == path) {
+    if (search_ref.GetHost() == row.url().host() &&
+        search_ref.GetPath() == path) {
       if (!built_terms && !BuildQueryTerms(row.url(), &query_terms)) {
         // No query terms. No need to continue with the rest of the
         // TemplateURLs.
         return;
       }
       built_terms = true;
 
       if (content::PageTransitionStripQualifier(details.transition) ==
           content::PAGE_TRANSITION_KEYWORD) {
         // 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);
       }
 
       QueryTerms::iterator terms_iterator =
-          query_terms.find(search_ref->GetSearchTermKey());
+          query_terms.find(search_ref.GetSearchTermKey());
       if (terms_iterator != query_terms.end() &&
           !terms_iterator->second.empty()) {
         SetKeywordSearchTermsForURL(*i, row.url(),
-            search_ref->SearchTermToString16(terms_iterator->second));
+            search_ref.SearchTermToString16(terms_iterator->second));
       }
     }
   }
 }
 
 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.
@@ skipping 49 matching lines @@
       }
     }
   }
   return (valid_term_count > 0);
 }
 
 void TemplateURLService::GoogleBaseURLChanged() {
   bool something_changed = false;
   for (size_t i = 0; i < template_urls_.size(); ++i) {
     const TemplateURL* t_url = template_urls_[i];
-    if ((t_url->url() && t_url->url()->HasGoogleBaseURLs()) ||
-        (t_url->suggestions_url() &&
-         t_url->suggestions_url()->HasGoogleBaseURLs())) {
+    if (t_url->url_ref().HasGoogleBaseURLs() ||
+        t_url->suggestions_url_ref().HasGoogleBaseURLs()) {
       RemoveFromKeywordMapByPointer(t_url);
       t_url->InvalidateCachedValues();
       if (!t_url->keyword().empty())
         keyword_to_template_map_[t_url->keyword()] = t_url;
       something_changed = true;
     }
   }
 
   if (something_changed && loaded_) {
     UIThreadSearchTermsData search_terms_data;
@@ skipping 101 matching lines @@
   default_search_provider_ = url;
 
   if (url) {
     TemplateURL* modifiable_url = const_cast<TemplateURL*>(url);
     // Don't mark the url as edited, otherwise we won't be able to rev the
     // template urls we ship with.
     modifiable_url->set_show_in_default_list(true);
     if (service_.get())
       service_.get()->UpdateKeyword(*url);
 
-    const TemplateURLRef* url_ref = url->url();
-    if (url_ref && url_ref->HasGoogleBaseURLs()) {
+    if (url->url_ref().HasGoogleBaseURLs()) {
       GoogleURLTracker::RequestServerCheck();
 #if defined(ENABLE_RLZ)
       // Needs to be evaluated. See http://crbug.com/62328.
       base::ThreadRestrictions::ScopedAllowIO allow_io;
       RLZTracker::RecordProductEvent(rlz_lib::CHROME,
                                      rlz_lib::CHROME_OMNIBOX,
                                      rlz_lib::SET_TO_GOOGLE);
 #endif
     }
   }
@@ skipping 135 matching lines @@
   new_url.set_sync_guid(guid);
   UpdateNoNotify(url, new_url);
 }
 
 string16 TemplateURLService::UniquifyKeyword(const TemplateURL& turl) const {
   // Already unique.
   if (!GetTemplateURLForKeyword(turl.keyword()))
     return turl.keyword();
 
   // First, try to return the generated keyword for the TemplateURL.
-  string16 keyword_candidate = GenerateKeyword(
-      turl.url() ? GURL(turl.url()->url()) : GURL(), true);
+  GURL gurl(turl.url());
+  string16 keyword_candidate = GenerateKeyword(gurl, true);
   if (!GetTemplateURLForKeyword(keyword_candidate) &&
       !keyword_candidate.empty()) {
     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.
   keyword_candidate = turl.keyword();
   do {
-    keyword_candidate.append(UTF8ToUTF16("_"));
+    keyword_candidate.append(ASCIIToUTF16("_"));
   } while (GetTemplateURLForKeyword(keyword_candidate));
 
   return keyword_candidate;
 }
 
 bool TemplateURLService::ResolveSyncKeywordConflict(
     TemplateURL* sync_turl,
     SyncChangeList* change_list) {
   DCHECK(sync_turl);
   DCHECK(change_list);
@@ skipping 23 matching lines @@
   return true;
 }
 
 const TemplateURL* TemplateURLService::FindDuplicateOfSyncTemplateURL(
     const TemplateURL& sync_turl) {
   const TemplateURL* existing_turl =
       GetTemplateURLForKeyword(sync_turl.keyword());
   if (!existing_turl)
     return NULL;
 
-  if (existing_turl->url() && sync_turl.url() &&
-      existing_turl->url()->url() == sync_turl.url()->url()) {
+  if (!existing_turl->url().empty() &&
+      existing_turl->url() == sync_turl.url()) {
     return existing_turl;
   }
   return NULL;
 }
 
 void TemplateURLService::MergeSyncAndLocalURLDuplicates(
     TemplateURL* sync_turl,
     TemplateURL* local_turl,
     SyncChangeList* change_list) {
   DCHECK(sync_turl);
@@ skipping 96 matching lines @@
   dst->set_input_encodings(input_encodings);
   dst->set_show_in_default_list(specifics.show_in_default_list());
   dst->SetSuggestionsURL(specifics.suggestions_url());
   dst->SetPrepopulateId(specifics.prepopulate_id());
   dst->set_autogenerate_keyword(specifics.autogenerate_keyword());
   dst->SetInstantURL(specifics.instant_url());
   dst->set_last_modified(
       base::Time::FromInternalValue(specifics.last_modified()));
   dst->set_sync_guid(specifics.sync_guid());
 }