Fixes bug where keyword editor would end up prefixing all keyword urls...

chrome/browser/search_engines/template_url_unittest.cc

 // Copyright (c) 2006-2008 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/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 25 matching lines @@
   TemplateURLRef ref(L"{searchTerms}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
 }
 
 TEST_F(TemplateURLTest, URLRefTestSearchTerms) {
   TemplateURL t_url;
   TemplateURLRef ref(L"http://foo{searchTerms}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
 
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"search",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"search",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://foosearch/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount) {
   TemplateURL t_url;
   TemplateURLRef ref(L"http://foo{searchTerms}{count?}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://foox/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount2) {
   TemplateURL t_url;
   TemplateURLRef ref(L"http://foo{searchTerms}{count}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://foox10/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices) {
   TemplateURL t_url;
   TemplateURLRef ref(L"http://foo{searchTerms}x{startIndex?}y{startPage?}",
                      1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxxy/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices2) {
   TemplateURL t_url;
   TemplateURLRef ref(L"http://foo{searchTerms}x{startIndex}y{startPage}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxx1y2/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding) {
   TemplateURL t_url;
   TemplateURLRef ref(
       L"http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxxutf-8ya/", result.spec());
 }
 
 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
   TemplateURL t_url;
   TemplateURLRef ref(
       L"http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxutf-8axyb/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding2) {
   TemplateURL t_url;
   TemplateURLRef ref(
       L"http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"X",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"X",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxxutf-8yutf-8a/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTermToWide) {
   struct ToWideCase {
     const char* encoded_search_term;
     const wchar_t* expected_decoded_term;
   } to_wide_cases[] = {
     {"hello+world", L"hello world"},
@@ skipping 93 matching lines @@
   };
   TemplateURL turl;
   turl.add_input_encoding("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     TemplateURLRef ref(data[i].url, 1, 2);
     EXPECT_TRUE(ref.IsValid());
     EXPECT_TRUE(ref.SupportsReplacement());
     std::string expected_result = data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
         WideToASCII(g_browser_process->GetApplicationLocale()));
-    GURL result = ref.ReplaceSearchTerms(turl, L"X",
-        TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+    GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(turl, L"X",
+        TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(expected_result, result.spec());
   }
 }
 
 
 // Tests replacing search terms in various encodings and making sure the
 // generated URL matches the expected value.
 TEST_F(TemplateURLTest, ReplaceArbitrarySearchTerms) {
   struct TestData {
     const std::string encoding;
     const std::wstring search_term;
     const std::wstring url;
     const std::string expected_result;
   } data[] = {
     { "BIG5",  L"\x60BD", L"http://foo/{searchTerms}{inputEncoding}",
       "http://foo/%B1~BIG5" },
     { "UTF-8", L"blah",   L"http://foo/{searchTerms}{inputEncoding}",
       "http://foo/blahUTF-8" },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     TemplateURL turl;
     turl.add_input_encoding(data[i].encoding);
     TemplateURLRef ref(data[i].url, 1, 2);
-    GURL result = ref.ReplaceSearchTerms(turl, data[i].search_term,
-        TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+    GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(turl,
+        data[i].search_term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
+        std::wstring())));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(data[i].expected_result, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, Suggestions) {
   struct TestData {
     const int accepted_suggestion;
     const std::wstring original_query_for_suggestion;
     const std::string expected_result;
   } data[] = {
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring(),
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, L"foo",
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTION_CHOSEN, std::wstring(),
       "http://bar/foo?aq=f&q=foobar" },
     { TemplateURLRef::NO_SUGGESTION_CHOSEN, L"foo",
       "http://bar/foo?aq=f&q=foobar" },
     { 0, std::wstring(), "http://bar/foo?aq=0&oq=&q=foobar" },
     { 1, L"foo", "http://bar/foo?aq=1&oq=foo&q=foobar" },
   };
   TemplateURL turl;
   turl.add_input_encoding("UTF-8");
   TemplateURLRef ref(L"http://bar/foo?{google:acceptedSuggestion}"
       L"{google:originalQueryForSuggestion}q={searchTerms}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    GURL result = ref.ReplaceSearchTerms(turl, L"foobar",
-        data[i].accepted_suggestion, data[i].original_query_for_suggestion);
+    GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(turl, L"foobar",
+        data[i].accepted_suggestion, data[i].original_query_for_suggestion)));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(data[i].expected_result, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, RLZ) {
 #if defined(OS_WIN)
   RLZTracker::InitRlz(base::DIR_EXE);
 #endif
   std::wstring rlz_string;
   RLZTracker::GetAccessPointRlz(RLZTracker::CHROME_OMNIBOX, &rlz_string);
 
   TemplateURL t_url;
   TemplateURLRef ref(L"http://bar/?{google:RLZ}{searchTerms}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = ref.ReplaceSearchTerms(t_url, L"x",
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
+  GURL result = GURL(WideToUTF8(ref.ReplaceSearchTerms(t_url, L"x",
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())));
   ASSERT_TRUE(result.is_valid());
   std::string expected_url = "http://bar/?";
   if (!rlz_string.empty()) {
     expected_url += "rlz=" + WideToUTF8(rlz_string) + "&";
   }
   expected_url += "x";
   ASSERT_EQ(expected_url, result.spec());
 }
 
 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
@@ skipping 56 matching lines @@
   EXPECT_FALSE(t_url.autogenerate_keyword());
   t_url.set_keyword(L"foo");
   EXPECT_EQ(L"foo", t_url.keyword());
   t_url.set_autogenerate_keyword(true);
   EXPECT_TRUE(t_url.autogenerate_keyword());
   EXPECT_EQ(L"google.com", t_url.keyword());
   t_url.set_keyword(L"foo");
   EXPECT_FALSE(t_url.autogenerate_keyword());
   EXPECT_EQ(L"foo", t_url.keyword());
 }