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"
 #include "base/metrics/field_trial.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/instant/instant_field_trial.h"
 #include "chrome/browser/search_engines/search_engine_type.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/browser/user_metrics.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/favicon_size.h"
 // TODO(pastarmovj): Remove google_update_settings and user_metrics when the
@@ skipping 30 matching lines @@
 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}";
+static const char kInstantFieldTrialGroupParameter[] =
+    "instantFieldTrialGroupParameter";

[sky, 2011/08/08 23:37:23]

Since this is google specific, use google:

[sreeram, 2011/08/09 16:24:01]

Done. Will reflect it in the next patch.

 
 // Display value for kSearchTermsParameter.
 static const char kDisplaySearchTerms[] = "%s";
 
 // Display value for kGoogleUnescapedSearchTermsParameter.
 static const char kDisplayUnescapedSearchTerms[] = "%S";
 
 // Used if the count parameter is not optional. Indicates we want 10 search
 // results.
 static const char kDefaultCount[] = "10";
@@ skipping 73 matching lines @@
     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, 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 if (parameter == kInstantFieldTrialGroupParameter) {
+    replacements->push_back(Replacement(INSTANT_FIELD_TRIAL_GROUP, start));
   } else {
     // If it's a prepopulated URL, we know that it's safe to remove unknown
     // parameters. Otherwise it could be some garbage but can also be a
     // javascript block. Put it back.
     if (!prepopulated_)
       url->insert(start, full_parameter);
     return false;
   }
   return true;
 }
@@ skipping 101 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;
-  return ReplaceSearchTermsUsingTermsData(host,
+  return ReplaceSearchTermsUsingTermsData(profile,
+                                          host,
                                           terms,
                                           accepted_suggestion,
                                           original_query_for_suggestion,
                                           search_terms_data);
 }
 
 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData(
+    Profile* profile,
     const TemplateURL& host,
     const string16& terms,
     int accepted_suggestion,
     const string16& original_query_for_suggestion,
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   if (!valid_)
     return std::string();
 
   if (replacements_.empty())
@@ skipping 108 matching lines @@
       case GOOGLE_UNESCAPED_SEARCH_TERMS: {
         std::string unescaped_terms;
         base::UTF16ToCodepage(terms, input_encoding.c_str(),
                               base::OnStringConversionError::SKIP,
                               &unescaped_terms);
         url.insert(i->index, std::string(unescaped_terms.begin(),
                                          unescaped_terms.end()));
         break;
       }
 
+      case INSTANT_FIELD_TRIAL_GROUP:
+        if (profile != NULL)
+          url.insert(i->index, InstantFieldTrial::GetGroupAsUrlParam(profile));
+        break;
+
       case LANGUAGE:
         url.insert(i->index, search_terms_data.GetApplicationLocale());
         break;
 
       case SEARCH_TERMS:
         url.insert(i->index, UTF16ToUTF8(encoded_terms));
         break;
 
       default:
         NOTREACHED();
@@ skipping 228 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(NULL, this).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);
 }