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

chrome/browser/search_engines/template_url.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.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 // Used if the count parameter is not optional. Indicates we want 10 search
 // results.
 static const char kDefaultCount[] = "10";
 
 // Used if the parameter kOutputEncodingParameter is required.
 static const char kOutputEncodingType[] = "UTF-8";
 
 
 // TemplateURLRef -------------------------------------------------------------
 
-TemplateURLRef::TemplateURLRef(TemplateURL* owner)
+TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
     : owner_(owner),
+      type_(type),
+      parsed_(false),
+      valid_(false),
+      supports_replacements_(false),
       prepopulated_(false) {
   DCHECK(owner_);
-  Set(std::string());
-}
-
-TemplateURLRef::TemplateURLRef(TemplateURL* owner, const std::string& url)
-    : owner_(owner),
-      prepopulated_(false) {
-  DCHECK(owner_);
-  Set(url);
 }
 
 TemplateURLRef::~TemplateURLRef() {
 }
 
+std::string TemplateURLRef::GetURL() const {
+  switch (type_) {
+    case SEARCH:  return owner_->url();
+    case SUGGEST: return owner_->suggestions_url();
+    case INSTANT: return owner_->instant_url();
+    default:      NOTREACHED(); return std::string();
+  }
+}
+
 bool TemplateURLRef::SupportsReplacement() const {
   UIThreadSearchTermsData search_terms_data;
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_ && supports_replacements_;
 }
@@ skipping 164 matching lines @@
 }
 
 bool TemplateURLRef::IsValidUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_;
 }
 
 string16 TemplateURLRef::DisplayURL() const {
   ParseIfNecessary();
-  if (!valid_ || replacements_.empty())
-    return UTF8ToUTF16(url_);
-
-  string16 result = UTF8ToUTF16(url_);
-  ReplaceSubstringsAfterOffset(&result, 0,
-                               ASCIIToUTF16(kSearchTermsParameterFull),
-                               ASCIIToUTF16(kDisplaySearchTerms));
-
-  ReplaceSubstringsAfterOffset(
-      &result, 0,
-      ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
-      ASCIIToUTF16(kDisplayUnescapedSearchTerms));
-
+  string16 result(UTF8ToUTF16(GetURL()));
+  if (valid_ && !replacements_.empty()) {
+    ReplaceSubstringsAfterOffset(&result, 0,
+                                 ASCIIToUTF16(kSearchTermsParameterFull),
+                                 ASCIIToUTF16(kDisplaySearchTerms));
+    ReplaceSubstringsAfterOffset(&result, 0,
+        ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
+        ASCIIToUTF16(kDisplayUnescapedSearchTerms));
+  }
   return result;
 }
 
 // static
 std::string TemplateURLRef::DisplayURLToURLRef(
     const string16& display_url) {
   string16 result = display_url;
   ReplaceSubstringsAfterOffset(&result, 0, ASCIIToUTF16(kDisplaySearchTerms),
                                ASCIIToUTF16(kSearchTermsParameterFull));
   ReplaceSubstringsAfterOffset(
@@ skipping 48 matching lines @@
 bool TemplateURLRef::HasGoogleBaseURLs() const {
   ParseIfNecessary();
   for (size_t i = 0; i < replacements_.size(); ++i) {
     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
       return true;
   }
   return false;
 }
 
-// static
-bool TemplateURLRef::SameUrlRefs(const TemplateURLRef* ref1,
-                                 const TemplateURLRef* ref2) {
-  return ref1 == ref2 || (ref1 && ref2 && ref1->url() == ref2->url());
-}
-
 void TemplateURLRef::CollectRLZMetrics() const {
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   ParseIfNecessary();
   for (size_t i = 0; i < replacements_.size(); ++i) {
     // We are interesed in searches that were supposed to send the RLZ token.
     if (replacements_[i].type == GOOGLE_RLZ) {
       std::string brand;
       // We only have RLZ tocken on a branded browser version.
       if (google_util::GetBrand(&brand) && !brand.empty() &&
            !google_util::IsOrganic(brand)) {
@@ skipping 10 matching lines @@
 }
 
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
   path_.clear();
   search_term_key_.clear();
   replacements_.clear();
 }
 
-void TemplateURLRef::Set(const std::string& url) {
-  url_ = url;
-  InvalidateCachedValues();
-}
-
 bool TemplateURLRef::ParseParameter(size_t start,
                                     size_t end,
                                     std::string* url,
                                     Replacements* replacements) const {
   DCHECK(start != std::string::npos &&
          end != std::string::npos && end > start);
   size_t length = end - start - 1;
   bool optional = false;
   if ((*url)[end - 1] == kOptional) {
     optional = true;
@@ skipping 89 matching lines @@
 
 void TemplateURLRef::ParseIfNecessary() const {
   UIThreadSearchTermsData search_terms_data;
   ParseIfNecessaryUsingTermsData(search_terms_data);
 }
 
 void TemplateURLRef::ParseIfNecessaryUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   if (!parsed_) {
     parsed_ = true;
-    parsed_url_ = ParseURL(url_, &replacements_, &valid_);
+    parsed_url_ = ParseURL(GetURL(), &replacements_, &valid_);
     supports_replacements_ = false;
     if (valid_) {
       bool has_only_one_search_term = false;
       for (Replacements::const_iterator i = replacements_.begin();
            i != replacements_.end(); ++i) {
         if ((i->type == SEARCH_TERMS) ||
             (i->type == GOOGLE_UNESCAPED_SEARCH_TERMS)) {
           if (has_only_one_search_term) {
             has_only_one_search_term = false;
             break;
           }
           has_only_one_search_term = true;
           supports_replacements_ = true;
         }
       }
       // Only parse the host/key if there is one search term. Technically there
       // could be more than one term, but it's uncommon; so we punt.
       if (has_only_one_search_term)
         ParseHostAndSearchTermKey(search_terms_data);
     }
   }
 }
 
 void TemplateURLRef::ParseHostAndSearchTermKey(
     const SearchTermsData& search_terms_data) const {
-  std::string url_string = url_;
+  std::string url_string(GetURL());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                kGoogleBaseURLParameterFull,
                                search_terms_data.GoogleBaseURLValue());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                kGoogleBaseSuggestURLParameterFull,
                                search_terms_data.GoogleBaseSuggestURLValue());
 
   GURL url(url_string);
   if (!url.is_valid())
     return;
@@ skipping 18 matching lines @@
         break;
       }
     }
   }
 }
 
 
 // TemplateURL ----------------------------------------------------------------
 
 TemplateURL::TemplateURL()
