Remove Profile* from TemplateURL

chrome/browser/search_engines/template_url_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/base_paths.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
@@ skipping 62 matching lines @@
 TEST_F(TemplateURLTest, Defaults) {
   TemplateURLData data;
   EXPECT_FALSE(data.show_in_default_list);
   EXPECT_FALSE(data.safe_for_autoreplace);
   EXPECT_EQ(0, data.prepopulate_id);
 }
 
 TEST_F(TemplateURLTest, TestValidWithComplete) {
   TemplateURLData data;
   data.SetURL("{searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 }
 
 TEST_F(TemplateURLTest, URLRefTestSearchTerms) {
   struct SearchTermsCase {
     const char* url;
     const base::string16 terms;
     const std::string output;
   } search_term_cases[] = {
     { "http://foo{searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch/bar" },
     { "http://foo{searchTerms}?boo=abc", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch/bar?boo=abc" },
     { "http://foo/?boo={searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foo/?boo=sea+rch%2Fbar" },
     { "http://en.wikipedia.org/{searchTerms}", ASCIIToUTF16("wiki/?"),
       "http://en.wikipedia.org/wiki/%3F" }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     TemplateURLData data;
     data.SetURL(value.url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}{count?}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://foox/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}{count}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://foox10/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{startIndex?}y{startPage?}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxy/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{startIndex}y{startPage}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxx1y1/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxutf-8ya/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestImageURLWithPOST) {
   const char kInvalidPostParamsString[] =
       "unknown_template={UnknownTemplate},bad_value=bad{value},"
       "{google:sbiSource}";
   // List all accpectable parameter format in valid_post_params_string. it is
   // expected like: "name0=,name1=value1,name2={template1}"
   const char kValidPostParamsString[] =
       "image_content={google:imageThumbnail},image_url={google:imageURL},"
       "sbisrc={google:imageSearchSource},language={language},empty_param=,"
       "constant_param=constant,width={google:imageOriginalWidth}";
   const char KImageSearchURL[] = "http://foo.com/sbi";
 
   TemplateURLData data;
   data.image_url = KImageSearchURL;
 
   // Try to parse invalid post parameters.
   data.image_url_post_params = kInvalidPostParamsString;
-  TemplateURL url_bad(NULL, data);
+  TemplateURL url_bad(data);
   ASSERT_FALSE(url_bad.image_url_ref().IsValid(search_terms_data_));
   const TemplateURLRef::PostParams& bad_post_params =
       url_bad.image_url_ref().post_params_;
   ASSERT_EQ(2U, bad_post_params.size());
   EXPECT_EQ("unknown_template", bad_post_params[0].first);
   EXPECT_EQ("{UnknownTemplate}", bad_post_params[0].second);
   EXPECT_EQ("bad_value", bad_post_params[1].first);
   EXPECT_EQ("bad{value}", bad_post_params[1].second);
 
   // Try to parse valid post parameters.
   data.image_url_post_params = kValidPostParamsString;
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   ASSERT_TRUE(url.image_url_ref().IsValid(search_terms_data_));
   ASSERT_FALSE(url.image_url_ref().SupportsReplacement(search_terms_data_));
 
   // Check term replacement.
   TemplateURLRef::SearchTermsArgs search_args(ASCIIToUTF16("X"));
   search_args.image_thumbnail_content = "dummy-image-thumbnail";
   search_args.image_url = GURL("http://dummyimage.com/dummy.jpg");
   search_args.image_original_size = gfx::Size(10, 10);
   // Replacement operation with no post_data buffer should still return
   // the parsed URL.
@@ skipping 58 matching lines @@
       EXPECT_EQ("constant", i->second);
     }
   }
 }
 
 // Test that setting the prepopulate ID from TemplateURL causes the stored
 // TemplateURLRef to handle parsing the URL parameters differently.
 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
   TemplateURLData data;
   data.SetURL("http://foo{fhqwhgads}bar");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("http://foo{fhqwhgads}bar", url.url_ref().ParseURL(
       "http://foo{fhqwhgads}bar", &replacements, NULL, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 
   data.prepopulate_id = 123;
-  TemplateURL url2(NULL, data);
+  TemplateURL url2(data);
   EXPECT_EQ("http://foobar", url2.url_ref().ParseURL("http://foo{fhqwhgads}bar",
                                                      &replacements, NULL,
                                                      &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
   TemplateURLData data;
   data.SetURL("http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxutf-8axyb/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxutf-8yutf-8a/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestSearchTermsUsingTermsData) {
   struct SearchTermsCase {
     const char* url;
     const base::string16 terms;
     const char* output;
   } search_term_cases[] = {
     { "{google:baseURL}{language}{searchTerms}", base::string16(),
       "http://example.com/e/en" },
     { "{google:baseSuggestURL}{searchTerms}", base::string16(),
       "http://example.com/complete/" }
   };
 
   TestSearchTermsData search_terms_data("http://example.com/e/");
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     data.SetURL(value.url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data, NULL));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTermToWide) {
@@ skipping 14 matching lines @@
     // Make sure we convert %2B to +.
     {"C%2B%2B", ASCIIToUTF16("C++")},
     // C%2B is escaped as C%252B, make sure we unescape it properly.
     {"C%252B", ASCIIToUTF16("C%2B")},
   };
 
   // Set one input encoding: big-5. This is so we can test fallback to UTF-8.
   TemplateURLData data;
   data.SetURL("http://foo?q={searchTerms}");
   data.input_encodings.push_back("big-5");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(to_wide_cases); i++) {
     EXPECT_EQ(to_wide_cases[i].expected_decoded_term,
               url.url_ref().SearchTermToString16(
                   to_wide_cases[i].encoded_search_term));
   }
 }
 
 TEST_F(TemplateURLTest, DisplayURLToURLRef) {
   struct TestData {
     const std::string url;
     const base::string16 expected_result;
   } test_data[] = {
     { "http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a",
       ASCIIToUTF16("http://foo%sx{inputEncoding}y{outputEncoding}a") },
     { "http://X",
       ASCIIToUTF16("http://X") },
     { "http://foo{searchTerms",
       ASCIIToUTF16("http://foo{searchTerms") },
     { "http://foo{searchTerms}{language}",
       ASCIIToUTF16("http://foo%s{language}") },
   };
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_EQ(test_data[i].expected_result,
               url.url_ref().DisplayURL(search_terms_data_));
     EXPECT_EQ(test_data[i].url,
               TemplateURLRef::DisplayURLToURLRef(
                   url.url_ref().DisplayURL(search_terms_data_)));
   }
 }
 
 TEST_F(TemplateURLTest, ReplaceSearchTerms) {
   struct TestData {
@@ skipping 22 matching lines @@
       "http://foo/XaUTF-8a{language}a" },
     { "http://foo/{inputEncoding}a{searchTerms}a{language}a",
       "http://foo/UTF-8aXa{language}a" },
     { "http://foo/{inputEncoding}a{language}a{searchTerms}a",
       "http://foo/UTF-8a{language}aXa" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     std::string expected_result = test_data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
         g_browser_process->GetApplicationLocale());
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")),
         search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(expected_result, result.spec());
@@ skipping 21 matching lines @@
       "http://foo/%82%A0/bar"},
     { "Shift_JIS", base::UTF8ToUTF16("\xe3\x81\x82 \xe3\x81\x84"),
       "http://foo/{searchTerms}/bar",
       "http://foo/%82%A0%20%82%A2/bar"},
   };
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
     data.input_encodings.clear();
     data.input_encodings.push_back(test_data[i].encoding);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(test_data[i].search_term),
         search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
@@ skipping 34 matching lines @@
     { ASCIIToUTF16("foo"),
       "chrome.0.0l6",
       "",
       "https://foo?{searchTerms}{google:assistedQueryStats}",
       "https://foo/?fooaqs=chrome.0.0l6&" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.assisted_query_stats = test_data[i].aqs;
     UIThreadSearchTermsData::SetGoogleBaseURL(test_data[i].base_url);
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
@@ skipping 18 matching lines @@
     { ASCIIToUTF16("foo"),
       15,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&cp=15&" },
   };
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.cursor_position = test_data[i].cursor_position;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
@@ skipping 17 matching lines @@
     { ASCIIToUTF16("foo"),
       metrics::OmniboxInputType::FORCED_QUERY,
       "{google:baseURL}?{searchTerms}&{google:inputType}",
       "http://www.google.com/?foo&oit=5&" },
   };
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.input_type = test_data[i].input_type;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
@@ skipping 17 matching lines @@
     { ASCIIToUTF16("foo"),
       "http://g.com/+-/*&=",
       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
       "http://www.google.com/?foo&url=http%3A%2F%2Fg.com%2F%2B-%2F*%26%3D&" },
   };
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.current_page_url = test_data[i].current_page_url;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
@@ skipping 12 matching lines @@
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTION_CHOSEN, ASCIIToUTF16("foo"),
       "http://bar/foo?q=foobar" },
     { 0, base::string16(), "http://bar/foo?oq=&q=foobar" },
     { 1, ASCIIToUTF16("foo"), "http://bar/foo?oq=foo&q=foobar" },
   };
   TemplateURLData data;
   data.SetURL("http://bar/foo?{google:originalQueryForSuggestion}"
               "q={searchTerms}");
   data.input_encodings.push_back("UTF-8");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     TemplateURLRef::SearchTermsArgs search_terms_args(
         ASCIIToUTF16("foobar"));
     search_terms_args.accepted_suggestion = test_data[i].accepted_suggestion;
     search_terms_args.original_query =
         test_data[i].original_query_for_suggestion;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
