Revert 130431 - Move the URL string from TemplateURLRef onto the owning TemplateURL. This will mak…

chrome/browser/search_engines/template_url.h

 // 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.
 
 #ifndef CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 32 matching lines @@
  public:
   // Magic numbers to pass to ReplaceSearchTerms() for the |accepted_suggestion|
   // parameter.  Most callers aren't using Suggest capabilities and should just
   // pass NO_SUGGESTIONS_AVAILABLE.
   // NOTE: Because positive values are meaningful, make sure these are negative!
   enum AcceptedSuggestion {
     NO_SUGGESTION_CHOSEN = -1,
     NO_SUGGESTIONS_AVAILABLE = -2,
   };
 
-  // Which kind of URL within our owner we are.  This allows us to get at the
-  // correct string field.
-  enum Type {
-    SEARCH,
-    SUGGEST,
-    INSTANT,
-  };
-
-  TemplateURLRef(TemplateURL* owner, Type type);
+  explicit TemplateURLRef(TemplateURL* owner);
+  TemplateURLRef(TemplateURL* owner, const std::string& url);
   ~TemplateURLRef();
 
-  // Returns the raw URL. None of the parameters will have been replaced.
-  std::string GetURL() const;
-
   // Returns true if this URL supports replacement.
   bool SupportsReplacement() const;
 
   // Like SupportsReplacement but usable on threads other than the UI thread.
   bool SupportsReplacementUsingTermsData(
       const SearchTermsData& search_terms_data) const;
 
   // Returns a string that is the result of replacing the search terms in
   // the url with the specified value.  We use our owner's input encoding.
   //
@@ skipping 15 matching lines @@
 
   // Just like ReplaceSearchTerms except that it takes SearchTermsData to supply
   // the data for some search terms. Most of the time ReplaceSearchTerms should
   // be called.
   std::string ReplaceSearchTermsUsingTermsData(
       const string16& terms,
       int accepted_suggestion,
       const string16& original_query_for_suggestion,
       const SearchTermsData& search_terms_data) const;
 
+  // Returns the raw URL. None of the parameters will have been replaced.
+  const std::string& url() const { return url_; }
+
   // Returns true if the TemplateURLRef is valid. An invalid TemplateURLRef is
   // one that contains unknown terms, or invalid characters.
   bool IsValid() const;
 
   // Like IsValid but usable on threads other than the UI thread.
   bool IsValidUsingTermsData(const SearchTermsData& search_terms_data) const;
 
   // Returns a string representation of this TemplateURLRef suitable for
   // display. The display format is the same as the format used by Firefox.
   string16 DisplayURL() const;
@@ skipping 11 matching lines @@
   // the key of the search term, otherwise this returns an empty string.
   const std::string& GetSearchTermKey() const;
 
   // Converts the specified term in our owner's encoding to a string16.
   string16 SearchTermToString16(const std::string& term) const;
 
   // Returns true if this TemplateURLRef has a replacement term of
   // {google:baseURL} or {google:baseSuggestURL}.
   bool HasGoogleBaseURLs() const;
 
+  // Returns true if both refs are NULL or have the same values.
+  static bool SameUrlRefs(const TemplateURLRef* ref1,
+                          const TemplateURLRef* ref2);
+
   // Collects metrics whether searches through Google are sent with RLZ string.
   void CollectRLZMetrics() const;
 
  private:
   friend class TemplateURL;
   FRIEND_TEST_ALL_PREFIXES(TemplateURLTest, SetPrepopulatedAndParse);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLTest, ParseParameterKnown);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLTest, ParseParameterUnknown);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLTest, ParseURLEmpty);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLTest, ParseURLNoTemplateEnd);
@@ skipping 25 matching lines @@
     size_t index;
   };
 
   // The list of elements to replace.
   typedef std::vector<struct Replacement> Replacements;
 
   // TemplateURLRef internally caches values to make replacement quick. This
   // method invalidates any cached values.
   void InvalidateCachedValues() const;
 
