/*
 * Copyright 2007 Google Inc. All rights reserved.
 * Copyright 2012 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef URLCanon_h
#define URLCanon_h

#include "URLBuffer.h"
#include "URLParse.h"
#include <stdlib.h>
#include <wtf/unicode/Unicode.h>

#if USE(WTFURL)

namespace WTF {

class URLQueryCharsetConverter;

namespace URLCanonicalizer {

// Whitespace -----------------------------------------------------------------

// Searches for whitespace that should be removed from the middle of URLs, and
// removes it. Removed whitespace are tabs and newlines, but NOT spaces. Spaces
// are preserved, which is what most browsers do. A pointer to the output will
// be returned, and the length of that output will be in |outputLength|.
//
// 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 |outputLength| instead.
const char* removeURLWhitespace(const char* input, int inputLength, URLBuffer<char>&, int& outputLength);
const UChar* removeURLWhitespace(const UChar* input, int inputLength, URLBuffer<UChar>&, int& outputLength);

// 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 UChar* src, int sourceLength, URLBuffer<UChar>& 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 URLComponent& scheme, URLBuffer<char>&, URLComponent& ouputScheme);
bool canonicalizeScheme(const UChar* spec, const URLComponent& scheme, URLBuffer<char>&, URLComponent& ouputScheme);

// 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* usernameSource, const URLComponent& username, const char* passwordSource, const URLComponent& password,
                          URLBuffer<char>&, URLComponent& outputUsername, URLComponent& outputPassword);
bool canonicalizeUserInfo(const UChar* usernameSource, const URLComponent& username, const UChar* passwordSource, const URLComponent& password,
                          URLBuffer<char>&, URLComponent& outputUsername, URLComponent& outputPassword);


// 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)
        , ipv4ComponentsCount(0)
        , ouputHost()
    {
    }

    // Convenience function to test if family is an IP address.
    bool IsIPAddress() const { return family == IPV4 || family == IPV6; }

    // This field summarizes how the input was classified by the canonicalizer.
    enum Family {
        // - Doesn't resemble an IP address. As far as the IP
        // canonicalizer is concerned, it should be treated as a
        //   hostname.
        NEUTRAL,

        // - Almost an IP, but was not canonicalized. This could be an
        // IPv4 address where truncation occurred, or something
        // containing the special characters :[] which did not parse
        // as an IPv6 address. Never attempt to connect to this
        // address, because it might actually succeed!
        BROKEN,

        IPV4, // - Successfully canonicalized as an IPv4 address.
        IPV6, // - Successfully canonicalized as an IPv6 address.
    };
    Family family;

    // If |family| is IPV4, then this is the number of nonempty dot-separated
    // components in the input text, from 1 to 4. If |family| is not IPV4,
    // this value is undefined.
    int ipv4ComponentsCount;

    // Location of host within the canonicalized output.
    // canonicalizeIPAddress() only sets this field if |family| is IPV4 or IPV6.
    URLComponent ouputHost;

    // |address| contains the parsed IP Address (if any) in its first
    // AddressLength() bytes, in network order. If IsIPAddress() is false
    // AddressLength() will return zero and the content of |address| is undefined.
    unsigned char address[16];

    // Convenience function to calculate the length of an IP address corresponding
    // to the current IP version in |family|, if any. For use with |address|.
    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 URLComponent& host, URLBuffer<char>&, URLComponent& ouputHost);
bool canonicalizeHost(const UChar* spec, const URLComponent& host, URLBuffer<char>&, URLComponent& ouputHost);

// 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 |*hostInfo| 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 URLComponent& host, URLBuffer<char>&, CanonHostInfo&);
void canonicalizeIPAddress(const UChar* spec, const URLComponent& host, URLBuffer<char>&, CanonHostInfo&);

// Port: this function will add the colon for the port if a port is present.
// The caller can pass URLParser::PORT_UNSPECIFIED as the
// defaultPortForScheme argument if there is no default port.
//
// The 8-bit version requires UTF-8 encoding.
bool canonicalizePort(const char* spec, const URLComponent& port, int defaultPortForScheme, URLBuffer<char>&, URLComponent& ouputPort);
bool canonicalizePort(const UChar* spec, const URLComponent& port, int defaultPortForScheme, URLBuffer<char>&, URLComponent& ouputPort);

// Returns the default port for the given canonical scheme, or PORT_UNSPECIFIED
// if the scheme is unknown.
int defaultPortForScheme(const char* scheme, int schemeLength);

// 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 URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
bool CanonicalizePath(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);

// 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 |outputPath| will be updated.
//
// The 8-bit version requires UTF-8 encoding.
bool FileCanonicalizePath(const char* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
bool FileCanonicalizePath(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);

// 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 URLComponent& query, URLQueryCharsetConverter*, URLBuffer<char>&, URLComponent* outputQuery);
void CanonicalizeQuery(const UChar* spec, const URLComponent& query, URLQueryCharsetConverter*, URLBuffer<char>&, URLComponent* outputQuery);

// 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 canonicalizeFragment(const char* spec, const URLComponent& path, URLBuffer<char>&, URLComponent& outputFragment);
void canonicalizeFragment(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent& outputFragment);

// 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 specLength, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                             URLBuffer<char>&, URLSegments* outputParsed);
bool CanonicalizeStandardURL(const UChar* spec, int specLength, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                             URLBuffer<char>&, URLSegments* outputParsed);

// Use for file URLs.
bool CanonicalizeFileURL(const char* spec, int specLength, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                         URLBuffer<char>&, URLSegments* outputParsed);
bool CanonicalizeFileURL(const UChar* spec, int specLength, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                         URLBuffer<char>&, URLSegments* outputParsed);

// Use for filesystem URLs.
bool canonicalizeFileSystemURL(const char* spec, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                               URLBuffer<char>&, URLSegments& outputParsed);
bool canonicalizeFileSystemURL(const UChar* spec, const URLSegments& parsed, URLQueryCharsetConverter* queryConverter,
                               URLBuffer<char>&, URLSegments& outputParsed);

// 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, const URLSegments& parsed, URLBuffer<char>& output, URLSegments& ouputParsed);
bool canonicalizePathURL(const UChar* spec, const URLSegments& parsed, URLBuffer<char>& output, URLSegments& ouputParsed);

// 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, const URLSegments& parsed, URLBuffer<char>&, URLSegments& outputParsed);
bool canonicalizeMailtoURL(const UChar* spec,  const URLSegments& parsed, URLBuffer<char>&, URLSegments& outputParsed);

// 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 URLSegments structure usually goes along with this. Those
// components identify offsets within these strings, so that they can all be
// in the same string, or spread arbitrarily across different ones.
//
// This structures does not own any data. It is the caller's responsibility to
// ensure that the data the pointers point to stays in scope and is not
// modified.
template<typename CharacterType>
struct URLComponentSource {
    // Constructor normally used by callers wishing to replace components. This
    // will make them all null, which is no replacement. The caller would then
    // override the components they want to replace.
    URLComponentSource()
        : scheme(0)
        , username(0)
        , password(0)
        , host(0)
        , port(0)
        , path(0)
        , query(0)
        , ref(0)
    {
    }

    // Constructor normally used internally to initialize all the components to
    // point to the same spec.
    explicit URLComponentSource(const CharacterType* defaultValue)
        : scheme(defaultValue)
        , username(defaultValue)
        , password(defaultValue)
        , host(defaultValue)
        , port(defaultValue)
        , path(defaultValue)
        , query(defaultValue)
        , ref(defaultValue)
    {
    }

    const CharacterType* scheme;
    const CharacterType* username;
    const CharacterType* password;
    const CharacterType* host;
    const CharacterType* port;
    const CharacterType* path;
    const CharacterType* query;
    const CharacterType* ref;
};

// This structure encapsulates information on modifying a URL. Each component
// may either be left unchanged, replaced, or deleted.
//
// By default, each component is unchanged. For those components that should be
// modified, call either Set* or Clear* to modify it.
//
// The string passed to Set* functions DOES NOT GET COPIED AND MUST BE KEPT
// IN SCOPE BY THE CALLER for as long as this object exists!
//
// Prefer the 8-bit replacement version if possible since it is more efficient.
template<typename CharacterType>
class Replacements {
public:
    Replacements()
    {
    }

    // Scheme
    void SetScheme(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.scheme = s;
        m_segments.scheme = comp;
    }
    // Note: we don't have a ClearScheme since this doesn't make any sense.
    bool IsSchemeOverridden() const { return !!m_sources.scheme; }

    // Username
    void SetUsername(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.username = s;
        m_segments.username = comp;
    }
    void ClearUsername()
    {
        m_sources.username = Placeholder();
        m_segments.username = URLComponent();
    }
    bool IsUsernameOverridden() const { return !!m_sources.username; }

    // Password
    void SetPassword(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.password = s;
        m_segments.password = comp;
    }
    void ClearPassword()
    {
        m_sources.password = Placeholder();
        m_segments.password = URLComponent();
    }
    bool IsPasswordOverridden() const { return !!m_sources.password; }

    // Host
    void SetHost(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.host = s;
        m_segments.host = comp;
    }
    void ClearHost()
    {
        m_sources.host = Placeholder();
        m_segments.host = URLComponent();
    }
    bool IsHostOverridden() const { return !!m_sources.host; }

    // Port
    void SetPort(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.port = s;
        m_segments.port = comp;
    }
    void ClearPort()
    {
        m_sources.port = Placeholder();
        m_segments.port = URLComponent();
    }
    bool IsPortOverridden() const { return !!m_sources.port; }

    // Path
    void SetPath(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.path = s;
        m_segments.path = comp;
    }
    void ClearPath()
    {
        m_sources.path = Placeholder();
        m_segments.path = URLComponent();
    }
    bool IsPathOverridden() const { return !m_sources.path; }

    // Query
    void SetQuery(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.query = s;
        m_segments.query = comp;
    }
    void ClearQuery()
    {
        m_sources.query = Placeholder();
        m_segments.query = URLComponent();
    }
    bool IsQueryOverridden() const { return !m_sources.query; }

    // Ref
    void SetRef(const CharacterType* s, const URLComponent& comp)
    {
        m_sources.ref = s;
        m_segments.fragment = comp;
    }
    void ClearRef()
    {
        m_sources.ref = Placeholder();
        m_segments.fragment = URLComponent();
    }
    bool IsRefOverridden() const { return !m_sources.ref; }

    // Getters for the itnernal data. See the variables below for how the
    // information is encoded.
    const URLComponentSource<CharacterType>& sources() const { return m_sources; }
    const URLSegments& components() const { return m_segments; }

private:
    // Returns a pointer to a static empty string that is used as a placeholder
    // to indicate a component should be deleted (see below).
    const CharacterType* Placeholder()
    {
        static const CharacterType emptyString = 0;
        return &emptyString;
    }

    // We support three states:
    //
    // Action                 | Source                Component
    // -----------------------+--------------------------------------------------
    // Don't change component | null                  (unused)
    // 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<CharacterType> m_sources;
    URLSegments m_segments;
};

// The base must be an 8-bit canonical URL.
bool ReplaceStandardURL(const char* base,
                        const URLSegments& baseParsed,
                        const Replacements<char>&,
                        URLQueryCharsetConverter* queryConverter,
                        URLBuffer<char>&,
                        URLSegments* outputParsed);
bool ReplaceStandardURL(const char* base,
                        const URLSegments& baseParsed,
                        const Replacements<UChar>&,
                        URLQueryCharsetConverter* queryConverter,
                        URLBuffer<char>&,
                        URLSegments* outputParsed);

// Filesystem URLs can only have the path, query, or ref replaced.
// All other components will be ignored.
bool ReplaceFileSystemURL(const char* base,
                          const URLSegments& baseParsed,
                          const Replacements<char>&,
                          URLQueryCharsetConverter* queryConverter,
                          URLBuffer<char>&,
                          URLSegments* outputParsed);
bool ReplaceFileSystemURL(const char* base,
                          const URLSegments& baseParsed,
                          const Replacements<UChar>&,
                          URLQueryCharsetConverter* queryConverter,
                          URLBuffer<char>&,
                          URLSegments* outputParsed);

// 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 URLSegments& baseParsed,
                    const Replacements<char>&,
                    URLQueryCharsetConverter* queryConverter,
                    URLBuffer<char>&,
                    URLSegments* outputParsed);
bool ReplaceFileURL(const char* base,
                    const URLSegments& baseParsed,
                    const Replacements<UChar>&,
                    URLQueryCharsetConverter* queryConverter,
                    URLBuffer<char>&,
                    URLSegments* outputParsed);

// Path URLs can only have the scheme and path replaced. All other components
// will be ignored.
bool ReplacePathURL(const char* base,
                    const URLSegments& baseParsed,
                    const Replacements<char>&,
                    URLBuffer<char>&,
                    URLSegments* outputParsed);
bool ReplacePathURL(const char* base,
                    const URLSegments& baseParsed,
                    const Replacements<UChar>&,
                    URLBuffer<char>&,
                    URLSegments* outputParsed);

// Mailto URLs can only have the scheme, path, and query replaced.
// All other components will be ignored.
bool replaceMailtoURL(const char* base, const URLSegments& baseParsed,
                      const Replacements<char>&,
                      URLBuffer<char>& output, URLSegments& outputParsed);
bool replaceMailtoURL(const char* base, const URLSegments& baseParsed,
                      const Replacements<UChar>&,
                      URLBuffer<char>& output, URLSegments& outputParsed);

// Relative URL ---------------------------------------------------------------

// Given an input URL or URL fragment |fragment|, determines if it is a
// relative or absolute URL and places the result into |*isRelative|. If it is
// relative, the relevant portion of the URL will be placed into
// |*relativeComponent| (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 URLSegments& baseParsed,
                   const char* fragment, int fragmentLength,
                   bool isBaseHierarchical,
                   bool& isRelative, URLComponent& relativeComponent);
bool isRelativeURL(const char* base, const URLSegments& baseParsed,
                   const UChar* fragment, int fragmentLength,
                   bool isBaseHierarchical,
                   bool& isRelative, URLComponent& relativeComponent);

// 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
// |outputParsed|.
//
// 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* baseURL, const URLSegments& baseParsed, bool baseIsFile,
                        const char* relativeURL, const URLComponent& relativeComponent,
                        URLQueryCharsetConverter* queryConverter,
                        URLBuffer<char>&, URLSegments* outputParsed);
bool resolveRelativeURL(const char* baseURL, const URLSegments& baseParsed, bool baseIsFile,
                        const UChar* relativeURL, const URLComponent& relativeComponent,
                        URLQueryCharsetConverter* queryConverter,
                        URLBuffer<char>&, URLSegments* outputParsed);

} // namespace URLCanonicalizer

} // namespace WTF

#endif // USE(WTFURL)

#endif // URLCanon_h