Revert 203027 "Revert 203025 "Make the copy of GURL in src/url b..."

trunk/src/url/url_canon.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_H_
 #define URL_URL_CANON_H_
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "base/string16.h"
+#include "url/url_export.h"
 #include "url/url_parse.h"
 
 namespace url_canon {
 
 // Canonicalizer output -------------------------------------------------------
 
 // Base class for the canonicalizer output, this maintains a buffer and
 // supports simple resizing and append operations on it.
 //
 // It is VERY IMPORTANT that no virtual function calls be made on the common
@@ skipping 157 matching lines @@
 class RawCanonOutputW : public RawCanonOutputT<char16, fixed_capacity> {};
 
 // Character set converter ----------------------------------------------------
 //
 // Converts query strings into a custom encoding. The embedder can supply an
 // implementation of this class to interface with their own character set
 // conversion libraries.
 //
 // Embedders will want to see the unit test for the ICU version.
 
-class CharsetConverter {
+class URL_EXPORT CharsetConverter {
  public:
   CharsetConverter() {}
   virtual ~CharsetConverter() {}
 
   // Converts the given input string from UTF-16 to whatever output format the
   // converter supports. This is used only for the query encoding conversion,
   // which does not fail. Instead, the converter should insert "invalid
   // character" characters in the output for invalid sequences, and do the
   // best it can.
   //
@@ skipping 17 matching lines @@
 // This should be called before parsing if whitespace removal is desired (which
 // it normally is when you are canonicalizing).
 //
 // If no whitespace is removed, this function will not use the buffer and will
 // return a pointer to the input, to avoid the extra copy. If modification is
 // required, the given |buffer| will be used and the returned pointer will
 // point to the beginning of the buffer.
 //
 // Therefore, callers should not use the buffer, since it may actuall be empty,
 // use the computed pointer and |*output_len| instead.
-const char* RemoveURLWhitespace(const char* input, int input_len,
-                                CanonOutputT<char>* buffer,
-                                int* output_len);
-const char16* RemoveURLWhitespace(const char16* input, int input_len,
-                                  CanonOutputT<char16>* buffer,
-                                  int* output_len);
+URL_EXPORT const char* RemoveURLWhitespace(const char* input, int input_len,
+                                           CanonOutputT<char>* buffer,
+                                           int* output_len);
+URL_EXPORT const char16* RemoveURLWhitespace(const char16* input, int input_len,
+                                             CanonOutputT<char16>* buffer,
+                                             int* output_len);
 
 // IDN ------------------------------------------------------------------------
 
 // Converts the Unicode input representing a hostname to ASCII using IDN rules.
 // The output must fall in the ASCII range, but will be encoded in UTF-16.
 //
 // On success, the output will be filled with the ASCII host name and it will
 // return true. Unlike most other canonicalization functions, this assumes that
 // the output is empty. The beginning of the host will be at offset 0, and
 // the length of the output will be set to the length of the new host name.
 //
 // On error, returns false. The output in this case is undefined.
-bool IDNToASCII(const char16* src, int src_len, CanonOutputW* output);
+URL_EXPORT bool IDNToASCII(const char16* src,
+                           int src_len,
+                           CanonOutputW* output);
 
 // Piece-by-piece canonicalizers ----------------------------------------------
 //
 // These individual canonicalizers append the canonicalized versions of the
 // corresponding URL component to the given std::string. The spec and the
 // previously-identified range of that component are the input. The range of
 // the canonicalized component will be written to the output component.
 //
 // These functions all append to the output so they can be chained. Make sure
 // the output is empty when you start.
 //
 // These functions returns boolean values indicating success. On failure, they
 // will attempt to write something reasonable to the output so that, if
 // displayed to the user, they will recognise it as something that's messed up.
 // Nothing more should ever be done with these invalid URLs, however.
 
 // Scheme: Appends the scheme and colon to the URL. The output component will
 // indicate the range of characters up to but not including the colon.
 //
 // Canonical URLs always have a scheme. If the scheme is not present in the
 // input, this will just write the colon to indicate an empty scheme. Does not
 // append slashes which will be needed before any authority components for most
 // URLs.
 //
 // The 8-bit version requires UTF-8 encoding.
-bool CanonicalizeScheme(const char* spec,
-                        const url_parse::Component& scheme,
-                        CanonOutput* output,
-                        url_parse::Component* out_scheme);
-bool CanonicalizeScheme(const char16* spec,
-                        const url_parse::Component& scheme,
-                        CanonOutput* output,
-                        url_parse::Component* out_scheme);
+URL_EXPORT bool CanonicalizeScheme(const char* spec,
+                                   const url_parse::Component& scheme,
+                                   CanonOutput* output,
+                                   url_parse::Component* out_scheme);
+URL_EXPORT bool CanonicalizeScheme(const char16* spec,
+                                   const url_parse::Component& scheme,
+                                   CanonOutput* output,
+                                   url_parse::Component* out_scheme);
 
 // User info: username/password. If present, this will add the delimiters so
 // the output will be "<username>:<password>@" or "<username>@". Empty
 // username/password pairs, or empty passwords, will get converted to
 // nonexistant in the canonical version.
 //
 // The components for the username and password refer to ranges in the
 // respective source strings. Usually, these will be the same string, which
 // is legal as long as the two components don't overlap.
 //
 // The 8-bit version requires UTF-8 encoding.
-bool CanonicalizeUserInfo(const char* username_source,
-                          const url_parse::Component& username,
-                          const char* password_source,
-                          const url_parse::Component& password,
-                          CanonOutput* output,
-                          url_parse::Component* out_username,
-                          url_parse::Component* out_password);
-bool CanonicalizeUserInfo(const char16* username_source,
-                          const url_parse::Component& username,
-                          const char16* password_source,
-                          const url_parse::Component& password,
-                          CanonOutput* output,
-                          url_parse::Component* out_username,
-                          url_parse::Component* out_password);
+URL_EXPORT bool CanonicalizeUserInfo(const char* username_source,
+                                     const url_parse::Component& username,
+                                     const char* password_source,
+                                     const url_parse::Component& password,
+                                     CanonOutput* output,
+                                     url_parse::Component* out_username,
+                                     url_parse::Component* out_password);
+URL_EXPORT bool CanonicalizeUserInfo(const char16* username_source,
+                                     const url_parse::Component& username,
+                                     const char16* password_source,
+                                     const url_parse::Component& password,
+                                     CanonOutput* output,
+                                     url_parse::Component* out_username,
+                                     url_parse::Component* out_password);
 
 
 // This structure holds detailed state exported from the IP/Host canonicalizers.
 // Additional fields may be added as callers require them.
 struct CanonHostInfo {
   CanonHostInfo() : family(NEUTRAL), num_ipv4_components(0), out_host() {}
 
   // Convenience function to test if family is an IP address.
   bool IsIPAddress() const { return family == IPV4 || family == IPV6; }
 
@@ skipping 32 matching lines @@
   int AddressLength() const {
     return family == IPV4 ? 4 : (family == IPV6 ? 16 : 0);
   }
 };
 
 
 // Host.
 //
 // The 8-bit version requires UTF-8 encoding.  Use this version when you only
 // need to know whether canonicalization succeeded.
-bool CanonicalizeHost(const char* spec,
-                      const url_parse::Component& host,
-                      CanonOutput* output,
-                      url_parse::Component* out_host);
-bool CanonicalizeHost(const char16* spec,
-                      const url_parse::Component& host,
-                      CanonOutput* output,
-                      url_parse::Component* out_host);
+URL_EXPORT bool CanonicalizeHost(const char* spec,
+                                 const url_parse::Component& host,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_host);
+URL_EXPORT bool CanonicalizeHost(const char16* spec,
+                                 const url_parse::Component& host,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_host);
 
 // Extended version of CanonicalizeHost, which returns additional information.
 // Use this when you need to know whether the hostname was an IP address.
 // A successful return is indicated by host_info->family != BROKEN.  See the
 // definition of CanonHostInfo above for details.
-void CanonicalizeHostVerbose(const char* spec,
-                             const url_parse::Component& host,
-                             CanonOutput* output,
-                             CanonHostInfo* host_info);
-void CanonicalizeHostVerbose(const char16* spec,
-                             const url_parse::Component& host,
-                             CanonOutput* output,
-                             CanonHostInfo* host_info);
+URL_EXPORT void CanonicalizeHostVerbose(const char* spec,
+                                        const url_parse::Component& host,
+                                        CanonOutput* output,
+                                        CanonHostInfo* host_info);
+URL_EXPORT void CanonicalizeHostVerbose(const char16* spec,
+                                        const url_parse::Component& host,
+                                        CanonOutput* output,
+                                        CanonHostInfo* host_info);
 
 
 // IP addresses.
 //
 // Tries to interpret the given host name as an IPv4 or IPv6 address. If it is
 // an IP address, it will canonicalize it as such, appending it to |output|.
 // Additional status information is returned via the |*host_info| parameter.
 // See the definition of CanonHostInfo above for details.
 //
 // This is called AUTOMATICALLY from the host canonicalizer, which ensures that
 // the input is unescaped and name-prepped, etc. It should not normally be
 // necessary or wise to call this directly.
-void CanonicalizeIPAddress(const char* spec,
-                           const url_parse::Component& host,
-                           CanonOutput* output,
-                           CanonHostInfo* host_info);
-void CanonicalizeIPAddress(const char16* spec,
-                           const url_parse::Component& host,
-                           CanonOutput* output,
-                           CanonHostInfo* host_info);
+URL_EXPORT void CanonicalizeIPAddress(const char* spec,
+                                      const url_parse::Component& host,
+                                      CanonOutput* output,
+                                      CanonHostInfo* host_info);
+URL_EXPORT void CanonicalizeIPAddress(const char16* spec,
+                                      const url_parse::Component& host,
+                                      CanonOutput* output,
+                                      CanonHostInfo* host_info);
 
 // Port: this function will add the colon for the port if a port is present.
 // The caller can pass url_parse::PORT_UNSPECIFIED as the
 // default_port_for_scheme argument if there is no default port.
 //
 // The 8-bit version requires UTF-8 encoding.
-bool CanonicalizePort(const char* spec,
-                      const url_parse::Component& port,
-                      int default_port_for_scheme,
-                      CanonOutput* output,
-                      url_parse::Component* out_port);
-bool CanonicalizePort(const char16* spec,
-                      const url_parse::Component& port,
-                      int default_port_for_scheme,
-                      CanonOutput* output,
-                      url_parse::Component* out_port);
+URL_EXPORT bool CanonicalizePort(const char* spec,
+                                 const url_parse::Component& port,
+                                 int default_port_for_scheme,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_port);
+URL_EXPORT bool CanonicalizePort(const char16* spec,
+                                 const url_parse::Component& port,
+                                 int default_port_for_scheme,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_port);
 
 // Returns the default port for the given canonical scheme, or PORT_UNSPECIFIED
 // if the scheme is unknown.
-int DefaultPortForScheme(const char* scheme, int scheme_len);
+URL_EXPORT int DefaultPortForScheme(const char* scheme, int scheme_len);
 
 // Path. If the input does not begin in a slash (including if the input is
 // empty), we'll prepend a slash to the path to make it canonical.
 //
 // The 8-bit version assumes UTF-8 encoding, but does not verify the validity
 // of the UTF-8 (i.e., you can have invalid UTF-8 sequences, invalid
 // characters, etc.). Normally, URLs will come in as UTF-16, so this isn't
 // an issue. Somebody giving us an 8-bit path is responsible for generating
 // the path that the server expects (we'll escape high-bit characters), so
 // if something is invalid, it's their problem.
-bool CanonicalizePath(const char* spec,
-                      const url_parse::Component& path,
-                      CanonOutput* output,
-                      url_parse::Component* out_path);
-bool CanonicalizePath(const char16* spec,
-                      const url_parse::Component& path,
-                      CanonOutput* output,
-                      url_parse::Component* out_path);
+URL_EXPORT bool CanonicalizePath(const char* spec,
+                                 const url_parse::Component& path,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_path);
+URL_EXPORT bool CanonicalizePath(const char16* spec,
+                                 const url_parse::Component& path,
+                                 CanonOutput* output,
+                                 url_parse::Component* out_path);
 
 // Canonicalizes the input as a file path. This is like CanonicalizePath except
 // that it also handles Windows drive specs. For example, the path can begin
 // with "c|\" and it will get properly canonicalized to "C:/".
 // The string will be appended to |*output| and |*out_path| will be updated.
 //
 // The 8-bit version requires UTF-8 encoding.
-bool FileCanonicalizePath(const char* spec,
-                          const url_parse::Component& path,
-                          CanonOutput* output,
-                          url_parse::Component* out_path);
-bool FileCanonicalizePath(const char16* spec,
-                          const url_parse::Component& path,
-                          CanonOutput* output,
-                          url_parse::Component* out_path);
+URL_EXPORT bool FileCanonicalizePath(const char* spec,
+                                     const url_parse::Component& path,
+                                     CanonOutput* output,
+                                     url_parse::Component* out_path);
+URL_EXPORT bool FileCanonicalizePath(const char16* spec,
+                                     const url_parse::Component& path,
+                                     CanonOutput* output,
+                                     url_parse::Component* out_path);
 
 // Query: Prepends the ? if needed.
 //
 // The 8-bit version requires the input to be UTF-8 encoding. Incorrectly
 // encoded characters (in UTF-8 or UTF-16) will be replaced with the Unicode
 // "invalid character." This function can not fail, we always just try to do
 // our best for crazy input here since web pages can set it themselves.
 //
 // This will convert the given input into the output encoding that the given
 // character set converter object provides. The converter will only be called
 // if necessary, for ASCII input, no conversions are necessary.
 //
 // The converter can be NULL. In this case, the output encoding will be UTF-8.
-void CanonicalizeQuery(const char* spec,
-                       const url_parse::Component& query,
-                       CharsetConverter* converter,
-                       CanonOutput* output,
-                       url_parse::Component* out_query);
-void CanonicalizeQuery(const char16* spec,
-                       const url_parse::Component& query,
-                       CharsetConverter* converter,
-                       CanonOutput* output,
-                       url_parse::Component* out_query);
+URL_EXPORT void CanonicalizeQuery(const char* spec,
+                                  const url_parse::Component& query,
+                                  CharsetConverter* converter,
+                                  CanonOutput* output,
+                                  url_parse::Component* out_query);
+URL_EXPORT void CanonicalizeQuery(const char16* spec,
+                                  const url_parse::Component& query,
+                                  CharsetConverter* converter,
+                                  CanonOutput* output,
+                                  url_parse::Component* out_query);
 
 // Ref: Prepends the # if needed. The output will be UTF-8 (this is the only
 // canonicalizer that does not produce ASCII output). The output is
 // guaranteed to be valid UTF-8.
 //
 // This function will not fail. If the input is invalid UTF-8/UTF-16, we'll use
 // the "Unicode replacement character" for the confusing bits and copy the rest.
-void CanonicalizeRef(const char* spec,
-                     const url_parse::Component& path,
-                     CanonOutput* output,
-                     url_parse::Component* out_path);
-void CanonicalizeRef(const char16* spec,
-                     const url_parse::Component& path,
-                     CanonOutput* output,
-                     url_parse::Component* out_path);
+URL_EXPORT void CanonicalizeRef(const char* spec,
+                                const url_parse::Component& path,
+                                CanonOutput* output,
+                                url_parse::Component* out_path);
+URL_EXPORT void CanonicalizeRef(const char16* spec,
+                                const url_parse::Component& path,
+                                CanonOutput* output,
+                                url_parse::Component* out_path);
 
 // Full canonicalizer ---------------------------------------------------------
 //
 // These functions replace any string contents, rather than append as above.
 // See the above piece-by-piece functions for information specific to
 // canonicalizing individual components.
 //
 // The output will be ASCII except the reference fragment, which may be UTF-8.
 //
 // The 8-bit versions require UTF-8 encoding.
 
 // Use for standard URLs with authorities and paths.
-bool CanonicalizeStandardURL(const char* spec,
-                             int spec_len,
-                             const url_parse::Parsed& parsed,
-                             CharsetConverter* query_converter,
-                             CanonOutput* output,
-                             url_parse::Parsed* new_parsed);
-bool CanonicalizeStandardURL(const char16* spec,
-                             int spec_len,
-                             const url_parse::Parsed& parsed,
-                             CharsetConverter* query_converter,
-                             CanonOutput* output,
-                             url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeStandardURL(const char* spec,
+                                        int spec_len,
+                                        const url_parse::Parsed& parsed,
+                                        CharsetConverter* query_converter,
+                                        CanonOutput* output,
+                                        url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeStandardURL(const char16* spec,
+                                        int spec_len,
+                                        const url_parse::Parsed& parsed,
+                                        CharsetConverter* query_converter,
+                                        CanonOutput* output,
+                                        url_parse::Parsed* new_parsed);
 
 // Use for file URLs.
-bool CanonicalizeFileURL(const char* spec,
-                         int spec_len,
-                         const url_parse::Parsed& parsed,
-                         CharsetConverter* query_converter,
-                         CanonOutput* output,
-                         url_parse::Parsed* new_parsed);
-bool CanonicalizeFileURL(const char16* spec,
-                         int spec_len,
-                         const url_parse::Parsed& parsed,
-                         CharsetConverter* query_converter,
-                         CanonOutput* output,
-                         url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeFileURL(const char* spec,
+                                    int spec_len,
+                                    const url_parse::Parsed& parsed,
+                                    CharsetConverter* query_converter,
+                                    CanonOutput* output,
+                                    url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeFileURL(const char16* spec,
+                                    int spec_len,
+                                    const url_parse::Parsed& parsed,
+                                    CharsetConverter* query_converter,
+                                    CanonOutput* output,
+                                    url_parse::Parsed* new_parsed);
 
 // Use for filesystem URLs.
-bool CanonicalizeFileSystemURL(const char* spec,
-                               int spec_len,
-                               const url_parse::Parsed& parsed,
-                               CharsetConverter* query_converter,
-                               CanonOutput* output,
-                               url_parse::Parsed* new_parsed);
-bool CanonicalizeFileSystemURL(const char16* spec,
-                               int spec_len,
-                               const url_parse::Parsed& parsed,
-                               CharsetConverter* query_converter,
-                               CanonOutput* output,
-                               url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeFileSystemURL(const char* spec,
+                                          int spec_len,
+                                          const url_parse::Parsed& parsed,
+                                          CharsetConverter* query_converter,
+                                          CanonOutput* output,
+                                          url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeFileSystemURL(const char16* spec,
+                                          int spec_len,
+                                          const url_parse::Parsed& parsed,
+                                          CharsetConverter* query_converter,
+                                          CanonOutput* output,
+                                          url_parse::Parsed* new_parsed);
 
 // Use for path URLs such as javascript. This does not modify the path in any
 // way, for example, by escaping it.
-bool CanonicalizePathURL(const char* spec,
-                         int spec_len,
-                         const url_parse::Parsed& parsed,
-                         CanonOutput* output,
-                         url_parse::Parsed* new_parsed);
-bool CanonicalizePathURL(const char16* spec,
-                         int spec_len,
-                         const url_parse::Parsed& parsed,
-                         CanonOutput* output,
-                         url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizePathURL(const char* spec,
+                                    int spec_len,
+                                    const url_parse::Parsed& parsed,
+                                    CanonOutput* output,
+                                    url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizePathURL(const char16* spec,
+                                    int spec_len,
+                                    const url_parse::Parsed& parsed,
+                                    CanonOutput* output,
+                                    url_parse::Parsed* new_parsed);
 
 // Use for mailto URLs. This "canonicalizes" the url into a path and query
 // component. It does not attempt to merge "to" fields. It uses UTF-8 for
 // the query encoding if there is a query. This is because a mailto URL is
 // really intended for an external mail program, and the encoding of a page,
 // etc. which would influence a query encoding normally are irrelevant.
-bool CanonicalizeMailtoURL(const char* spec,
-                           int spec_len,
-                           const url_parse::Parsed& parsed,
-                           CanonOutput* output,
-                           url_parse::Parsed* new_parsed);
-bool CanonicalizeMailtoURL(const char16* spec,
-                           int spec_len,
-                           const url_parse::Parsed& parsed,
-                           CanonOutput* output,
-                           url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeMailtoURL(const char* spec,
+                                      int spec_len,
+                                      const url_parse::Parsed& parsed,
+                                      CanonOutput* output,
+                                      url_parse::Parsed* new_parsed);
+URL_EXPORT bool CanonicalizeMailtoURL(const char16* spec,
+                                      int spec_len,
+                                      const url_parse::Parsed& parsed,
+                                      CanonOutput* output,
+                                      url_parse::Parsed* new_parsed);
 
 // Part replacer --------------------------------------------------------------
 
 // Internal structure used for storing separate strings for each component.
 // The basic canonicalization functions use this structure internally so that
 // component replacement (different strings for different components) can be
 // treated on the same code path as regular canonicalization (the same string
 // for each component).
 //
 // A url_parse::Parsed structure usually goes along with this. Those
@@ skipping 164 matching lines @@
   // Replace component      | (replacement string)  (replacement component)
   // Delete component       | (non-NULL)            (invalid component: (0,-1))
   //
   // We use a pointer to the empty string for the source when the component
   // should be deleted.
   URLComponentSource<CHAR> sources_;
   url_parse::Parsed components_;
 };
 
 // The base must be an 8-bit canonical URL.
-bool ReplaceStandardURL(const char* base,
-                        const url_parse::Parsed& base_parsed,
-                        const Replacements<char>& replacements,
-                        CharsetConverter* query_converter,
-                        CanonOutput* output,
-                        url_parse::Parsed* new_parsed);
-bool ReplaceStandardURL(const char* base,
-                        const url_parse::Parsed& base_parsed,
-                        const Replacements<char16>& replacements,
-                        CharsetConverter* query_converter,
-                        CanonOutput* output,
-                        url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceStandardURL(const char* base,
+                                   const url_parse::Parsed& base_parsed,
+                                   const Replacements<char>& replacements,
+                                   CharsetConverter* query_converter,
+                                   CanonOutput* output,
+                                   url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceStandardURL(const char* base,
+                                   const url_parse::Parsed& base_parsed,
+                                   const Replacements<char16>& replacements,
+                                   CharsetConverter* query_converter,
+                                   CanonOutput* output,
+                                   url_parse::Parsed* new_parsed);
 
 // Filesystem URLs can only have the path, query, or ref replaced.
 // All other components will be ignored.
-bool ReplaceFileSystemURL(const char* base,
-                          const url_parse::Parsed& base_parsed,
-                          const Replacements<char>& replacements,
-                          CharsetConverter* query_converter,
-                          CanonOutput* output,
-                          url_parse::Parsed* new_parsed);
-bool ReplaceFileSystemURL(const char* base,
-                          const url_parse::Parsed& base_parsed,
-                          const Replacements<char16>& replacements,
-                          CharsetConverter* query_converter,
-                          CanonOutput* output,
-                          url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceFileSystemURL(const char* base,
+                                     const url_parse::Parsed& base_parsed,
+                                     const Replacements<char>& replacements,
+                                     CharsetConverter* query_converter,
+                                     CanonOutput* output,
+                                     url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceFileSystemURL(const char* base,
+                                     const url_parse::Parsed& base_parsed,
+                                     const Replacements<char16>& replacements,
+                                     CharsetConverter* query_converter,
+                                     CanonOutput* output,
+                                     url_parse::Parsed* new_parsed);
 
 // Replacing some parts of a file URL is not permitted. Everything except
 // the host, path, query, and ref will be ignored.
-bool ReplaceFileURL(const char* base,
-                    const url_parse::Parsed& base_parsed,
-                    const Replacements<char>& replacements,
-                    CharsetConverter* query_converter,
-                    CanonOutput* output,
-                    url_parse::Parsed* new_parsed);
-bool ReplaceFileURL(const char* base,
-                    const url_parse::Parsed& base_parsed,
-                    const Replacements<char16>& replacements,
-                    CharsetConverter* query_converter,
-                    CanonOutput* output,
-                    url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceFileURL(const char* base,
+                               const url_parse::Parsed& base_parsed,
+                               const Replacements<char>& replacements,
+                               CharsetConverter* query_converter,
+                               CanonOutput* output,
+                               url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceFileURL(const char* base,
+                               const url_parse::Parsed& base_parsed,
+                               const Replacements<char16>& replacements,
+                               CharsetConverter* query_converter,
+                               CanonOutput* output,
+                               url_parse::Parsed* new_parsed);
 
 // Path URLs can only have the scheme and path replaced. All other components
 // will be ignored.
-bool ReplacePathURL(const char* base,
-                    const url_parse::Parsed& base_parsed,
-                    const Replacements<char>& replacements,
-                    CanonOutput* output,
-                    url_parse::Parsed* new_parsed);
-bool ReplacePathURL(const char* base,
-                    const url_parse::Parsed& base_parsed,
-                    const Replacements<char16>& replacements,
-                    CanonOutput* output,
-                    url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplacePathURL(const char* base,
+                               const url_parse::Parsed& base_parsed,
+                               const Replacements<char>& replacements,
+                               CanonOutput* output,
+                               url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplacePathURL(const char* base,
+                               const url_parse::Parsed& base_parsed,
+                               const Replacements<char16>& replacements,
+                               CanonOutput* output,
+                               url_parse::Parsed* new_parsed);
 
 // Mailto URLs can only have the scheme, path, and query replaced.
 // All other components will be ignored.
-bool ReplaceMailtoURL(const char* base,
-                      const url_parse::Parsed& base_parsed,
-                      const Replacements<char>& replacements,
-                      CanonOutput* output,
-                      url_parse::Parsed* new_parsed);
-bool ReplaceMailtoURL(const char* base,
-                      const url_parse::Parsed& base_parsed,
-                      const Replacements<char16>& replacements,
-                      CanonOutput* output,
-                      url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceMailtoURL(const char* base,
+                                 const url_parse::Parsed& base_parsed,
+                                 const Replacements<char>& replacements,
+                                 CanonOutput* output,
+                                 url_parse::Parsed* new_parsed);
+URL_EXPORT bool ReplaceMailtoURL(const char* base,
+                                 const url_parse::Parsed& base_parsed,
+                                 const Replacements<char16>& replacements,
+                                 CanonOutput* output,
+                                 url_parse::Parsed* new_parsed);
 
 // Relative URL ---------------------------------------------------------------
 
 // Given an input URL or URL fragment |fragment|, determines if it is a
 // relative or absolute URL and places the result into |*is_relative|. If it is
 // relative, the relevant portion of the URL will be placed into
 // |*relative_component| (there may have been trimmed whitespace, for example).
 // This value is passed to ResolveRelativeURL. If the input is not relative,
 // this value is UNDEFINED (it may be changed by the function).
 //
 // Returns true on success (we successfully determined the URL is relative or
 // not). Failure means that the combination of URLs doesn't make any sense.
 //
 // The base URL should always be canonical, therefore is ASCII.
-bool IsRelativeURL(const char* base,
-                   const url_parse::Parsed& base_parsed,
-                   const char* fragment,
-                   int fragment_len,
-                   bool is_base_hierarchical,
-                   bool* is_relative,
-                   url_parse::Component* relative_component);
-bool IsRelativeURL(const char* base,
-                   const url_parse::Parsed& base_parsed,
-                   const char16* fragment,
-                   int fragment_len,
-                   bool is_base_hierarchical,
-                   bool* is_relative,
-                   url_parse::Component* relative_component);
+URL_EXPORT bool IsRelativeURL(const char* base,
+                              const url_parse::Parsed& base_parsed,
+                              const char* fragment,
+                              int fragment_len,
+                              bool is_base_hierarchical,
+                              bool* is_relative,
+                              url_parse::Component* relative_component);
+URL_EXPORT bool IsRelativeURL(const char* base,
+                              const url_parse::Parsed& base_parsed,
+                              const char16* fragment,
+                              int fragment_len,
+                              bool is_base_hierarchical,
+                              bool* is_relative,
+                              url_parse::Component* relative_component);
 
 // Given a canonical parsed source URL, a URL fragment known to be relative,
 // and the identified relevant portion of the relative URL (computed by
 // IsRelativeURL), this produces a new parsed canonical URL in |output| and
 // |out_parsed|.
 //
 // It also requires a flag indicating whether the base URL is a file: URL
 // which triggers additional logic.
 //
 // The base URL should be canonical and have a host (may be empty for file
 // URLs) and a path. If it doesn't have these, we can't resolve relative
 // URLs off of it and will return the base as the output with an error flag.
 // Becausee it is canonical is should also be ASCII.
 //
 // The query charset converter follows the same rules as CanonicalizeQuery.
 //
 // Returns true on success. On failure, the output will be "something
 // reasonable" that will be consistent and valid, just probably not what
 // was intended by the web page author or caller.
-bool ResolveRelativeURL(const char* base_url,
-                        const url_parse::Parsed& base_parsed,
-                        bool base_is_file,
-                        const char* relative_url,
-                        const url_parse::Component& relative_component,
-                        CharsetConverter* query_converter,
-                        CanonOutput* output,
-                        url_parse::Parsed* out_parsed);
-bool ResolveRelativeURL(const char* base_url,
-                        const url_parse::Parsed& base_parsed,
-                        bool base_is_file,
-                        const char16* relative_url,
-                        const url_parse::Component& relative_component,
-                        CharsetConverter* query_converter,
-                        CanonOutput* output,
-                        url_parse::Parsed* out_parsed);
+URL_EXPORT bool ResolveRelativeURL(
+    const char* base_url,
+    const url_parse::Parsed& base_parsed,
+    bool base_is_file,
+    const char* relative_url,
+    const url_parse::Component& relative_component,
+    CharsetConverter* query_converter,
+    CanonOutput* output,
+    url_parse::Parsed* out_parsed);
+URL_EXPORT bool ResolveRelativeURL(
+    const char* base_url,
+    const url_parse::Parsed& base_parsed,
+    bool base_is_file,
+    const char16* relative_url,
+    const url_parse::Component& relative_component,
+    CharsetConverter* query_converter,
+    CanonOutput* output,
+    url_parse::Parsed* out_parsed);
 
 }  // namespace url_canon
 
 #endif  // URL_URL_CANON_H_