Make it possible to build url/ without ICU on android.

url/url_canon_unittest.cc

 // Copyright 2013 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 <errno.h>
 
+#include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/common/unicode/ucnv.h"
 #include "url/url_canon.h"
-#include "url/url_canon_icu.h"
 #include "url/url_canon_internal.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_parse.h"
 #include "url/url_test_utils.h"
 
 // Some implementations of base/basictypes.h may define ARRAYSIZE.
 // If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
 // which is in our version of basictypes.h.
 #ifndef ARRAYSIZE
 #define ARRAYSIZE ARRAYSIZE_UNSAFE
@@ skipping 56 matching lines @@
   const char* username;
   const char* password;
   const char* host;
   const char* port;
   const char* path;
   const char* query;
   const char* ref;
   const char* expected;
 };
 
-// Wrapper around a UConverter object that managers creation and destruction.
-class UConvScoper {
- public:
-  explicit UConvScoper(const char* charset_name) {
-    UErrorCode err = U_ZERO_ERROR;
-    converter_ = ucnv_open(charset_name, &err);
-  }
-
-  ~UConvScoper() {
-    if (converter_)
-      ucnv_close(converter_);
-  }
-
-  // Returns the converter object, may be NULL.
-  UConverter* converter() const { return converter_; }
-
- private:
-  UConverter* converter_;
-};
-
 // Magic string used in the replacements code that tells SetupReplComp to
 // call the clear function.
 const char kDeleteComp[] = "|";
 
 // Sets up a replacement for a single component. This is given pointers to
 // the set and clear function for the component being replaced, and will
 // either set the component (if it exists) or clear it (if the replacement
 // string matches kDeleteComp).
 //
 // This template is currently used only for the 8-bit case, and the strlen
@@ skipping 120 matching lines @@
       std::string input8_str(utf_cases[i].input8);
       base::string16 input16_str(WStringToUTF16(utf_cases[i].input16));
       EXPECT_EQ(input8_str, ConvertUTF16ToUTF8(input16_str));
 
       // UTF-8 -> UTF-16
       EXPECT_EQ(input16_str, ConvertUTF8ToUTF16(input8_str));
     }
   }
 }
 
