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

chrome/browser/autocomplete/keyword_provider.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/autocomplete/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string16.h"
@@ skipping 346 matching lines @@
   return !keyword->empty();
 }
 
 // static
 void KeywordProvider::FillInURLAndContents(
     Profile* profile,
     const string16& remaining_input,
     const TemplateURL* element,
     AutocompleteMatch* match) {
   DCHECK(!element->short_name().empty());
-  const TemplateURLRef* element_ref = element->url();
-  DCHECK(element_ref);
-  DCHECK(element_ref->IsValid());
+  const TemplateURLRef& element_ref = element->url_ref();
+  DCHECK(element_ref.IsValid());
   int message_id = element->IsExtensionKeyword() ?
       IDS_EXTENSION_KEYWORD_COMMAND : IDS_KEYWORD_SEARCH;
   if (remaining_input.empty()) {
     // Allow extension keyword providers to accept empty string input. This is
     // useful to allow extensions to do something in the case where no input is
     // entered.
-    if (element_ref->SupportsReplacement() && !element->IsExtensionKeyword()) {
+    if (element_ref.SupportsReplacement() && !element->IsExtensionKeyword()) {
       // No query input; return a generic, no-destination placeholder.
       match->contents.assign(
           l10n_util::GetStringFUTF16(message_id,
               element->AdjustedShortNameForLocaleDirection(),
               l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE)));
       match->contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::DIM));
     } else {
       // Keyword that has no replacement text (aka a shorthand for a URL).
-      match->destination_url = GURL(element_ref->url());
+      match->destination_url = GURL(element->url());
       match->contents.assign(element->short_name());
       AutocompleteMatch::ClassifyLocationInString(0, match->contents.length(),
           match->contents.length(), ACMatchClassification::NONE,
           &match->contents_class);
     }
   } else {
     // Create destination URL by escaping user input and substituting into
     // keyword template URL.  The escaping here handles whitespace in user
     // input, but we rely on later canonicalization functions to do more
     // fixup to make the URL valid if necessary.
-    DCHECK(element_ref->SupportsReplacement());
-    match->destination_url = GURL(element_ref->
-        ReplaceSearchTermsUsingProfile(profile, remaining_input,
-            TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+    DCHECK(element_ref.SupportsReplacement());
+    match->destination_url = GURL(element_ref.ReplaceSearchTermsUsingProfile(
+        profile, remaining_input, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
+        string16()));
     std::vector<size_t> content_param_offsets;
     match->contents.assign(l10n_util::GetStringFUTF16(message_id,
                                                       element->short_name(),
                                                       remaining_input,
                                                       &content_param_offsets));
     if (content_param_offsets.size() == 2) {
       AutocompleteMatch::ClassifyLocationInString(content_param_offsets[1],
           remaining_input.length(), match->contents.length(),
           ACMatchClassification::NONE, &match->contents_class);
     } else {
@@ skipping 21 matching lines @@
     TemplateURLService* model,
     const string16& keyword,
     const AutocompleteInput& input,
     size_t prefix_length,
     const string16& remaining_input,
     int relevance) {
   DCHECK(model);
   // Get keyword data from data store.
   const TemplateURL* element(
       model->GetTemplateURLForKeyword(keyword));
-  DCHECK(element && element->url());
-  const bool supports_replacement = element->url()->SupportsReplacement();
+  DCHECK(element && !element->url().empty());
+  const bool supports_replacement = element->url_ref().SupportsReplacement();
 
   // Create an edit entry of "[keyword] [remaining input]".  This is helpful
   // even when [remaining input] is empty, as the user can select the popup
   // choice and immediately begin typing in query input.
   const bool keyword_complete = (prefix_length == keyword.length());
   if (relevance < 0) {
     relevance =
         CalculateRelevance(input.type(), keyword_complete,
                            // When the user wants keyword matches to take
                            // preference, score them highly regardless of
@@ skipping 128 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }