Modify the headers in src/ to forward to url/*.h

src/url_canon_internal.h

Index: src/url_canon_internal.h
diff --git a/src/url_canon_internal.h b/src/url_canon_internal.h
index 9165398fac6a21e2bfc618bc61b87bd4b7041d77..68e2ba2ae099cff8116da8da2240a42dac56387b 100644
--- a/src/url_canon_internal.h
+++ b/src/url_canon_internal.h
@@ -35,427 +35,6 @@
 #ifndef GOOGLEURL_SRC_URL_CANON_INTERNAL_H__
 #define GOOGLEURL_SRC_URL_CANON_INTERNAL_H__
 
-#include <stdlib.h>
-
-#include "base/logging.h"
-#include "googleurl/src/url_canon.h"
-
-namespace url_canon {
-
-// Character type handling -----------------------------------------------------
-
-// Bits that identify different character types. These types identify different
-// bits that are set for each 8-bit character in the kSharedCharTypeTable.
-enum SharedCharTypes {
-  // Characters that do not require escaping in queries. Characters that do
-  // not have this flag will be escaped; see url_canon_query.cc
-  CHAR_QUERY = 1,
-
-  // Valid in the username/password field.
-  CHAR_USERINFO = 2,
-
-  // Valid in a IPv4 address (digits plus dot and 'x' for hex).
-  CHAR_IPV4 = 4,
-
-  // Valid in an ASCII-representation of a hex digit (as in %-escaped).
-  CHAR_HEX = 8,
-
-  // Valid in an ASCII-representation of a decimal digit.
-  CHAR_DEC = 16,
-
-  // Valid in an ASCII-representation of an octal digit.
-  CHAR_OCT = 32,
-
-  // Characters that do not require escaping in encodeURIComponent.  Characters
-  // that do not have this flag will be escaped; see url_util.cc.
-  CHAR_COMPONENT = 64,
-};
-
-// This table contains the flags in SharedCharTypes for each 8-bit character.
-// Some canonicalization functions have their own specialized lookup table.
-// For those with simple requirements, we have collected the flags in one
-// place so there are fewer lookup tables to load into the CPU cache.
-//
-// Using an unsigned char type has a small but measurable performance benefit
-// over using a 32-bit number.
-extern const unsigned char kSharedCharTypeTable[0x100];
-
-// More readable wrappers around the character type lookup table.
-inline bool IsCharOfType(unsigned char c, SharedCharTypes type) {
-  return !!(kSharedCharTypeTable[c] & type);
-}
-inline bool IsQueryChar(unsigned char c) {
-  return IsCharOfType(c, CHAR_QUERY);
-}
-inline bool IsIPv4Char(unsigned char c) {
-  return IsCharOfType(c, CHAR_IPV4);
-}
-inline bool IsHexChar(unsigned char c) {
-  return IsCharOfType(c, CHAR_HEX);
-}
-inline bool IsComponentChar(unsigned char c) {
-  return IsCharOfType(c, CHAR_COMPONENT);
-}
-
-// Appends the given string to the output, escaping characters that do not
-// 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.
-GURL_API 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];
-
-// Assumes the input is a valid hex digit! Call IsHexChar before using this.
-inline unsigned char HexCharToValue(unsigned char c) {
-  return c - kCharToHexLookup[c / 0x20];
-}
-
-// Indicates if the given character is a dot or dot equivalent, returning the
-// number of characters taken by it. This will be one for a literal dot, 3 for
-// an escaped dot. If the character is not a dot, this will return 0.
-template<typename CHAR>
-inline int IsDot(const CHAR* spec, int offset, int end) {
-  if (spec[offset] == '.') {
-    return 1;
-  } else if (spec[offset] == '%' && offset + 3 <= end &&
-             spec[offset + 1] == '2' &&
-             (spec[offset + 2] == 'e' || spec[offset + 2] == 'E')) {
-    // Found "%2e"
-    return 3;
-  }
-  return 0;
-}
-
-// Returns the canonicalized version of the input character according to scheme
-// rules. This is implemented alongside the scheme canonicalizer, and is
-// required for relative URL resolving to test for scheme equality.
-//
-// Returns 0 if the input character is not a valid scheme character.
-char CanonicalSchemeChar(char16 ch);
-
-// Write a single character, escaped, to the output. This always escapes: it
-// does no checking that thee character requires escaping.
-// Escaping makes sense only 8 bit chars, so code works in all cases of
-// input parameters (8/16bit).
-template<typename UINCHAR, typename OUTCHAR>
-inline void AppendEscapedChar(UINCHAR ch,
-                              CanonOutputT<OUTCHAR>* output) {
-  output->push_back('%');
-  output->push_back(kHexCharLookup[(ch >> 4) & 0xf]);
-  output->push_back(kHexCharLookup[ch & 0xf]);
-}
-
-// The character we'll substitute for undecodable or invalid characters.
-extern const char16 kUnicodeReplacementCharacter;
-
-// UTF-8 functions ------------------------------------------------------------
-
-// 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.
-GURL_API 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) {
-    Appender(static_cast<unsigned char>(char_value), output);
-  } else if (char_value <= 0x7ff) {
-    // 110xxxxx 10xxxxxx
-    Appender(static_cast<unsigned char>(0xC0 | (char_value >> 6)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
-             output);
-  } else if (char_value <= 0xffff) {
-    // 1110xxxx 10xxxxxx 10xxxxxx
-    Appender(static_cast<unsigned char>(0xe0 | (char_value >> 12)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | ((char_value >> 6) & 0x3f)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
-             output);
-  } else if (char_value <= 0x10FFFF) {  // Max unicode code point.
-    // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-    Appender(static_cast<unsigned char>(0xf0 | (char_value >> 18)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | ((char_value >> 12) & 0x3f)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | ((char_value >> 6) & 0x3f)),
-             output);
-    Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
-             output);
-  } else {
-    // Invalid UTF-8 character (>20 bits).
-    NOTREACHED();
-  }
-}
-
-// Helper used by AppendUTF8Value below. We use an unsigned parameter so there
-// are no funny sign problems with the input, but then have to convert it to
-// a regular char for appending.
-inline void AppendCharToOutput(unsigned char ch, CanonOutput* output) {
-  output->push_back(static_cast<char>(ch));
-}
-
-// Writes the given character to the output as UTF-8. This does NO checking
-// of the validity of the unicode characters; the caller should ensure that
-// the value it is appending is valid to append.
-inline void AppendUTF8Value(unsigned char_value, CanonOutput* output) {
-  DoAppendUTF8<CanonOutput, AppendCharToOutput>(char_value, output);
-}
-
-// Writes the given character to the output as UTF-8, escaping ALL
-// characters (even when they are ASCII). This does NO checking of the
-// validity of the unicode characters; the caller should ensure that the value
-// it is appending is valid to append.
-inline void AppendUTF8EscapedValue(unsigned char_value, CanonOutput* output) {
-  DoAppendUTF8<CanonOutput, AppendEscapedChar>(char_value, output);
-}
-
-// UTF-16 functions -----------------------------------------------------------
-
-// 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.
-GURL_API 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));
-  }
-}
-
-// Escaping functions ---------------------------------------------------------
-
-// Writes the given character to the output as UTF-8, escaped. Call this
-// function only when the input is wide. Returns true on success. Failure
-// means there was some problem with the encoding, we'll still try to
-// update the |*begin| pointer and add a placeholder character to the
-// output so processing can continue.
-//
-// We will append the character starting at ch[begin] with the buffer ch
-// being |length|. |*begin| will be updated to point to the last character
-// consumed (we may consume more than one for UTF-16) so that if called in
-// a loop, incrementing the pointer will move to the next character.
-//
-// Every single output character will be escaped. This means that if you
-// give it an ASCII character as input, it will be escaped. Some code uses
-// this when it knows that a character is invalid according to its rules
-// for validity. If you don't want escaping for ASCII characters, you will
-// have to filter them out prior to calling this function.
-//
-// Assumes that ch[begin] is within range in the array, but does not assume
-// that any following characters are.
-inline bool AppendUTF8EscapedChar(const char16* str, int* begin, int length,
-                                  CanonOutput* output) {
-  // UTF-16 input. Readchar16 will handle invalid characters for us and give
-  // us the kUnicodeReplacementCharacter, so we don't have to do special
-  // checking after failure, just pass through the failure to the caller.
-  unsigned char_value;
-  bool success = ReadUTFChar(str, begin, length, &char_value);
-  AppendUTF8EscapedValue(char_value, output);
-  return success;
-}
-
-// Handles UTF-8 input. See the wide version above for usage.
-inline bool AppendUTF8EscapedChar(const char* str, int* begin, int length,
-                                  CanonOutput* output) {
-  // ReadUTF8Char will handle invalid characters for us and give us the
-  // kUnicodeReplacementCharacter, so we don't have to do special checking
-  // after failure, just pass through the failure to the caller.
-  unsigned ch;
-  bool success = ReadUTFChar(str, begin, length, &ch);
-  AppendUTF8EscapedValue(ch, output);
-  return success;
-}
-
-// Given a '%' character at |*begin| in the string |spec|, this will decode
-// the escaped value and put it into |*unescaped_value| on success (returns
-// true). On failure, this will return false, and will not write into
-// |*unescaped_value|.
-//
-// |*begin| will be updated to point to the last character of the escape
-// sequence so that when called with the index of a for loop, the next time
-// through it will point to the next character to be considered. On failure,
-// |*begin| will be unchanged.
-inline bool Is8BitChar(char c) {
-  return true;  // this case is specialized to avoid a warning
-}
-inline bool Is8BitChar(char16 c) {
-  return c <= 255;
-}
-
-template<typename CHAR>
-inline bool DecodeEscaped(const CHAR* spec, int* begin, int end,
-                          unsigned char* unescaped_value) {
-  if (*begin + 3 > end ||
-      !Is8BitChar(spec[*begin + 1]) || !Is8BitChar(spec[*begin + 2])) {
-    // Invalid escape sequence because there's not enough room, or the
-    // digits are not ASCII.
-    return false;
-  }
-
-  unsigned char first = static_cast<unsigned char>(spec[*begin + 1]);
-  unsigned char second = static_cast<unsigned char>(spec[*begin + 2]);
-  if (!IsHexChar(first) || !IsHexChar(second)) {
-    // Invalid hex digits, fail.
-    return false;
-  }
-
-  // Valid escape sequence.
-  *unescaped_value = (HexCharToValue(first) << 4) + HexCharToValue(second);
-  *begin += 2;
-  return true;
-}
-
-// Appends the given substring to the output, escaping "some" characters that
-// it feels may not be safe. It assumes the input values are all contained in
-// 8-bit although it allows any type.
-//
-// This is used in error cases to append invalid output so that it looks
-// approximately correct. Non-error cases should not call this function since
-// the escaping rules are not guaranteed!
-void AppendInvalidNarrowString(const char* spec, int begin, int end,
-                               CanonOutput* output);
-void AppendInvalidNarrowString(const char16* spec, int begin, int end,
-                               CanonOutput* output);
-
-// 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.
-GURL_API bool ConvertUTF16ToUTF8(const char16* input, int input_len,
-                                 CanonOutput* output);
-GURL_API 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
-// point to the spec of the old URL, and all of the Parsed components will
-// be indices into that string.
-//
-// The pointers and components in the |source| for all non-NULL strings in the
-// |repl| (replacements) will be updated to reference those strings.
-// Canonicalizing with the new |source| and |parsed| can then combine URL
-// components from many different strings.
-void SetupOverrideComponents(const char* base,
-                             const Replacements<char>& repl,
-                             URLComponentSource<char>* source,
-                             url_parse::Parsed* parsed);
-
-// Like the above 8-bit version, except that it additionally converts the
-// UTF-16 input to UTF-8 before doing the overrides.
-//
-// The given utf8_buffer is used to store the converted components. They will
-// be appended one after another, with the parsed structure identifying the
-// appropriate substrings. This buffer is a parameter because the source has
-// no storage, so the buffer must have the same lifetime as the source
-// parameter owned by the caller.
-//
-// THE CALLER MUST NOT ADD TO THE |utf8_buffer| AFTER THIS CALL. Members of
-// |source| will point into this buffer, which could be invalidated if
-// additional data is added and the CanonOutput resizes its buffer.
-//
-// Returns true on success. Fales means that the input was not valid UTF-16,
-// although we will have still done the override with "invalid characters" in
-// place of errors.
-bool SetupUTF16OverrideComponents(const char* base,
-                                  const Replacements<char16>& repl,
-                                  CanonOutput* utf8_buffer,
-                                  URLComponentSource<char>* source,
-                                  url_parse::Parsed* parsed);
-
-// Implemented in url_canon_path.cc, these are required by the relative URL
-// resolver as well, so we declare them here.
-bool CanonicalizePartialPath(const char* spec,
-                             const url_parse::Component& path,
-                             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
-GURL_API int _itoa_s(int value, char* buffer, size_t size_in_chars, int radix);
-GURL_API 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
+#include "url/url_canon_internal.h"
 
 #endif  // GOOGLEURL_SRC_URL_CANON_INTERNAL_H__