-    : url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      suggestions_url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      instant_url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      autogenerate_keyword_(false),
+    : autogenerate_keyword_(false),
       keyword_generated_(false),
       show_in_default_list_(false),
       safe_for_autoreplace_(false),
       id_(0),
       date_created_(base::Time::Now()),
       last_modified_(base::Time::Now()),
       created_by_policy_(false),
       usage_count_(0),
       prepopulate_id_(0),
-      sync_guid_(guid::GenerateGUID()) {
+      sync_guid_(guid::GenerateGUID()),
+      url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this), TemplateURLRef::SEARCH),
+      suggestions_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                           TemplateURLRef::SUGGEST),
+      instant_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                       TemplateURLRef::INSTANT) {
 }
 
 TemplateURL::TemplateURL(const TemplateURL& other)
     : short_name_(other.short_name_),
-      url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      suggestions_url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      instant_url_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      url_(other.url_),
+      suggestions_url_(other.suggestions_url_),
+      instant_url_(other.instant_url_),
       originating_url_(other.originating_url_),
       keyword_(other.keyword_),
       autogenerate_keyword_(other.autogenerate_keyword_),
       keyword_generated_(other.keyword_generated_),
       show_in_default_list_(other.show_in_default_list_),
       safe_for_autoreplace_(other.safe_for_autoreplace_),
       favicon_url_(other.favicon_url_),
       input_encodings_(other.input_encodings_),
       id_(other.id_),
       date_created_(other.date_created_),
       last_modified_(other.last_modified_),
       created_by_policy_(other.created_by_policy_),
       usage_count_(other.usage_count_),
