Add a URL param to indicate group selection in Instant field trial.

chrome/browser/search_engines/template_url.cc

 // Copyright (c) 2011 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/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
 static const char kGoogleAcceptedSuggestionParameter[] =
     "google:acceptedSuggestion";
 // Host/Domain Google searches are relative to.
 static const char kGoogleBaseURLParameter[] = "google:baseURL";
 static const char kGoogleBaseURLParameterFull[] = "{google:baseURL}";
 // Like google:baseURL, but for the Search Suggest capability.
 static const char kGoogleBaseSuggestURLParameter[] =
     "google:baseSuggestURL";
 static const char kGoogleBaseSuggestURLParameterFull[] =
     "{google:baseSuggestURL}";
+static const char kGoogleInstantFieldTrialGroupParameter[] =
+    "google:instantFieldTrialGroupParameter";
 static const char kGoogleOriginalQueryForSuggestionParameter[] =
     "google:originalQueryForSuggestion";
 static const char kGoogleRLZParameter[] = "google:RLZ";
 // Same as kSearchTermsParameter, with no escaping.
 static const char kGoogleSearchFieldtrialParameter[] =
     "google:searchFieldtrialParameter";
 static const char kGoogleUnescapedSearchTermsParameter[] =
     "google:unescapedSearchTerms";
 static const char kGoogleUnescapedSearchTermsParameterFull[] =
     "{google:unescapedSearchTerms}";
@@ skipping 74 matching lines @@
     replacements->push_back(Replacement(ENCODING, start));
   } else if (parameter == kOutputEncodingParameter) {
     if (!optional)
       url->insert(start, kOutputEncodingType);
   } else if (parameter == kGoogleAcceptedSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ACCEPTED_SUGGESTION, 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 == kGoogleInstantFieldTrialGroupParameter) {
+    replacements->push_back(Replacement(GOOGLE_INSTANT_FIELD_TRIAL_GROUP,
+                                        start));
   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
                                         start));
   } else if (parameter == kGoogleRLZParameter) {
     replacements->push_back(Replacement(GOOGLE_RLZ, start));
   } else if (parameter == kGoogleSearchFieldtrialParameter) {
     replacements->push_back(Replacement(GOOGLE_SEARCH_FIELDTRIAL_GROUP, start));
   } else if (parameter == kGoogleUnescapedSearchTermsParameter) {
     replacements->push_back(Replacement(GOOGLE_UNESCAPED_SEARCH_TERMS, start));
   } else {
@@ skipping 35 matching lines @@
         // Open brace without a closing brace, return.
         return std::string();
       }
     }
   }
   *valid = true;
   return parsed_url;
 }
 
 void TemplateURLRef::ParseIfNecessary() const {
-  UIThreadSearchTermsData search_terms_data;
+  UIThreadSearchTermsData search_terms_data(NULL);
   ParseIfNecessaryUsingTermsData(search_terms_data);
 }
 
 void TemplateURLRef::ParseIfNecessaryUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   if (!parsed_) {
     parsed_ = true;
     parsed_url_ = ParseURL(url_, &replacements_, &valid_);
     supports_replacements_ = false;
     if (valid_) {
@@ skipping 54 matching lines @@
     }
   }
 }
 
 // static
 void TemplateURLRef::SetGoogleBaseURL(std::string* google_base_url) {
   UIThreadSearchTermsData::SetGoogleBaseURL(google_base_url);
 }
 
 std::string TemplateURLRef::ReplaceSearchTerms(
+    Profile* profile,
     const TemplateURL& host,
     const string16& terms,
     int accepted_suggestion,
     const string16& original_query_for_suggestion) const {
-  UIThreadSearchTermsData search_terms_data;
+  UIThreadSearchTermsData search_terms_data(profile);
   return ReplaceSearchTermsUsingTermsData(host,
                                           terms,
                                           accepted_suggestion,
                                           original_query_for_suggestion,
                                           search_terms_data);
 }
 
 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData(
     const TemplateURL& host,
     const string16& terms,
@@ skipping 74 matching lines @@
         break;
 
       case GOOGLE_BASE_URL:
         url.insert(i->index, search_terms_data.GoogleBaseURLValue());
         break;
 
       case GOOGLE_BASE_SUGGEST_URL:
         url.insert(i->index, search_terms_data.GoogleBaseSuggestURLValue());
         break;
 
+      case GOOGLE_INSTANT_FIELD_TRIAL_GROUP:
+        url.insert(i->index, search_terms_data.InstantFieldTrialUrlParam());
+        break;
+
       case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
         if (accepted_suggestion >= 0)
           url.insert(i->index, "oq=" + UTF16ToUTF8(encoded_original_query) +
                                "&");
         break;
 
       case GOOGLE_RLZ: {
         // On platforms that don't have RLZ, we still want this branch
         // to happen so that we replace the RLZ template with the
         // empty string.  (If we don't handle this case, we hit a
@@ skipping 40 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
 
   return url;
 }
 
 bool TemplateURLRef::SupportsReplacement() const {
-  UIThreadSearchTermsData search_terms_data;
+  UIThreadSearchTermsData search_terms_data(NULL);
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_ && supports_replacements_;
 }
 
 bool TemplateURLRef::IsValid() const {
-  UIThreadSearchTermsData search_terms_data;
+  UIThreadSearchTermsData search_terms_data(NULL);
   return IsValidUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::IsValidUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_;
 }
 
 string16 TemplateURLRef::DisplayURL() const {
@@ skipping 128 matching lines @@
   rep.SetPath(favicon_path, url_parse::Component(0, favicon_path_len));
   rep.ClearUsername();
   rep.ClearPassword();
   rep.ClearQuery();
   rep.ClearRef();
   return url.ReplaceComponents(rep);
 }
 
 // static
 bool TemplateURL::SupportsReplacement(const TemplateURL* turl) {
-  UIThreadSearchTermsData search_terms_data;
+  UIThreadSearchTermsData search_terms_data(NULL);
   return SupportsReplacementUsingTermsData(turl, search_terms_data);
 }
 
 // static
 bool TemplateURL::SupportsReplacementUsingTermsData(
     const TemplateURL* turl,
     const SearchTermsData& search_terms_data) {
   return turl && turl->url() &&
       turl->url()->SupportsReplacementUsingTermsData(search_terms_data);
 }
@@ skipping 49 matching lines @@
 
 string16 TemplateURL::keyword() const {
   EnsureKeyword();
   return keyword_;
 }
 
 void TemplateURL::EnsureKeyword() const {
   if (autogenerate_keyword_ && !keyword_generated_) {
     // Generate a keyword and cache it.
     keyword_ = TemplateURLService::GenerateKeyword(
-        TemplateURLService::GenerateSearchURL(this).GetWithEmptyPath(), true);
+        TemplateURLService::GenerateSearchURL(this, NULL).GetWithEmptyPath(),
+        true);
     keyword_generated_ = true;
   }
 }
 
 bool TemplateURL::ShowInDefaultList() const {
   return show_in_default_list() && url() && url()->SupportsReplacement();
 }
 
 void TemplateURL::SetFaviconURL(const GURL& url) {
   for (std::vector<ImageRef>::iterator i = image_refs_.begin();
@@ skipping 50 matching lines @@
 }
 
 std::string TemplateURL::GetExtensionId() const {
   DCHECK(IsExtensionKeyword());
   return GURL(url_.url()).host();
 }
 
 bool TemplateURL::IsExtensionKeyword() const {
   return GURL(url_.url()).SchemeIs(chrome::kExtensionScheme);
 }