@@ skipping 11 matching lines @@
     RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz_string);
   }
 #elif defined(OS_ANDROID)
   SearchTermsDataAndroid::rlz_parameter_value_.Get() =
       ASCIIToUTF16("android_test");
   rlz_string = SearchTermsDataAndroid::rlz_parameter_value_.Get();
 #endif
 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("x")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   std::string expected_url = "http://bar/?";
   if (!rlz_string.empty())
     expected_url += "rlz=" + base::UTF16ToUTF8(rlz_string) + "&";
   expected_url += "x";
   EXPECT_EQ(expected_url, result.spec());
 }
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 TEST_F(TemplateURLTest, RLZFromAppList) {
   base::string16 rlz_string;
 #if defined(ENABLE_RLZ)
   std::string brand;
   if (google_brand::GetBrand(&brand) && !brand.empty() &&
       !google_brand::IsOrganic(brand)) {
     RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz_string);
   }
 #endif
 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs args(ASCIIToUTF16("x"));
   args.from_app_list = true;
   GURL result(url.url_ref().ReplaceSearchTerms(args, search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   std::string expected_url = "http://bar/?";
   if (!rlz_string.empty())
     expected_url += "rlz=" + base::UTF16ToUTF8(rlz_string) + "&";
   expected_url += "x";
@@ skipping 25 matching lines @@
     { "http://blah/?q={searchTerms}", "blah", "/", "q"},
     { "https://blah/?q={searchTerms}", "blah", "/", "q"},
 
     // Single term with extra chars in value should match.
     { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
-    TemplateURL url(NULL, data);
+    TemplateURL url(data);
     EXPECT_EQ(test_data[i].host, url.url_ref().GetHost(search_terms_data_));
     EXPECT_EQ(test_data[i].path, url.url_ref().GetPath(search_terms_data_));
     EXPECT_EQ(test_data[i].search_term_key,
               url.url_ref().GetSearchTermKey(search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
   static const struct {
     const char* const base_url;
     const char* const base_suggest_url;
   } data[] = {
     { "http://google.com/", "http://google.com/complete/", },
     { "http://www.google.com/", "http://www.google.com/complete/", },
     { "http://www.google.co.uk/", "http://www.google.co.uk/complete/", },
     { "http://www.google.com.by/", "http://www.google.com.by/complete/", },
     { "http://google.com/intl/xx/", "http://google.com/complete/", },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
     CheckSuggestBaseURL(data[i].base_url, data[i].base_suggest_url);
 }
 
 TEST_F(TemplateURLTest, ParseParameterKnown) {
   std::string parsed_url("{searchTerms}");
   TemplateURLData data;
   data.SetURL(parsed_url);
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   EXPECT_TRUE(url.url_ref().ParseParameter(0, 12, &parsed_url, &replacements));
   EXPECT_EQ(std::string(), parsed_url);
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(0U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 }
 
 TEST_F(TemplateURLTest, ParseParameterUnknown) {
   std::string parsed_url("{fhqwhgads}abc");
   TemplateURLData data;
   data.SetURL(parsed_url);
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
 
   // By default, TemplateURLRef should not consider itself prepopulated.
   // Therefore we should not replace the unknown parameter.
   EXPECT_FALSE(url.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
   EXPECT_EQ("{fhqwhgads}abc", parsed_url);
   EXPECT_TRUE(replacements.empty());
 
   // If the TemplateURLRef is prepopulated, we should remove unknown parameters.
   parsed_url = "{fhqwhgads}abc";
   data.prepopulate_id = 1;
-  TemplateURL url2(NULL, data);
+  TemplateURL url2(data);
   EXPECT_TRUE(url2.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
   EXPECT_EQ("abc", parsed_url);
   EXPECT_TRUE(replacements.empty());
 }
 
 TEST_F(TemplateURLTest, ParseURLEmpty) {
-  TemplateURL url(NULL, TemplateURLData());
+  TemplateURLData data;
+  TemplateURL url(data);

[Peter Kasting, 2014/06/17 21:07:55]

Nit: Why not just do this?:

  TemplateURL url(TemplateURLData());

[hashimoto, 2014/06/17 21:58:03]

Done.
Please note that the additional parenthesis are needed to avoid compile error.
(with Clang, it says "error: parentheses were disambiguated as a function
declaration [-Werror,-Wvexing-parse]")
Seems this sentence can be parsed as a function declaration by the compiler
without these parenthesis.

   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ(std::string(),
             url.url_ref().ParseURL(std::string(), &replacements, NULL, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNoTemplateEnd) {
   TemplateURLData data;
   data.SetURL("{");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ(std::string(), url.url_ref().ParseURL("{", &replacements, NULL,
                                                   &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_FALSE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNoKnownParameters) {
   TemplateURLData data;
   data.SetURL("{}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{}", url.url_ref().ParseURL("{}", &replacements, NULL, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLTwoParameters) {
   TemplateURLData data;
   data.SetURL("{}{{%s}}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{}{}",
             url.url_ref().ParseURL("{}{{searchTerms}}", &replacements, NULL,
                                    &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(3U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNestedParameter) {
   TemplateURLData data;
   data.SetURL("{%s");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{",
             url.url_ref().ParseURL("{{searchTerms}", &replacements, NULL,
                                    &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(1U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }
 
 #if defined(OS_ANDROID)
 TEST_F(TemplateURLTest, SearchClient) {
   const std::string base_url_str("http://google.com/?");
   const std::string terms_str("{searchTerms}&{google:searchClient}");
   const std::string full_url_str = base_url_str + terms_str;
   const base::string16 terms(ASCIIToUTF16(terms_str));
   UIThreadSearchTermsData::SetGoogleBaseURL(base_url_str);
 
   TemplateURLData data;
   data.SetURL(full_url_str);
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
 
   // Check that the URL is correct when a client is not present.
   GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://google.com/?foobar&", result.spec());
 
   // Check that the URL is correct when a client is present.
   SearchTermsDataAndroid::search_client_.Get() = "android_test";
   GURL result_2(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
   ASSERT_TRUE(result_2.is_valid());
   EXPECT_EQ("http://google.com/?foobar&client=android_test&", result_2.spec());
 }
 #endif
 
 TEST_F(TemplateURLTest, GetURLNoInstantURL) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.suggestions_url = "http://google.com/suggest?q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt?q={searchTerms}");
   data.alternate_urls.push_back("{google:baseURL}/alt/#q={searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   ASSERT_EQ(3U, url.URLCount());
   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
   EXPECT_EQ("{google:baseURL}/alt/#q={searchTerms}", url.GetURL(1));
   EXPECT_EQ("http://google.com/?q={searchTerms}", url.GetURL(2));
 }
 
 TEST_F(TemplateURLTest, GetURLNoSuggestionsURL) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.instant_url = "http://google.com/instant#q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt?q={searchTerms}");
   data.alternate_urls.push_back("{google:baseURL}/alt/#q={searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   ASSERT_EQ(3U, url.URLCount());
   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
   EXPECT_EQ("{google:baseURL}/alt/#q={searchTerms}", url.GetURL(1));
   EXPECT_EQ("http://google.com/?q={searchTerms}", url.GetURL(2));
 }
 
 TEST_F(TemplateURLTest, GetURLOnlyOneURL) {
   TemplateURLData data;
   data.SetURL("http://www.google.co.uk/");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   ASSERT_EQ(1U, url.URLCount());
   EXPECT_EQ("http://www.google.co.uk/", url.GetURL(0));
 }
 
 TEST_F(TemplateURLTest, ExtractSearchTermsFromURL) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.instant_url = "http://google.com/instant#q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
   data.alternate_urls.push_back(
       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   base::string16 result;
 
   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
       GURL("http://google.com/?q=something"), search_terms_data_, &result));
   EXPECT_EQ(ASCIIToUTF16("something"), result);
 
   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
       GURL("http://google.com/?espv&q=something"),
       search_terms_data_, &result));
   EXPECT_EQ(ASCIIToUTF16("something"), result);
@@ skipping 90 matching lines @@
 }
 
 TEST_F(TemplateURLTest, HasSearchTermsReplacementKey) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.instant_url = "http://google.com/instant#q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
   data.alternate_urls.push_back(
       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
   data.search_terms_replacement_key = "espv";
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
 
   // Test with instant enabled required.
   EXPECT_FALSE(url.HasSearchTermsReplacementKey(
       GURL("http://google.com/")));
 
   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
       GURL("http://google.com/?espv")));
 
   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
       GURL("http://google.com/#espv")));
@@ skipping 60 matching lines @@
       GURL("http://bing.com/#espv")));
 }
 
 TEST_F(TemplateURLTest, ReplaceSearchTermsInURL) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.instant_url = "http://google.com/instant#q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
   data.alternate_urls.push_back(
       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("Bob Morane"));
   GURL result;
 
   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
       GURL("http://google.com/?q=something"), search_terms,
       search_terms_data_, &result));
   EXPECT_EQ(GURL("http://google.com/?q=Bob%20Morane"), result);
 
   result = GURL("http://should.not.change.com");
   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
@@ skipping 61 matching lines @@
 }
 
 // Test the |suggest_query_params| field of SearchTermsArgs.
 TEST_F(TemplateURLTest, SuggestQueryParams) {
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   // Pick a URL with replacements before, during, and after the query, to ensure
   // we don't goof up any of them.
   data.SetURL("{google:baseURL}search?q={searchTerms}"
       "#{google:originalQueryForSuggestion}x");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
 
   // Baseline: no |suggest_query_params| field.
   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
   search_terms.original_query = ASCIIToUTF16("def");
   search_terms.accepted_suggestion = 0;
   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Set the suggest_query_params.
   search_terms.suggest_query_params = "pq=xyz";
   EXPECT_EQ("http://www.google.com/search?pq=xyz&q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Add extra_query_params in the mix, and ensure it works.
   search_terms.append_extra_query_params = true;
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
   EXPECT_EQ("http://www.google.com/search?a=b&pq=xyz&q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 }
 
 // Test the |append_extra_query_params| field of SearchTermsArgs.
 TEST_F(TemplateURLTest, ExtraQueryParams) {
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   // Pick a URL with replacements before, during, and after the query, to ensure
   // we don't goof up any of them.
   data.SetURL("{google:baseURL}search?q={searchTerms}"
       "#{google:originalQueryForSuggestion}x");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
 
   // Baseline: no command-line args, no |append_extra_query_params| flag.
   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
   search_terms.original_query = ASCIIToUTF16("def");
   search_terms.accepted_suggestion = 0;
   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Set the flag.  Since there are no command-line args, this should have no
   // effect.
@@ skipping 12 matching lines @@
   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 }
 
 // Tests replacing pageClassification.
 TEST_F(TemplateURLTest, ReplacePageClassification) {
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   data.SetURL("{google:baseURL}?{google:pageClassification}q={searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
 
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://www.google.com/?q=foo", result);
 
   search_terms_args.page_classification = AutocompleteInput::NTP;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
@@ skipping 10 matching lines @@
 // Test the IsSearchResults function.
 TEST_F(TemplateURLTest, IsSearchResults) {
   TemplateURLData data;
   data.SetURL("http://bar/search?q={searchTerms}");
   data.instant_url = "http://bar/instant#q={searchTerms}";
   data.new_tab_url = "http://bar/newtab";
   data.alternate_urls.push_back("http://bar/?q={searchTerms}");
   data.alternate_urls.push_back("http://bar/#q={searchTerms}");
   data.alternate_urls.push_back("http://bar/search#q{searchTerms}");
   data.alternate_urls.push_back("http://bar/webhp#q={searchTerms}");
-  TemplateURL search_provider(NULL, data);
+  TemplateURL search_provider(data);
 
   const struct {
     const char* const url;
     bool result;
   } url_data[] = {
     { "http://bar/search?q=foo&oq=foo", true, },
     { "http://bar/?q=foo&oq=foo", true, },
     { "http://bar/#output=search&q=foo&oq=foo", true, },
     { "http://bar/webhp#q=foo&oq=foo", true, },
     { "http://bar/#q=foo&oq=foo", true, },
     { "http://bar/?ext=foo&q=foo#ref=bar", true, },
     { "http://bar/url?url=http://www.foo.com/&q=foo#ref=bar", false, },
     { "http://bar/", false, },
     { "http://foo/", false, },
     { "http://bar/newtab", false, },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_data); ++i) {
     EXPECT_EQ(url_data[i].result,
               search_provider.IsSearchURL(GURL(url_data[i].url),
                                           search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, ReflectsBookmarkBarPinned) {
   UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   data.SetURL("{google:baseURL}?{google:bookmarkBarPinned}q={searchTerms}");
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
 
   // Do not add the param when InstantExtended is suppressed on SRPs.
   url.url_ref_.showing_search_terms_ = false;
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://www.google.com/?q=foo", result);
 
   // Add the param when InstantExtended is not suppressed on SRPs.
   url.url_ref_.showing_search_terms_ = true;
   search_terms_args.bookmark_bar_pinned = false;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://www.google.com/?bmbp=0&q=foo", result);
 
   url.url_ref_.showing_search_terms_ = true;
   search_terms_args.bookmark_bar_pinned = true;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://www.google.com/?bmbp=1&q=foo", result);
 }
 
 TEST_F(TemplateURLTest, AnswersHasVersion) {
   TemplateURLData data;
   UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
   data.SetURL("http://bar/search?q={searchTerms}&{google:searchVersion}xssi=t");
 
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableAnswersInSuggest);
-  TemplateURL url2(NULL, data);
+  TemplateURL url2(data);
   result = url2.url_ref().ReplaceSearchTerms(search_terms_args,
                                              search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&gs_rn=42&xssi=t", result);
 }
 
 TEST_F(TemplateURLTest, SessionToken) {
   TemplateURLData data;
   UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
   data.SetURL("http://bar/search?q={searchTerms}&{google:sessionToken}xssi=t");
 
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   search_terms_args.session_token = "SESSIONTOKENGOESHERE";
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&psi=SESSIONTOKENGOESHERE&xssi=t", result);
 
-  TemplateURL url2(NULL, data);
+  TemplateURL url2(data);
   search_terms_args.session_token = "";
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 }
 
 TEST_F(TemplateURLTest, ContextualSearchParameters) {
   TemplateURLData data;
   UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
   data.SetURL("http://bar/_/contextualsearch?"
               "{google:contextualSearchVersion}"
               "{google:contextualSearchContextData}");
 
-  TemplateURL url(NULL, data);
+  TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/_/contextualsearch?", result);
 
   TemplateURLRef::SearchTermsArgs::ContextualSearchParams params(
       1, 6, 11, "allen", "woody+allen+movies", "www.wikipedia.org",
       "utf-8");
   search_terms_args.contextual_search_params = params;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://bar/_/contextualsearch?"
                 "ctxs=1&"
                 "ctxs_start=6&"
                 "ctxs_end=11&"
                 "q=allen&"
                 "ctxs_content=woody+allen+movies&"
                 "ctxs_url=www.wikipedia.org&"
             "ctxs_encoding=utf-8&", result);
 }