Replace --google-base-suggest-url and --instant-url with --google-base-url.

chrome/browser/autocomplete/keyword_provider_unittest.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 "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class KeywordProviderTest : public testing::Test {
  protected:
   template<class ResultType>
   struct test_data {
     const string16 input;
     const size_t num_results;
     const ResultType output[3];
   };
 
   KeywordProviderTest() : kw_provider_(NULL) { }
   virtual ~KeywordProviderTest() { }
 
   virtual void SetUp();
   virtual void TearDown();
 
   template<class ResultType>
   void RunTest(test_data<ResultType>* keyword_cases,
                int num_cases,
                ResultType AutocompleteMatch::* member);
 
  protected:
+  static const TemplateURLService::Initializer kTestData[];
+
   scoped_refptr<KeywordProvider> kw_provider_;
   scoped_ptr<TemplateURLService> model_;
 };
 
+// static
+const TemplateURLService::Initializer KeywordProviderTest::kTestData[] = {
+  { "aa", "aa.com?foo=%s", "aa" },
+  { "aaaa", "http://aaaa/?aaaa=1&b=%s&c", "aaaa" },
+  { "aaaaa", "%s", "aaaaa" },
+  { "ab", "bogus URL %s", "ab" },
+  { "weasel", "weasel%sweasel", "weasel" },
+  { "www", " +%2B?=%sfoo ", "www" },
+  { "z", "%s=z", "z" },
+};
+
 void KeywordProviderTest::SetUp() {
-  static const TemplateURLService::Initializer kTestKeywordData[] = {
-    { "aa", "aa.com?foo=%s", "aa" },
-    { "aaaa", "http://aaaa/?aaaa=1&b=%s&c", "aaaa" },
-    { "aaaaa", "%s", "aaaaa" },
-    { "ab", "bogus URL %s", "ab" },
-    { "weasel", "weasel%sweasel", "weasel" },
-    { "www", " +%2B?=%sfoo ", "www" },
-    { "z", "%s=z", "z" },
-  };
-
-  model_.reset(new TemplateURLService(kTestKeywordData,
-                                    arraysize(kTestKeywordData)));
+  model_.reset(new TemplateURLService(kTestData, arraysize(kTestData)));
   kw_provider_ = new KeywordProvider(NULL, model_.get());
 }
 
 void KeywordProviderTest::TearDown() {
   model_.reset();
   kw_provider_ = NULL;
 }
 
 template<class ResultType>
 void KeywordProviderTest::RunTest(
@@ skipping 64 matching lines @@
     {ASCIIToUTF16("https://z"),       1, {ASCIIToUTF16("z ")}},
   };
 
   RunTest<string16>(edit_cases, arraysize(edit_cases),
                     &AutocompleteMatch::fill_into_edit);
 }
 
 TEST_F(KeywordProviderTest, URL) {
   test_data<GURL> url_cases[] = {
     // No query input -> empty destination URL.
-    {ASCIIToUTF16("z"),               1, {GURL()}},
-    {ASCIIToUTF16("z    \t"),         1, {GURL()}},
+    {ASCIIToUTF16("z"),           1, {GURL()}},
+    {ASCIIToUTF16("z    \t"),     1, {GURL()}},
 
     // Check that tokenization only collapses whitespace between first tokens
     // and query input, but not rest of URL, is escaped.
-    {ASCIIToUTF16("w  bar +baz"),     2, {GURL(" +%2B?=bar+%2Bbazfoo "),
-                                          GURL("bar+%2Bbaz=z")}},
+    {ASCIIToUTF16("w  bar +baz"), 2, {GURL(" +%2B?=bar+%2Bbazfoo "),
+                                      GURL("bar+%2Bbaz=z")}},
 
     // Substitution should work with various locations of the "%s".
-    {ASCIIToUTF16("aaa 1a2b"),        2, {GURL("http://aaaa/?aaaa=1&b=1a2b&c"),
-                                          GURL("1a2b")}},
-    {ASCIIToUTF16("a 1 2 3"),         3, {GURL("aa.com?foo=1+2+3"),
-                                          GURL("bogus URL 1+2+3"),
-                                        GURL("http://aaaa/?aaaa=1&b=1+2+3&c")}},
-    {ASCIIToUTF16("www.w w"),         2, {GURL(" +%2B?=wfoo "),
-                                          GURL("weaselwweasel")}},
+    {ASCIIToUTF16("aaa 1a2b"),    2, {GURL("http://aaaa/?aaaa=1&b=1a2b&c"),
+                                      GURL("1a2b")}},
+    {ASCIIToUTF16("a 1 2 3"),     3, {GURL("aa.com?foo=1+2+3"),
+                                      GURL("bogus URL 1+2+3"),
+                                      GURL("http://aaaa/?aaaa=1&b=1+2+3&c")}},
+    {ASCIIToUTF16("www.w w"),     2, {GURL(" +%2B?=wfoo "),
+                                      GURL("weaselwweasel")}},
   };
 
   RunTest<GURL>(url_cases, arraysize(url_cases),
                 &AutocompleteMatch::destination_url);
 }
 
 TEST_F(KeywordProviderTest, Contents) {
   test_data<string16> contents_cases[] = {
     // No query input -> substitute "<enter query>" into contents.
     {ASCIIToUTF16("z"),               1,
@@ skipping 19 matching lines @@
          ASCIIToUTF16("Search weasel for w")}},
     // Also, check that tokenization only collapses whitespace between first
     // tokens and contents are not escaped or unescaped.
     {ASCIIToUTF16("a   1 2+ 3"),      3,
         {ASCIIToUTF16("Search aa for 1 2+ 3"),
          ASCIIToUTF16("Search ab for 1 2+ 3"),
          ASCIIToUTF16("Search aaaa for 1 2+ 3")}},
   };
 
   RunTest<string16>(contents_cases, arraysize(contents_cases),
-                        &AutocompleteMatch::contents);
-}
-
-TEST_F(KeywordProviderTest, DISABLED_Description) {
-  test_data<string16> description_cases[] = {
-    // Whole keyword should be returned for both exact and inexact matches.
-    {ASCIIToUTF16("z foo"),           1, {ASCIIToUTF16("(Keyword: z)")}},
-    {ASCIIToUTF16("a foo"),           3, {ASCIIToUTF16("(Keyword: aa)"),
-                                          ASCIIToUTF16("(Keyword: ab)"),
-                                          ASCIIToUTF16("(Keyword: aaaa)")}},
-    {ASCIIToUTF16("ftp://www.www w"), 0, {}},
-    {ASCIIToUTF16("http://www.ab w"), 1, {ASCIIToUTF16("(Keyword: ab)")}},
-
-    // Keyword should be returned regardless of query input.
-    {ASCIIToUTF16("z"),               1, {ASCIIToUTF16("(Keyword: z)")}},
-    {ASCIIToUTF16("z    \t"),         1, {ASCIIToUTF16("(Keyword: z)")}},
-    {ASCIIToUTF16("z   a   b   c++"), 1, {ASCIIToUTF16("(Keyword: z)")}},
-  };
-
-  RunTest<string16>(description_cases, arraysize(description_cases),
-                        &AutocompleteMatch::description);
+                    &AutocompleteMatch::contents);
 }
 
 TEST_F(KeywordProviderTest, AddKeyword) {
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("Test");
   string16 keyword(ASCIIToUTF16("foo"));
   data.SetKeyword(keyword);
   data.SetURL("http://www.google.com/foo?q={searchTerms}");
   TemplateURL* template_url = new TemplateURL(NULL, data);
   model_->Add(template_url);
@@ skipping 64 matching lines @@
         KeywordProvider::GetSubstitutingTemplateURLForInput(model_.get(),
                                                             &input);
     if (cases[i].expected_url.empty())
       EXPECT_FALSE(url);
     else
       EXPECT_EQ(cases[i].expected_url, url->url());
     EXPECT_EQ(ASCIIToUTF16(cases[i].updated_text), input.text());
     EXPECT_EQ(cases[i].updated_cursor_position, input.cursor_position());
   }
 }
+
+// If extra query params are specified on the command line, they should be
+// reflected (only) in the default search provider's destination URL.
+TEST_F(KeywordProviderTest, ExtraQueryParams) {
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kExtraSearchQueryParams, "a=b");
+
+  test_data<GURL> url_cases[] = {
+    {ASCIIToUTF16("a 1 2 3"), 3, {GURL("aa.com?a=b&foo=1+2+3"),
+                                  GURL("bogus URL 1+2+3"),
+                                  GURL("http://aaaa/?aaaa=1&b=1+2+3&c")}},
+  };
+
+  RunTest<GURL>(url_cases, arraysize(url_cases),
+                &AutocompleteMatch::destination_url);
+}