Send URLs on non-zero prefix suggest requests also.

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/basictypes.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
@@ skipping 42 matching lines @@
 
 const char kGoogleAssistedQueryStatsParameter[] = "google:assistedQueryStats";
 
 // Host/Domain Google searches are relative to.
 const char kGoogleBaseURLParameter[] = "google:baseURL";
 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}";
 
 // Like google:baseURL, but for the Search Suggest capability.
 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL";
 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}";
+const char kGoogleCurrentPageUrlParameter[] = "google:currentPageUrl";
 const char kGoogleCursorPositionParameter[] = "google:cursorPosition";
 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter";
 const char kGoogleInstantExtendedEnabledParameter[] =
     "google:instantExtendedEnabledParameter";
 const char kGoogleInstantExtendedEnabledKey[] =
     "google:instantExtendedEnabledKey";
 const char kGoogleInstantExtendedEnabledKeyFull[] =
     "{google:instantExtendedEnabledKey}";
 const char kGoogleNTPIsThemedParameter[] = "google:ntpIsThemedParameter";
 const char kGoogleOmniboxStartMarginParameter[] =
     "google:omniboxStartMarginParameter";
 const char kGoogleOriginalQueryForSuggestionParameter[] =
     "google:originalQueryForSuggestion";
 const char kGooglePageClassificationParameter[] = "google:pageClassification";
 const char kGoogleRLZParameter[] = "google:RLZ";
 const char kGoogleSearchClient[] = "google:searchClient";
 const char kGoogleSearchFieldtrialParameter[] =
     "google:searchFieldtrialParameter";
 const char kGoogleSourceIdParameter[] = "google:sourceId";
 const char kGoogleSuggestAPIKeyParameter[] = "google:suggestAPIKeyParameter";
 const char kGoogleSuggestClient[] = "google:suggestClient";
-const char kGoogleZeroPrefixUrlParameter[] = "google:zeroPrefixUrl";
 
 // Same as kSearchTermsParameter, with no escaping.
 const char kGoogleUnescapedSearchTermsParameter[] =
     "google:unescapedSearchTerms";
 const char kGoogleUnescapedSearchTermsParameterFull[] =
     "{google:unescapedSearchTerms}";
 
 const char kGoogleImageSearchSource[] = "google:imageSearchSource";
 const char kGoogleImageThumbnailParameter[] = "google:imageThumbnail";
 const char kGoogleImageURLParameter[] = "google:imageURL";
@@ skipping 434 matching lines @@
     replacements->push_back(Replacement(SEARCH_TERMS, start));
   } else if (parameter == kCountParameter) {
     if (!optional)
       url->insert(start, kDefaultCount);
   } else if (parameter == kGoogleAssistedQueryStatsParameter) {
     replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start));
   } else if (parameter == kGoogleBaseURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_URL, start));
   } else if (parameter == kGoogleBaseSuggestURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start));
+  } else if (parameter == kGoogleCurrentPageUrlParameter) {
+    replacements->push_back(Replacement(GOOGLE_CURRENT_PAGE_URL, start));
   } else if (parameter == kGoogleCursorPositionParameter) {
     replacements->push_back(Replacement(GOOGLE_CURSOR_POSITION, start));
   } else if (parameter == kGoogleImageOriginalHeight) {
     replacements->push_back(
         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_HEIGHT, start));
   } else if (parameter == kGoogleImageOriginalWidth) {
     replacements->push_back(
         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH, start));
   } else if (parameter == kGoogleImageSearchSource) {
     url->insert(start, GetGoogleImageSearchSource());
@@ skipping 31 matching lines @@
 #else
     url->insert(start, "sourceid=chrome&");
 #endif
   } else if (parameter == kGoogleSuggestAPIKeyParameter) {
     url->insert(start,
                 net::EscapeQueryParamValue(google_apis::GetAPIKey(), false));
   } else if (parameter == kGoogleSuggestClient) {
     replacements->push_back(Replacement(GOOGLE_SUGGEST_CLIENT, start));
   } else if (parameter == kGoogleUnescapedSearchTermsParameter) {
     replacements->push_back(Replacement(GOOGLE_UNESCAPED_SEARCH_TERMS, start));
-  } else if (parameter == kGoogleZeroPrefixUrlParameter) {
-    replacements->push_back(Replacement(GOOGLE_ZERO_PREFIX_URL, start));
   } else if (parameter == kInputEncodingParameter) {
     replacements->push_back(Replacement(ENCODING, start));
   } else if (parameter == kLanguageParameter) {
     replacements->push_back(Replacement(LANGUAGE, start));
   } else if (parameter == kOutputEncodingParameter) {
     if (!optional)
       url->insert(start, kOutputEncodingType);
   } else if ((parameter == kStartIndexParameter) ||
              (parameter == kStartPageParameter)) {
     // We don't support these.
@@ skipping 219 matching lines @@
             std::string(), search_terms_data.GoogleBaseURLValue(), *i, &url);
         break;
 
       case GOOGLE_BASE_SUGGEST_URL:
         DCHECK(!i->is_post_param);
         HandleReplacement(
             std::string(), search_terms_data.GoogleBaseSuggestURLValue(), *i,
             &url);
         break;
 
+      case GOOGLE_CURRENT_PAGE_URL:
+        DCHECK(!i->is_post_param);
+        if (!search_terms_args.current_page_url.empty()) {
+          const std::string& escaped_current_page_url =
+              net::EscapeQueryParamValue(search_terms_args.current_page_url,

[Peter Kasting, 2013/10/08 01:10:25]

Nit: Consider inlining this into the next statement to match how most of the
other cases here handle things

[H Fung, 2013/10/30 23:56:15]

Done.

+                                         true);
+          HandleReplacement("url", escaped_current_page_url, *i, &url);
+        }
+
+        break;
+
       case GOOGLE_CURSOR_POSITION:
         DCHECK(!i->is_post_param);
         if (search_terms_args.cursor_position != string16::npos)
           HandleReplacement(
               "cp",
               base::StringPrintf("%" PRIuS, search_terms_args.cursor_position),
               *i,
               &url);
         break;
 
@@ skipping 80 matching lines @@
       case GOOGLE_UNESCAPED_SEARCH_TERMS: {
         std::string unescaped_terms;
         base::UTF16ToCodepage(search_terms_args.search_terms,
                               input_encoding.c_str(),
                               base::OnStringConversionError::SKIP,
                               &unescaped_terms);
         HandleReplacement(std::string(), unescaped_terms, *i, &url);
         break;
       }
 
-      case GOOGLE_ZERO_PREFIX_URL:
-        DCHECK(!i->is_post_param);
-        if (!search_terms_args.zero_prefix_url.empty()) {
-          const std::string& escaped_zero_prefix_url =
-              net::EscapeQueryParamValue(search_terms_args.zero_prefix_url,
-                                         true);
-          HandleReplacement("url", escaped_zero_prefix_url, *i, &url);
-        }
-
-        break;
-
       case LANGUAGE:
         HandleReplacement(
             std::string(), search_terms_data.GetApplicationLocale(), *i, &url);
         break;
 
       case SEARCH_TERMS:
         HandleReplacement(std::string(), UTF16ToUTF8(encoded_terms), *i, &url);
         break;
 
       case GOOGLE_IMAGE_THUMBNAIL:
@@ skipping 326 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }