Add contextual search to the template url system

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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 85 matching lines @@
     "google:unescapedSearchTerms";
 const char kGoogleUnescapedSearchTermsParameterFull[] =
     "{google:unescapedSearchTerms}";
 
 const char kGoogleImageSearchSource[] = "google:imageSearchSource";
 const char kGoogleImageThumbnailParameter[] = "google:imageThumbnail";
 const char kGoogleImageURLParameter[] = "google:imageURL";
 const char kGoogleImageOriginalWidth[] = "google:imageOriginalWidth";
 const char kGoogleImageOriginalHeight[] = "google:imageOriginalHeight";
 
+// Contextual search parameters.
+const char kGoogleContextualSearchVersion[] = "google:contextualSearchVersion";
+const char kGoogleContextualSearchStart[] = "google:contextualSearchStart";
+const char kGoogleContextualSearchEnd[] = "google:contextualSearchEnd";
+const char kGoogleContextualSearchContent[] = "google:contextualSearchContent";
+const char kGoogleContextualSearchBasePageURL[] =
+    "google:contextualSearchBasePageURL";
+const char kGoogleContextualSearchEncoding[] =
+    "google:contextualSearchEncoding";
+
 // Display value for kSearchTermsParameter.
 const char kDisplaySearchTerms[] = "%s";
 
 // Display value for kGoogleUnescapedSearchTermsParameter.
 const char kDisplayUnescapedSearchTerms[] = "%S";
 
 // Used if the count parameter is not optional. Indicates we want 10 search
 // results.
 const char kDefaultCount[] = "10";
 
@@ skipping 82 matching lines @@
 
 
 // TemplateURLRef::SearchTermsArgs --------------------------------------------
 
 TemplateURLRef::SearchTermsArgs::SearchTermsArgs(
     const base::string16& search_terms)
     : search_terms(search_terms),
       accepted_suggestion(NO_SUGGESTIONS_AVAILABLE),
       cursor_position(base::string16::npos),
       omnibox_start_margin(-1),
+      contextual_search_version(-1),
+      contextual_search_start(-1),
+      contextual_search_end(-1),
       page_classification(AutocompleteInput::INVALID_SPEC),
       bookmark_bar_pinned(false),
       append_extra_query_params(false),
       force_instant_results(false),
       from_app_list(false) {
 }
 
 TemplateURLRef::SearchTermsArgs::~SearchTermsArgs() {
 }
 
@@ skipping 26 matching lines @@
       showing_search_terms_(ShowingSearchTermsOnSRP()) {
   DCHECK(owner_);
   DCHECK_LT(index_in_owner_, owner_->URLCount());
 }
 
 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();
