Update the contextual search API to include a parameter specifying whether the server shoudl return…

components/search_engines/template_url.cc

 // Copyright 2014 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 "components/search_engines/template_url.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 179 matching lines @@
       contextual_search_params(ContextualSearchParams()) {
 }
 
 TemplateURLRef::SearchTermsArgs::~SearchTermsArgs() {
 }
 
 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
     ContextualSearchParams()
     : version(-1),
       start(base::string16::npos),
-      end(base::string16::npos) {
+      end(base::string16::npos),
+      resolve(true) {
 }
 
 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
     ContextualSearchParams(
         const int version,
         const size_t start,
         const size_t end,
         const std::string& selection,
         const std::string& content,
         const std::string& base_page_url,
         const std::string& encoding)
     : version(version),
       start(start),
       end(end),
       selection(selection),
       content(content),
       base_page_url(base_page_url),
-      encoding(encoding) {
+      encoding(encoding),
+      resolve(true) {
 }
 
 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
+    ContextualSearchParams(
+        const int version,
+        const size_t start,
+        const size_t end,
+        const std::string& selection,
+        const std::string& content,
+        const std::string& base_page_url,
+        const std::string& encoding,
+        const bool resolve)
+    : version(version),
+      start(start),
+      end(end),
+      selection(selection),
+      content(content),
+      base_page_url(base_page_url),
+      encoding(encoding),
+      resolve(resolve) {
+}
+
+TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
     ~ContextualSearchParams() {
 }
 
 // TemplateURLRef -------------------------------------------------------------
 
 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
     : owner_(owner),
       type_(type),
       index_in_owner_(0),
       parsed_(false),
@@ skipping 725 matching lines @@
               params.end) + "&");
         }
 
         if (!params.selection.empty())
           context_data.append("q=" + params.selection + "&");
 
         if (!params.content.empty())
           context_data.append("ctxs_content=" + params.content + "&");
 
         if (!params.base_page_url.empty())
-          context_data.append("ctxs_url=" + params.base_page_url + "&");
+          context_data.append("ctxsl_url=" + params.base_page_url + "&");
 
         if (!params.encoding.empty()) {
           context_data.append("ctxs_encoding=" + params.encoding + "&");
         }
 
+        context_data.append(
+            params.resolve ? "ctxsl_resolve=1" : "ctxsl_resolve=0");
+
         HandleReplacement(std::string(), context_data, *i, &url);
         break;
       }
 
       case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
         DCHECK(!i->is_post_param);
         if (search_terms_args.accepted_suggestion >= 0 ||
             !search_terms_args.assisted_query_stats.empty()) {
           HandleReplacement(
               "oq", base::UTF16ToUTF8(encoded_original_query), *i, &url);
@@ skipping 461 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;
 }