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

chrome/browser/importer/profile_writer.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/importer/profile_writer.h"
 
 #include <string>
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 223 matching lines @@
 // HostPathMap.
 //
 // If |try_url_if_invalid| is true, and |t_url| isn't valid, a string is built
 // from the raw TemplateURL string. Use a value of true for |try_url_if_invalid|
 // when checking imported URLs as the imported URL may not be valid yet may
 // match the host+path of one of the default URLs. This is used to catch the
 // case of IE using an invalid OSDD URL for Live Search, yet the host+path
 // matches our prepopulate data. IE's URL for Live Search is something like
 // 'http://...{Language}...'. As {Language} is not a valid OSDD parameter value
 // the TemplateURL is invalid.
-static std::string BuildHostPathKey(const TemplateURL* t_url,
+static std::string BuildHostPathKey(Profile* profile,
+                                    const TemplateURL* t_url,
                                     bool try_url_if_invalid) {
   if (t_url->url()) {
     if (try_url_if_invalid && !t_url->url()->IsValid())
       return HostPathKeyForURL(GURL(t_url->url()->url()));
 
     if (t_url->url()->SupportsReplacement()) {
       return HostPathKeyForURL(GURL(
           t_url->url()->ReplaceSearchTerms(
-          *t_url, ASCIIToUTF16("random string"),
+          profile, *t_url, ASCIIToUTF16("random string"),

[Peter Kasting, 2011/08/11 00:35:17]

HostPathKeyForURL() strips the query params so this spot can pass NULL as well.

           TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())));
     }
   }
   return std::string();
 }
 
 // Builds a set that contains an entry of the host+path for each TemplateURL in
 // the TemplateURLService that has a valid search url.
-static void BuildHostPathMap(const TemplateURLService& model,
+static void BuildHostPathMap(Profile* profile,
+                             const TemplateURLService& model,
                              HostPathMap* host_path_map) {
   std::vector<const TemplateURL*> template_urls = model.GetTemplateURLs();
   for (size_t i = 0; i < template_urls.size(); ++i) {
-    const std::string host_path = BuildHostPathKey(template_urls[i], false);
+    const std::string host_path = BuildHostPathKey(profile, template_urls[i],
+                                                   false);
     if (!host_path.empty()) {
       const TemplateURL* existing_turl = (*host_path_map)[host_path];
       if (!existing_turl ||
           (template_urls[i]->show_in_default_list() &&
            !existing_turl->show_in_default_list())) {
         // If there are multiple TemplateURLs with the same host+path, favor
         // those shown in the default list.  If there are multiple potential
         // defaults, favor the first one, which should be the more commonly used
         // one.
         (*host_path_map)[host_path] = template_urls[i];
       }
     }  // else case, TemplateURL doesn't have a search url, doesn't support
        // replacement, or doesn't have valid GURL. Ignore it.
   }
 }
 
 void ProfileWriter::AddKeywords(const std::vector<TemplateURL*>& template_urls,
                                 int default_keyword_index,
                                 bool unique_on_host_and_path) {
   TemplateURLService* model =
       TemplateURLServiceFactory::GetForProfile(profile_);
   HostPathMap host_path_map;
   if (unique_on_host_and_path)
-    BuildHostPathMap(*model, &host_path_map);
+    BuildHostPathMap(profile_, *model, &host_path_map);
 
   for (std::vector<TemplateURL*>::const_iterator i = template_urls.begin();
        i != template_urls.end(); ++i) {
     TemplateURL* t_url = *i;
     bool default_keyword =
         default_keyword_index >= 0 &&
         (i - template_urls.begin() == default_keyword_index);
 
     // TemplateURLService requires keywords to be unique. If there is already a
     // TemplateURL with this keyword, don't import it again.
     const TemplateURL* turl_with_keyword =
         model->GetTemplateURLForKeyword(t_url->keyword());
     if (turl_with_keyword != NULL) {
       if (default_keyword)
         model->SetDefaultSearchProvider(turl_with_keyword);
       delete t_url;
       continue;
     }
 
     // For search engines if there is already a keyword with the same
     // host+path, we don't import it. This is done to avoid both duplicate
     // search providers (such as two Googles, or two Yahoos) as well as making
     // sure the search engines we provide aren't replaced by those from the
     // imported browser.
     if (unique_on_host_and_path &&
         host_path_map.find(
-            BuildHostPathKey(t_url, true)) != host_path_map.end()) {
+            BuildHostPathKey(profile_, t_url, true)) != host_path_map.end()) {
       if (default_keyword) {
         const TemplateURL* turl_with_host_path =
-            host_path_map[BuildHostPathKey(t_url, true)];
+            host_path_map[BuildHostPathKey(profile_, t_url, true)];
         if (turl_with_host_path)
           model->SetDefaultSearchProvider(turl_with_host_path);
         else
           NOTREACHED();  // BuildHostPathMap should only insert non-null values.
       }
       delete t_url;
       continue;
     }
     if (t_url->url() && t_url->url()->IsValid()) {
       model->Add(t_url);
       if (default_keyword && TemplateURL::SupportsReplacement(t_url))
         model->SetDefaultSearchProvider(t_url);
     } else {
       // Don't add invalid TemplateURLs to the model.
       delete t_url;
     }
   }
 }
 
 ProfileWriter::~ProfileWriter() {}