-TEST(URLCanonTest, ICUCharsetConverter) {
-  struct ICUCase {
-    const wchar_t* input;
-    const char* encoding;
-    const char* expected;
-  } icu_cases[] = {
-      // UTF-8.
-    {L"Hello, world", "utf-8", "Hello, world"},
-    {L"\x4f60\x597d", "utf-8", "\xe4\xbd\xa0\xe5\xa5\xbd"},
-      // Non-BMP UTF-8.
-    {L"!\xd800\xdf00!", "utf-8", "!\xf0\x90\x8c\x80!"},
-      // Big5
-    {L"\x4f60\x597d", "big5", "\xa7\x41\xa6\x6e"},
-      // Unrepresentable character in the destination set.
-    {L"hello\x4f60\x06de\x597dworld", "big5", "hello\xa7\x41%26%231758%3B\xa6\x6eworld"},
-  };
-
-  for (size_t i = 0; i < ARRAYSIZE(icu_cases); i++) {
-    UConvScoper conv(icu_cases[i].encoding);
-    ASSERT_TRUE(conv.converter() != NULL);
-    ICUCharsetConverter converter(conv.converter());
-
-    std::string str;
-    StdStringCanonOutput output(&str);
-
-    base::string16 input_str(WStringToUTF16(icu_cases[i].input));
-    int input_len = static_cast<int>(input_str.length());
-    converter.ConvertFromUTF16(input_str.c_str(), input_len, &output);
-    output.Complete();
-
-    EXPECT_STREQ(icu_cases[i].expected, str.c_str());
-  }
-
-  // Test string sizes around the resize boundary for the output to make sure
-  // the converter resizes as needed.
-  const int static_size = 16;
-  UConvScoper conv("utf-8");
-  ASSERT_TRUE(conv.converter());
-  ICUCharsetConverter converter(conv.converter());
-  for (int i = static_size - 2; i <= static_size + 2; i++) {
-    // Make a string with the appropriate length.
-    base::string16 input;
-    for (int ch = 0; ch < i; ch++)
-      input.push_back('a');
-
-    RawCanonOutput<static_size> output;
-    converter.ConvertFromUTF16(input.c_str(), static_cast<int>(input.length()),
-                               &output);
-    EXPECT_EQ(input.length(), static_cast<size_t>(output.length()));
-  }
-}
-
 TEST(URLCanonTest, Scheme) {
   // Here, we're mostly testing that unusual characters are handled properly.
   // The canonicalizer doesn't do any parsing or whitespace detection. It will
   // also do its best on error, and will escape funny sequences (these won't be
   // valid schemes and it will return error).
   //
   // Note that the canonicalizer will append a colon to the output to separate
   // out the rest of the URL, which is not present in the input. We check,
   // however, that the output range includes everything but the colon.
   ComponentCase scheme_cases[] = {
@@ skipping 882 matching lines @@
   bool success = CanonicalizePath(path_with_null, in_comp, &output, &out_comp);
   output.Complete();
   EXPECT_FALSE(success);
   EXPECT_EQ("/ab%00c", out_str);
 }
 
 TEST(URLCanonTest, Query) {
   struct QueryCase {
     const char* input8;
     const wchar_t* input16;
-    const char* encoding;
     const char* expected;
   } query_cases[] = {
-      // Regular ASCII case in some different encodings.
-    {"foo=bar", L"foo=bar", NULL, "?foo=bar"},
-    {"foo=bar", L"foo=bar", "utf-8", "?foo=bar"},
-    {"foo=bar", L"foo=bar", "shift_jis", "?foo=bar"},
-    {"foo=bar", L"foo=bar", "gb2312", "?foo=bar"},
+      // Regular ASCII case.
+    {"foo=bar", L"foo=bar", "?foo=bar"},
       // Allow question marks in the query without escaping
-    {"as?df", L"as?df", NULL, "?as?df"},
+    {"as?df", L"as?df", "?as?df"},
       // Always escape '#' since it would mark the ref.
-    {"as#df", L"as#df", NULL, "?as%23df"},
+    {"as#df", L"as#df", "?as%23df"},
       // Escape some questionable 8-bit characters, but never unescape.
-    {"\x02hello\x7f bye", L"\x02hello\x7f bye", NULL, "?%02hello%7F%20bye"},
-    {"%40%41123", L"%40%41123", NULL, "?%40%41123"},
+    {"\x02hello\x7f bye", L"\x02hello\x7f bye", "?%02hello%7F%20bye"},
+    {"%40%41123", L"%40%41123", "?%40%41123"},
       // Chinese input/output
-    {"q=\xe4\xbd\xa0\xe5\xa5\xbd", L"q=\x4f60\x597d", NULL, "?q=%E4%BD%A0%E5%A5%BD"},
-    {"q=\xe4\xbd\xa0\xe5\xa5\xbd", L"q=\x4f60\x597d", "gb2312", "?q=%C4%E3%BA%C3"},
-    {"q=\xe4\xbd\xa0\xe5\xa5\xbd", L"q=\x4f60\x597d", "big5", "?q=%A7A%A6n"},
-      // Unencodable character in the destination character set should be
-      // escaped. The escape sequence unescapes to be the entity name:
-      // "?q=&#20320;"
-    {"q=Chinese\xef\xbc\xa7", L"q=Chinese\xff27", "iso-8859-1", "?q=Chinese%26%2365319%3B"},
+    {"q=\xe4\xbd\xa0\xe5\xa5\xbd", L"q=\x4f60\x597d", "?q=%E4%BD%A0%E5%A5%BD"},
       // Invalid UTF-8/16 input should be replaced with invalid characters.
-    {"q=\xed\xed", L"q=\xd800\xd800", NULL, "?q=%EF%BF%BD%EF%BF%BD"},
+    {"q=\xed\xed", L"q=\xd800\xd800", "?q=%EF%BF%BD%EF%BF%BD"},
       // Don't allow < or > because sometimes they are used for XSS if the
       // URL is echoed in content. Firefox does this, IE doesn't.
-    {"q=<asdf>", L"q=<asdf>", NULL, "?q=%3Casdf%3E"},
+    {"q=<asdf>", L"q=<asdf>", "?q=%3Casdf%3E"},
       // Escape double quotemarks in the query.
-    {"q=\"asdf\"", L"q=\"asdf\"", NULL, "?q=%22asdf%22"},
+    {"q=\"asdf\"", L"q=\"asdf\"", "?q=%22asdf%22"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE(query_cases); i++) {
     Component out_comp;
 
-    UConvScoper conv(query_cases[i].encoding);
-    ASSERT_TRUE(!query_cases[i].encoding || conv.converter());
-    ICUCharsetConverter converter(conv.converter());
-
-    // Map NULL to a NULL converter pointer.
-    ICUCharsetConverter* conv_pointer = &converter;
-    if (!query_cases[i].encoding)
-      conv_pointer = NULL;
-
     if (query_cases[i].input8) {
       int len = static_cast<int>(strlen(query_cases[i].input8));
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
-      CanonicalizeQuery(query_cases[i].input8, in_comp, conv_pointer, &output,
+      CanonicalizeQuery(query_cases[i].input8, in_comp, NULL, &output,
                         &out_comp);
       output.Complete();
 
       EXPECT_EQ(query_cases[i].expected, out_str);
     }
 
     if (query_cases[i].input16) {
       base::string16 input16(WStringToUTF16(query_cases[i].input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
-      CanonicalizeQuery(input16.c_str(), in_comp, conv_pointer, &output,
-                        &out_comp);
+      CanonicalizeQuery(input16.c_str(), in_comp, NULL, &output, &out_comp);
       output.Complete();
 
       EXPECT_EQ(query_cases[i].expected, out_str);
     }
   }
 
   // Extra test for input with embedded NULL;
   std::string out_str;
   StdStringCanonOutput output(&out_str);
   Component out_comp;
@@ skipping 940 matching lines @@
   repl_output.Complete();
 
   // Generate the expected string and check.
   std::string expected("file:///foo?");
   for (size_t i = 0; i < new_query.length(); i++)
     expected.push_back('a');
   EXPECT_TRUE(expected == repl_str);
 }
 
 }  // namespace url