Make the copy of GURL in src/url buildable as a component build. (try 2)

url/url_canon_internal.h

 // 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.
 
 #ifndef URL_URL_CANON_INTERNAL_H_
 #define URL_URL_CANON_INTERNAL_H_
 
 // This file is intended to be included in another C++ file where the character
 // types are defined. This allows us to write mostly generic code, but not have
 // templace bloat because everything is inlined when anybody calls any of our
@@ skipping 65 matching lines @@
 // match the given |type| in SharedCharTypes.
 void AppendStringOfType(const char* source, int length,
                         SharedCharTypes type,
                         CanonOutput* output);
 void AppendStringOfType(const char16* source, int length,
                         SharedCharTypes type,
                         CanonOutput* output);
 
 // Maps the hex numerical values 0x0 to 0xf to the corresponding ASCII digit
 // that will be used to represent it.
-extern const char kHexCharLookup[0x10];
+URL_EXPORT extern const char kHexCharLookup[0x10];
 
 // This lookup table allows fast conversion between ASCII hex letters and their
 // corresponding numerical value. The 8-bit range is divided up into 8
 // regions of 0x20 characters each. Each of the three character types (numbers,
 // uppercase, lowercase) falls into different regions of this range. The table
 // contains the amount to subtract from characters in that range to get at
 // the corresponding numerical value.
 //
 // See HexDigitToValue for the lookup.
 extern const char kCharToHexLookup[8];
@@ skipping 46 matching lines @@
 // Reads one character in UTF-8 starting at |*begin| in |str| and places
 // the decoded value into |*code_point|. If the character is valid, we will
 // return true. If invalid, we'll return false and put the
 // kUnicodeReplacementCharacter into |*code_point|.
 //
 // |*begin| will be updated to point to the last character consumed so it
 // can be incremented in a loop and will be ready for the next character.
 // (for a single-byte ASCII character, it will not be changed).
 //
 // Implementation is in url_canon_icu.cc.
-bool ReadUTFChar(const char* str, int* begin, int length,
-                 unsigned* code_point_out);
+URL_EXPORT bool ReadUTFChar(const char* str, int* begin, int length,
+                            unsigned* code_point_out);
 
 // Generic To-UTF-8 converter. This will call the given append method for each
 // character that should be appended, with the given output method. Wrappers
 // are provided below for escaped and non-escaped versions of this.
 //
 // The char_value must have already been checked that it's a valid Unicode
 // character.
 template<class Output, void Appender(unsigned char, Output*)>
 inline void DoAppendUTF8(unsigned char_value, Output* output) {
   if (char_value <= 0x7f) {
@@ skipping 55 matching lines @@
 // Reads one character in UTF-16 starting at |*begin| in |str| and places
 // the decoded value into |*code_point|. If the character is valid, we will
 // return true. If invalid, we'll return false and put the
 // kUnicodeReplacementCharacter into |*code_point|.
 //
 // |*begin| will be updated to point to the last character consumed so it
 // can be incremented in a loop and will be ready for the next character.
 // (for a single-16-bit-word character, it will not be changed).
 //
 // Implementation is in url_canon_icu.cc.
-bool ReadUTFChar(const char16* str, int* begin, int length,
-                 unsigned* code_point);
+URL_EXPORT bool ReadUTFChar(const char16* str, int* begin, int length,
+                            unsigned* code_point);
 
 // Equivalent to U16_APPEND_UNSAFE in ICU but uses our output method.
 inline void AppendUTF16Value(unsigned code_point,
                              CanonOutputT<char16>* output) {
   if (code_point > 0xffff) {
     output->push_back(static_cast<char16>((code_point >> 10) + 0xd7c0));
     output->push_back(static_cast<char16>((code_point & 0x3ff) | 0xdc00));
   } else {
     output->push_back(static_cast<char16>(code_point));
   }
@@ skipping 97 matching lines @@
 // Misc canonicalization helpers ----------------------------------------------
 
 // Converts between UTF-8 and UTF-16, returning true on successful conversion.
 // The output will be appended to the given canonicalizer output (so make sure
 // it's empty if you want to replace).
 //
 // On invalid input, this will still write as much output as possible,
 // replacing the invalid characters with the "invalid character". It will
 // return false in the failure case, and the caller should not continue as
 // normal.
-bool ConvertUTF16ToUTF8(const char16* input, int input_len,
-                        CanonOutput* output);
-bool ConvertUTF8ToUTF16(const char* input, int input_len,
-                        CanonOutputT<char16>* output);
+URL_EXPORT bool ConvertUTF16ToUTF8(const char16* input, int input_len,
+                                   CanonOutput* output);
+URL_EXPORT bool ConvertUTF8ToUTF16(const char* input, int input_len,
+                                   CanonOutputT<char16>* output);
 
 // Converts from UTF-16 to 8-bit using the character set converter. If the
 // converter is NULL, this will use UTF-8.
 void ConvertUTF16ToQueryEncoding(const char16* input,
                                  const url_parse::Component& query,
                                  CharsetConverter* converter,
                                  CanonOutput* output);
 
 // Applies the replacements to the given component source. The component source
 // should be pre-initialized to the "old" base. That is, all pointers will
@@ skipping 38 matching lines @@
                              int path_begin_in_output,
                              CanonOutput* output);
 bool CanonicalizePartialPath(const char16* spec,
                              const url_parse::Component& path,
                              int path_begin_in_output,
                              CanonOutput* output);
 
 #ifndef WIN32
 
 // Implementations of Windows' int-to-string conversions
-int _itoa_s(int value, char* buffer, size_t size_in_chars, int radix);
-int _itow_s(int value, char16* buffer, size_t size_in_chars,
-            int radix);
+URL_EXPORT int _itoa_s(int value, char* buffer, size_t size_in_chars,
+                       int radix);
+URL_EXPORT int _itow_s(int value, char16* buffer, size_t size_in_chars,
+                       int radix);
 
 // Secure template overloads for these functions
 template<size_t N>
 inline int _itoa_s(int value, char (&buffer)[N], int radix) {
   return _itoa_s(value, buffer, N, radix);
 }
 
 template<size_t N>
 inline int _itow_s(int value, char16 (&buffer)[N], int radix) {
   return _itow_s(value, buffer, N, radix);
 }
 
 // _strtoui64 and strtoull behave the same
 inline unsigned long long _strtoui64(const char* nptr,
                                      char** endptr, int base) {
   return strtoull(nptr, endptr, base);
 }
 
 #endif  // WIN32
 
 }  // namespace url_canon
 
 #endif  // URL_URL_CANON_INTERNAL_H_