-    case IMAGE:   return owner_->image_url();
-    case NEW_TAB: return owner_->new_tab_url();
-    case INDEXED: return owner_->GetURL(index_in_owner_);
-    default:      NOTREACHED(); return std::string();  // NOLINT
+    case SEARCH:            return owner_->url();
+    case SUGGEST:           return owner_->suggestions_url();
+    case INSTANT:           return owner_->instant_url();
+    case IMAGE:             return owner_->image_url();
+    case NEW_TAB:           return owner_->new_tab_url();
+    case CONTEXTUAL_SEARCH: return owner_->contextual_search_url();
+    case INDEXED:           return owner_->GetURL(index_in_owner_);
+    default:       NOTREACHED(); return std::string();  // NOLINT
   }
 }
 
 std::string TemplateURLRef::GetPostParamsString() const {
   switch (type_) {
     case INDEXED:
-    case SEARCH:  return owner_->search_url_post_params();
-    case SUGGEST: return owner_->suggestions_url_post_params();
-    case INSTANT: return owner_->instant_url_post_params();
-    case NEW_TAB: return std::string();
-    case IMAGE:   return owner_->image_url_post_params();
+    case SEARCH:            return owner_->search_url_post_params();
+    case SUGGEST:           return owner_->suggestions_url_post_params();
+    case INSTANT:           return owner_->instant_url_post_params();
+    case NEW_TAB:           return std::string();
+    case CONTEXTUAL_SEARCH: return std::string();
+    case IMAGE:             return owner_->image_url_post_params();
     default:      NOTREACHED(); return std::string();  // NOLINT
   }
 }
 
 bool TemplateURLRef::UsesPOSTMethodUsingTermsData(
     const SearchTermsData* search_terms_data) const {
   if (search_terms_data)
     ParseIfNecessaryUsingTermsData(*search_terms_data);
   else
     ParseIfNecessary();
@@ skipping 303 matching lines @@
     replacements->push_back(Replacement(GOOGLE_FORCE_INSTANT_RESULTS, start));
   } else if (parameter == kGoogleInstantExtendedEnabledParameter) {
     replacements->push_back(Replacement(GOOGLE_INSTANT_EXTENDED_ENABLED,
                                         start));
   } else if (parameter == kGoogleInstantExtendedEnabledKey) {
     url->insert(start, google_util::kInstantExtendedAPIParam);
   } else if (parameter == kGoogleNTPIsThemedParameter) {
     replacements->push_back(Replacement(GOOGLE_NTP_IS_THEMED, start));
   } else if (parameter == kGoogleOmniboxStartMarginParameter) {
     replacements->push_back(Replacement(GOOGLE_OMNIBOX_START_MARGIN, start));
+  } else if (parameter == kGoogleContextualSearchVersion) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_VERSION, start));
+  } else if (parameter == kGoogleContextualSearchStart) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_START, start));
+  } else if (parameter == kGoogleContextualSearchEnd) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_END, start));
+  } else if (parameter == kGoogleContextualSearchContent) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_CONTENT, start));
+  } else if (parameter == kGoogleContextualSearchBasePageURL) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_BASE_PAGE_URL, start));
+  } else if (parameter == kGoogleContextualSearchEncoding) {
+    replacements->push_back(
+        Replacement(GOOGLE_CONTEXTUAL_SEARCH_ENCODING, start));
   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
                                         start));
   } else if (parameter == kGooglePageClassificationParameter) {
     replacements->push_back(Replacement(GOOGLE_PAGE_CLASSIFICATION, start));
   } else if (parameter == kGoogleRLZParameter) {
     replacements->push_back(Replacement(GOOGLE_RLZ, start));
   } else if (parameter == kGoogleSearchClient) {
     replacements->push_back(Replacement(GOOGLE_SEARCH_CLIENT, start));
   } else if (parameter == kGoogleSearchFieldtrialParameter) {
@@ skipping 316 matching lines @@
         DCHECK(!i->is_post_param);
         if (search_terms_args.omnibox_start_margin >= 0) {
           HandleReplacement(
               "es_sm",
               base::IntToString(search_terms_args.omnibox_start_margin),
               *i,
               &url);
         }
         break;
 
+      case GOOGLE_CONTEXTUAL_SEARCH_VERSION:
+        DCHECK(!i->is_post_param);

[Peter Kasting, 2014/06/03 21:47:09]

Why are you putting this on all these cases?  It seems like there's nothing
about any of your params that will break if they're instead sent via POST, so
these DCHECKs seem wrong.

(Some of the DCHECKs elsewhere in here look wrong too, in particular the ones in
GOOGLE_CURRENT_PAGE_URL, GOOGLE_OMNIBOX_START_MARGIN,
GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION, GOOGLE_RLZ, and GOOGLE_SEARCH_CLIENT).

[jeremycho, 2014/06/04 00:22:11]

Done.  In fact, we may ultimately send this as a POST request.

On 2014/06/03 21:47:09, Peter Kasting wrote:

[Peter Kasting, 2014/06/04 00:40:49]

Unfortunately, you changed several of these to only replacing the value here,
and listing the param name inside the URL in prepopulated_engines.json.  That's
not compatible with having these be POST params, and you need to restore the
DCHECKs on anything where you call HandleReplacement() with std::string() as the
first arg.

If you really want to support POST for all this stuff, you need to restore the
previous code, or better yet use my suggestion that you simply have a single
replacement string that inserts the value of almost all these.  Then it can be
coded here as a set of several sequential HandleReplacement() calls, saving code
as well as not exploding the replacement type enum quite as much.

[jeremycho, 2014/06/04 03:33:04]

Not sure I follow how the single replacement string would work.  Using
HandleReplacement on each post parameter requires them to have indices into
post_params_.  So don't these still need to be added to the big else if block in
TemplateURLRef::ParseParameter?

On 2014/06/04 00:40:49, Peter Kasting wrote:

[Peter Kasting, 2014/06/04 06:56:21]

Frankly, I don't know.  I didn't write any of the POST stuff and AFAIK it
doesn't really work right anyway.  Certainly jnd@ (who wrote it) never bothered
to get it working properly for anything other than some of the image stuff he
was trying to implement.  Now that I'm staring at it again, I'm becoming less
and less certain that I actually understand how any of it works.  You wouldn't
know I reviewed all this once upon a time...

It looks from inspection like you'd first have to add a contextual search case
to GetPostParamsString(), then probably modify ParseURL() a bit to understand
how to handle this kind of thing.

What I would do for now is probably drop the idea of POST entirely (get GET
working first), and aim for the simplest possible code.  IMO having one
replacement param instead of n is simpler, but if you really want to do it the
other way, I don't care too much.  I am no longer certain whether or not the
DCHECKs about things not being post params are correct.

+        if (search_terms_args.contextual_search_version >= 0) {
+          HandleReplacement(
+              "ctxs",
+              base::IntToString(search_terms_args.contextual_search_version),
+              *i,
+              &url);
+        }
+        break;
+
+      case GOOGLE_CONTEXTUAL_SEARCH_START:
+        DCHECK(!i->is_post_param);
+        if (search_terms_args.contextual_search_start >= 0) {
+          HandleReplacement(
+              "ctxs_start",
+              base::IntToString(search_terms_args.contextual_search_start),
+              *i,
+              &url);
+        }
+        break;
+
+      case GOOGLE_CONTEXTUAL_SEARCH_END:
+        DCHECK(!i->is_post_param);
+        if (search_terms_args.contextual_search_end >= 0) {
+          HandleReplacement(
+              "ctxs_end",
+              base::IntToString(search_terms_args.contextual_search_end),
+              *i,
+              &url);
+        }
+        break;
+
+      case GOOGLE_CONTEXTUAL_SEARCH_CONTENT: {
+        DCHECK(!i->is_post_param);
+        const std::string content = search_terms_args.contextual_search_content;
+        if (!content.empty())
+          HandleReplacement("ctxs_content", content, *i, &url);
+        break;
+      }
+
+      case GOOGLE_CONTEXTUAL_SEARCH_BASE_PAGE_URL: {
+        DCHECK(!i->is_post_param);
+        const std::string base_page_url =
+            search_terms_args.contextual_search_base_page_url;
+        if (!base_page_url.empty())
+          HandleReplacement("ctxs_url", base_page_url, *i, &url);
+        break;
+      }
+
+      case GOOGLE_CONTEXTUAL_SEARCH_ENCODING: {
+        DCHECK(!i->is_post_param);
+        const std::string encoding =
+            search_terms_args.contextual_search_encoding;
+        if (!encoding.empty())
+          HandleReplacement("ctxs_encoding", encoding, *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);
         }
         break;
 
       case GOOGLE_PAGE_CLASSIFICATION:
@@ skipping 151 matching lines @@
 
 TemplateURL::TemplateURL(Profile* profile, const TemplateURLData& data)
     : profile_(profile),
       data_(data),
       url_ref_(this, TemplateURLRef::SEARCH),
       suggestions_url_ref_(this,
                            TemplateURLRef::SUGGEST),
       instant_url_ref_(this,
                        TemplateURLRef::INSTANT),
       image_url_ref_(this, TemplateURLRef::IMAGE),
-      new_tab_url_ref_(this, TemplateURLRef::NEW_TAB) {
+      new_tab_url_ref_(this, TemplateURLRef::NEW_TAB),
+      contextual_search_url_ref_(this, TemplateURLRef::CONTEXTUAL_SEARCH) {
   SetPrepopulateId(data_.prepopulate_id);
 
   if (data_.search_terms_replacement_key ==
       kGoogleInstantExtendedEnabledKeyFull) {
     data_.search_terms_replacement_key = google_util::kInstantExtendedAPIParam;
   }
 }
 
 TemplateURL::~TemplateURL() {
 }
@@ skipping 267 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;
 }