-      sync_guid_(other.sync_guid_) {
+      sync_guid_(other.sync_guid_),
+      url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this), TemplateURLRef::SEARCH),
+      suggestions_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                           TemplateURLRef::SUGGEST),
+      instant_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                       TemplateURLRef::INSTANT) {
   CopyURLRefs(other);
 }
 
 TemplateURL& TemplateURL::operator=(const TemplateURL& other) {
   if (this == &other)
     return *this;
 
   short_name_ = other.short_name_;
-  CopyURLRefs(other);
+  url_ = other.url_;
+  suggestions_url_ = other.suggestions_url_;
+  instant_url_ = other.instant_url_;
   originating_url_ = other.originating_url_;
   keyword_ = other.keyword_;
   autogenerate_keyword_ = other.autogenerate_keyword_;
   keyword_generated_ = other.keyword_generated_;
   show_in_default_list_ = other.show_in_default_list_;
   safe_for_autoreplace_ = other.safe_for_autoreplace_;
   favicon_url_ = other.favicon_url_;
   input_encodings_ = other.input_encodings_;
   id_ = other.id_;
   date_created_ = other.date_created_;
   last_modified_ = other.last_modified_;
   created_by_policy_ = other.created_by_policy_;
   usage_count_ = other.usage_count_;
   sync_guid_ = other.sync_guid_;
+  CopyURLRefs(other);
   return *this;
 }
 
 TemplateURL::~TemplateURL() {
 }
 
 // static
 GURL TemplateURL::GenerateFaviconURL(const GURL& url) {
   DCHECK(url.is_valid());
   GURL::Replacements rep;
 
   const char favicon_path[] = "/favicon.ico";
   int favicon_path_len = arraysize(favicon_path) - 1;
 
   rep.SetPath(favicon_path, url_parse::Component(0, favicon_path_len));
   rep.ClearUsername();
   rep.ClearPassword();
   rep.ClearQuery();
   rep.ClearRef();
   return url.ReplaceComponents(rep);
 }
 
 string16 TemplateURL::AdjustedShortNameForLocaleDirection() const {
   string16 bidi_safe_short_name = short_name_;
   base::i18n::AdjustStringForLocaleDirection(&bidi_safe_short_name);
   return bidi_safe_short_name;
 }
 
 void TemplateURL::SetURL(const std::string& url) {
-  url_.Set(url);
+  url_ = url;
+  url_ref_.InvalidateCachedValues();
 }
 
 void TemplateURL::SetSuggestionsURL(const std::string& url) {
-  suggestions_url_.Set(url);
+  suggestions_url_ = url;
+  suggestions_url_ref_.InvalidateCachedValues();
 }
 
 void TemplateURL::SetInstantURL(const std::string& url) {
-  instant_url_.Set(url);
+  instant_url_ = url;
+  instant_url_ref_.InvalidateCachedValues();
 }
 
 void TemplateURL::set_keyword(const string16& keyword) {
   // Case sensitive keyword matching is confusing. As such, we force all
   // keywords to be lower case.
   keyword_ = base::i18n::ToLower(keyword);
   autogenerate_keyword_ = false;
 }
 
 const string16& TemplateURL::keyword() const {
   EnsureKeyword();
   return keyword_;
 }
 
 void TemplateURL::EnsureKeyword() const {
   if (autogenerate_keyword_ && !keyword_generated_) {
     // Generate a keyword and cache it.
     keyword_ = TemplateURLService::GenerateKeyword(
         TemplateURLService::GenerateSearchURL(this).GetWithEmptyPath(), true);
     keyword_generated_ = true;
   }
 }
 
 bool TemplateURL::ShowInDefaultList() const {
-  return show_in_default_list() && url() && url()->SupportsReplacement();
+  return show_in_default_list() && url_ref_.SupportsReplacement();
 }
 
 void TemplateURL::CopyURLRefs(const TemplateURL& other) {
-  suggestions_url_.Set(other.suggestions_url_.url_);
-  url_.Set(other.url_.url_);
-  instant_url_.Set(other.instant_url_.url_);
+  url_ref_.InvalidateCachedValues();
+  suggestions_url_ref_.InvalidateCachedValues();
+  instant_url_ref_.InvalidateCachedValues();
   SetPrepopulateId(other.prepopulate_id_);
 }
 
 void TemplateURL::SetPrepopulateId(int id) {
   prepopulate_id_ = id;
   const bool prepopulated = id > 0;
-  suggestions_url_.prepopulated_ = prepopulated;
-  url_.prepopulated_ = prepopulated;
-  instant_url_.prepopulated_ = prepopulated;
+  suggestions_url_ref_.prepopulated_ = prepopulated;
+  url_ref_.prepopulated_ = prepopulated;
+  instant_url_ref_.prepopulated_ = prepopulated;
 }
 
 void TemplateURL::InvalidateCachedValues() const {
-  url_.InvalidateCachedValues();
-  suggestions_url_.InvalidateCachedValues();
+  url_ref_.InvalidateCachedValues();
+  suggestions_url_ref_.InvalidateCachedValues();
+  instant_url_ref_.InvalidateCachedValues();
   if (autogenerate_keyword_) {
     keyword_.clear();
     keyword_generated_ = false;
   }
 }
 
 bool TemplateURL::SupportsReplacement() const {
   UIThreadSearchTermsData search_terms_data;
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURL::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
-  return url_.SupportsReplacementUsingTermsData(search_terms_data);
+  return url_ref_.SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 std::string TemplateURL::GetExtensionId() const {
   DCHECK(IsExtensionKeyword());
-  return GURL(url_.url()).host();
+  return GURL(url_).host();
 }
 
 bool TemplateURL::IsExtensionKeyword() const {
-  return GURL(url_.url()).SchemeIs(chrome::kExtensionScheme);
+  return GURL(url_).SchemeIs(chrome::kExtensionScheme);
 }