+  // Resets the url.
+  void Set(const std::string& url);
+
   // Parses the parameter in url at the specified offset. start/end specify the
   // range of the parameter in the url, including the braces. If the parameter
   // is valid, url is updated to reflect the appropriate parameter. If
   // the parameter is one of the known parameters an element is added to
   // replacements indicating the type and range of the element. The original
   // parameter is erased from the url.
   //
   // If the parameter is not a known parameter, false is returned. If this is a
   // prepopulated URL, the parameter is erased, otherwise it is left alone.
   bool ParseParameter(size_t start,
@@ skipping 17 matching lines @@
 
   // Like ParseIfNecessary but usable on threads other than the UI thread.
   void ParseIfNecessaryUsingTermsData(
       const SearchTermsData& search_terms_data) const;
 
   // Extracts the query key and host from the url.
   void ParseHostAndSearchTermKey(
       const SearchTermsData& search_terms_data) const;
 
   // The TemplateURL that contains us.  This should outlive us.
-  TemplateURL* const owner_;
+  TemplateURL* owner_;
 
-  // What kind of URL we are.
-  const Type type_;
+  // The raw URL. Where as this contains all the terms (such as {searchTerms}),
+  // parsed_url_ has them all stripped out.
+  std::string url_;
 
   // Whether the URL has been parsed.
   mutable bool parsed_;
 
   // Whether the url was successfully parsed.
   mutable bool valid_;
 
   // The parsed URL. All terms have been stripped out of this with
   // replacements_ giving the index of the terms to replace.
   mutable std::string parsed_url_;
@@ skipping 30 matching lines @@
   // Generates a favicon URL from the specified url.
   static GURL GenerateFaviconURL(const GURL& url);
 
   // A short description of the template. This is the name we show to the user
   // in various places that use keywords. For example, the location bar shows
   // this when the user selects the keyword.
   void set_short_name(const string16& short_name) {
     short_name_ = short_name;
   }
   const string16& short_name() const { return short_name_; }
+
   // An accessor for the short_name, but adjusted so it can be appropriately
   // displayed even if it is LTR and the UI is RTL.
   string16 AdjustedShortNameForLocaleDirection() const;
 
-  // Parameterized URL for providing the results.
+  // Parameterized URL for providing the results. This may be NULL.
+  // Be sure and check the resulting TemplateURLRef for SupportsReplacement
+  // before using.
   void SetURL(const std::string& url);
-  const std::string& url() const { return url_; }
+  // Returns the TemplateURLRef that may be used for search results. This
+  // returns NULL if a url element was not specified.
+  const TemplateURLRef* url() const {
+    return url_.url().empty() ? NULL : &url_;
+  }
 
   // URL providing JSON results. This is typically used to provide suggestions
-  // as you type.
+  // as your type. If NULL, this url does not support suggestions.
+  // Be sure and check the resulting TemplateURLRef for SupportsReplacement
+  // before using.
   void SetSuggestionsURL(const std::string& url);
-  const std::string& suggestions_url() const { return suggestions_url_; }
+  const TemplateURLRef* suggestions_url() const {
+    return suggestions_url_.url().empty() ? NULL : &suggestions_url_;
+  }
 
-  // Parameterized URL for instant results.
+  // Parameterized URL for instant results. This may be NULL.  Be sure and check
+  // the resulting TemplateURLRef for SupportsReplacement before using.
   void SetInstantURL(const std::string& url);
-  const std::string& instant_url() const { return instant_url_; }
+  // Returns the TemplateURLRef that may be used for search results. This
+  // returns NULL if a url element was not specified.
+  const TemplateURLRef* instant_url() const {
+    return instant_url_.url().empty() ? NULL : &instant_url_;
+  }
 
   // URL to the OSD file this came from. May be empty.
   void set_originating_url(const GURL& url) {
     originating_url_ = url;
   }
   const GURL& originating_url() const { return originating_url_; }
 
   // The shortcut for this template url. May be empty.
   void set_keyword(const string16& keyword);
   const string16& keyword() const;
@@ skipping 95 matching lines @@
 
   // If this TemplateURL comes from prepopulated data the prepopulate_id is > 0.
   // SetPrepopulateId also sets any TemplateURLRef's prepopulated flag to true
   // if |id| > 0 and false otherwise.
   void SetPrepopulateId(int id);
   int prepopulate_id() const { return prepopulate_id_; }
 
   const std::string& sync_guid() const { return sync_guid_; }
   void set_sync_guid(const std::string& guid) { sync_guid_ = guid; }
 
-  const TemplateURLRef& url_ref() const { return url_ref_; }
-  const TemplateURLRef& suggestions_url_ref() const {
-    return suggestions_url_ref_;
-  }
-  const TemplateURLRef& instant_url_ref() const { return instant_url_ref_; }
-
   // Returns true if |url| supports replacement.
   bool SupportsReplacement() const;
 
   // Like SupportsReplacement but usable on threads other than the UI thread.
   bool SupportsReplacementUsingTermsData(
       const SearchTermsData& search_terms_data) const;
 
   std::string GetExtensionId() const;
   bool IsExtensionKeyword() const;
 
@@ skipping 11 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
                            ResolveSyncKeywordConflict);
 
   // Invalidates cached values on this object and its child TemplateURLRefs.
   void InvalidateCachedValues() const;
 
   // Unique identifier, used when archived to the database.
   void set_id(TemplateURLID id) { id_ = id; }
 
   string16 short_name_;
-  std::string url_;
-  std::string suggestions_url_;
-  std::string instant_url_;
+  TemplateURLRef url_;
+  TemplateURLRef suggestions_url_;
+  TemplateURLRef instant_url_;
   GURL originating_url_;
   mutable string16 keyword_;
   bool autogenerate_keyword_;  // If this is set, |keyword_| holds the cached
                                // generated keyword if available.
   mutable bool keyword_generated_;  // True if the keyword was generated. This
                                     // is used to avoid multiple attempts if
                                     // generating a keyword failed.
   bool show_in_default_list_;
   bool safe_for_autoreplace_;
   GURL favicon_url_;
   // List of supported input encodings.
   std::vector<std::string> input_encodings_;
   TemplateURLID id_;
   base::Time date_created_;
   base::Time last_modified_;
   bool created_by_policy_;
   int usage_count_;
   int prepopulate_id_;
   // The primary unique identifier for Sync. This is only set on TemplateURLs
   // that have been associated with Sync.
   std::string sync_guid_;
 
-  TemplateURLRef url_ref_;
-  TemplateURLRef suggestions_url_ref_;
-  TemplateURLRef instant_url_ref_;
-
   // TODO(sky): Add date last parsed OSD file.
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_H_