Add contextual search to the template url system

chrome/browser/search_engines/template_url.cc

Index: chrome/browser/search_engines/template_url.cc
diff --git a/chrome/browser/search_engines/template_url.cc b/chrome/browser/search_engines/template_url.cc
index 96c68ebed9c6d9561e0e23fb7684f2108ae902a6..9ef48a752d72e91fff2c17ff8ce790712dac44f6 100644
--- a/chrome/browser/search_engines/template_url.cc
+++ b/chrome/browser/search_engines/template_url.cc
@@ -103,6 +103,16 @@ 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";
 
@@ -205,6 +215,9 @@ TemplateURLRef::SearchTermsArgs::SearchTermsArgs(
       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),
@@ -251,24 +264,26 @@ 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
   }
 }
@@ -592,6 +607,24 @@ bool TemplateURLRef::ParseParameter(size_t start,
     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));
@@ -928,6 +961,65 @@ std::string TemplateURLRef::HandleReplacements(
         }
         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 ||
@@ -1099,7 +1191,8 @@ TemplateURL::TemplateURL(Profile* profile, const TemplateURLData& data)
       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 ==