url: Build it as a static library.

url/url_parse.h

 // Copyright 2007, Google 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 GOOGLEURL_SRC_URL_PARSE_H__
-#define GOOGLEURL_SRC_URL_PARSE_H__
+#ifndef URL_URL_PARSE_H_
+#define URL_URL_PARSE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
-#include "googleurl/src/url_common.h"
 
 namespace url_parse {
 
 // Deprecated, but WebKit/WebCore/platform/KURLGooglePrivate.h and
 // KURLGoogle.cpp still rely on this type.
 typedef char16 UTF16Char;
 
 // Component ------------------------------------------------------------------
 
 // Represents a substring for URL parsing.
@@ skipping 66 matching lines @@
     PASSWORD,
     HOST,
     PORT,
     PATH,
     QUERY,
     REF,
   };
 
   // The default constructor is sufficient for the components, but inner_parsed_
   // requires special handling.
-  GURL_API Parsed();
-  GURL_API Parsed(const Parsed&);
-  GURL_API Parsed& operator=(const Parsed&);
-  GURL_API ~Parsed();
+  Parsed();
+  Parsed(const Parsed&);
+  Parsed& operator=(const Parsed&);
+  ~Parsed();
 
   // Returns the length of the URL (the end of the last component).
   //
   // Note that for some invalid, non-canonical URLs, this may not be the length
   // of the string. For example "http://": the parsed structure will only
   // contain an entry for the four-character scheme, and it doesn't know about
   // the "://". For all other last-components, it will return the real length.
-  GURL_API int Length() const;
+  int Length() const;
 
   // Returns the number of characters before the given component if it exists,
   // or where the component would be if it did exist. This will return the
   // string length if the component would be appended to the end.
   //
   // Note that this can get a little funny for the port, query, and ref
   // components which have a delimiter that is not counted as part of the
   // component. The |include_delimiter| flag controls if you want this counted
   // as part of the component or not when the component exists.
   //
   // This example shows the difference between the two flags for two of these
   // delimited components that is present (the port and query) and one that
   // isn't (the reference). The components that this flag affects are marked
   // with a *.
   //                 0         1         2
   //                 012345678901234567890
   // Example input:  http://foo:80/?query
   //              include_delim=true,  ...=false  ("<-" indicates different)
   //      SCHEME: 0                    0
   //    USERNAME: 5                    5
   //    PASSWORD: 5                    5
   //        HOST: 7                    7
   //       *PORT: 10                   11 <-
   //        PATH: 13                   13
   //      *QUERY: 14                   15 <-
   //        *REF: 20                   20
   //
-  GURL_API int CountCharactersBefore(ComponentType type,
-                                     bool include_delimiter) const;
+  int CountCharactersBefore(ComponentType type,
+                            bool include_delimiter) const;
 
   // Scheme without the colon: "http://foo"/ would have a scheme of "http".
   // The length will be -1 if no scheme is specified ("foo.com"), or 0 if there
   // is a colon but no scheme (":foo"). Note that the scheme is not guaranteed
   // to start at the beginning of the string if there are preceeding whitespace
   // or control characters.
   Component scheme;
 
   // Username. Specified in URLs with an @ sign before the host. See |password|
   Component username;
@@ skipping 64 matching lines @@
 // at any point in the process, and will actually handle embedded NULLs.
 //
 // IMPORTANT: These functions do NOT hang on to the given pointer or copy it
 // in any way. See the comment above the struct.
 //
 // The 8-bit versions require UTF-8 encoding.
 
 // StandardURL is for when the scheme is known to be one that has an
 // authority (host) like "http". This function will not handle weird ones
 // like "about:" and "javascript:", or do the right thing for "file:" URLs.
-GURL_API void ParseStandardURL(const char* url, int url_len, Parsed* parsed);
-GURL_API void ParseStandardURL(const char16* url, int url_len, Parsed* parsed);
+void ParseStandardURL(const char* url, int url_len, Parsed* parsed);
+void ParseStandardURL(const char16* url, int url_len, Parsed* parsed);
 
 // PathURL is for when the scheme is known not to have an authority (host)
 // section but that aren't file URLs either. The scheme is parsed, and
 // everything after the scheme is considered as the path. This is used for
 // things like "about:" and "javascript:"
-GURL_API void ParsePathURL(const char* url, int url_len, Parsed* parsed);
-GURL_API void ParsePathURL(const char16* url, int url_len, Parsed* parsed);
+void ParsePathURL(const char* url, int url_len, Parsed* parsed);
+void ParsePathURL(const char16* url, int url_len, Parsed* parsed);
 
 // FileURL is for file URLs. There are some special rules for interpreting
 // these.
-GURL_API void ParseFileURL(const char* url, int url_len, Parsed* parsed);
-GURL_API void ParseFileURL(const char16* url, int url_len, Parsed* parsed);
+void ParseFileURL(const char* url, int url_len, Parsed* parsed);
+void ParseFileURL(const char16* url, int url_len, Parsed* parsed);
 
 // Filesystem URLs are structured differently than other URLs.
-GURL_API void ParseFileSystemURL(const char* url,
-                                 int url_len,
-                                 Parsed* parsed);
-GURL_API void ParseFileSystemURL(const char16* url,
-                                 int url_len,
-                                 Parsed* parsed);
+void ParseFileSystemURL(const char* url,
+                        int url_len,
+                        Parsed* parsed);
+void ParseFileSystemURL(const char16* url,
+                        int url_len,
+                        Parsed* parsed);
 
 // MailtoURL is for mailto: urls. They are made up scheme,path,query
-GURL_API void ParseMailtoURL(const char* url, int url_len, Parsed* parsed);
-GURL_API void ParseMailtoURL(const char16* url, int url_len, Parsed* parsed);
+void ParseMailtoURL(const char* url, int url_len, Parsed* parsed);
+void ParseMailtoURL(const char16* url, int url_len, Parsed* parsed);
 
 // Helper functions -----------------------------------------------------------
 
 // Locates the scheme according to the URL  parser's rules. This function is
 // designed so the caller can find the scheme and call the correct Init*
 // function according to their known scheme types.
 //
 // It also does not perform any validation on the scheme.
 //
 // This function will return true if the scheme is found and will put the
 // scheme's range into *scheme. False means no scheme could be found. Note
 // that a URL beginning with a colon has a scheme, but it is empty, so this
 // function will return true but *scheme will = (0,0).
 //
 // The scheme is found by skipping spaces and control characters at the
 // beginning, and taking everything from there to the first colon to be the
 // scheme. The character at scheme.end() will be the colon (we may enhance
 // this to handle full width colons or something, so don't count on the
 // actual character value). The character at scheme.end()+1 will be the
 // beginning of the rest of the URL, be it the authority or the path (or the
 // end of the string).
 //
 // The 8-bit version requires UTF-8 encoding.
-GURL_API bool ExtractScheme(const char* url, int url_len, Component* scheme);
-GURL_API bool ExtractScheme(const char16* url, int url_len, Component* scheme);
+bool ExtractScheme(const char* url, int url_len, Component* scheme);
+bool ExtractScheme(const char16* url, int url_len, Component* scheme);
 
 // Returns true if ch is a character that terminates the authority segment
 // of a URL.
-GURL_API bool IsAuthorityTerminator(char16 ch);
+bool IsAuthorityTerminator(char16 ch);
 
 // Does a best effort parse of input |spec|, in range |auth|. If a particular
 // component is not found, it will be set to invalid.
-GURL_API void ParseAuthority(const char* spec,
-                             const Component& auth,
-                             Component* username,
-                             Component* password,
-                             Component* hostname,
-                             Component* port_num);
-GURL_API void ParseAuthority(const char16* spec,
-                             const Component& auth,
-                             Component* username,
-                             Component* password,
-                             Component* hostname,
-                             Component* port_num);
+void ParseAuthority(const char* spec,
+                    const Component& auth,
+                    Component* username,
+                    Component* password,
+                    Component* hostname,
+                    Component* port_num);
+void ParseAuthority(const char16* spec,
+                    const Component& auth,
+                    Component* username,
+                    Component* password,
+                    Component* hostname,
+                    Component* port_num);
 
 // Computes the integer port value from the given port component. The port
 // component should have been identified by one of the init functions on
 // |Parsed| for the given input url.
 //
 // The return value will be a positive integer between 0 and 64K, or one of
 // the two special values below.
 enum SpecialPort { PORT_UNSPECIFIED = -1, PORT_INVALID = -2 };
-GURL_API int ParsePort(const char* url, const Component& port);
-GURL_API int ParsePort(const char16* url, const Component& port);
+int ParsePort(const char* url, const Component& port);
+int ParsePort(const char16* url, const Component& port);
 
 // Extracts the range of the file name in the given url. The path must
 // already have been computed by the parse function, and the matching URL
 // and extracted path are provided to this function. The filename is
 // defined as being everything from the last slash/backslash of the path
 // to the end of the path.
 //
 // The file name will be empty if the path is empty or there is nothing
 // following the last slash.
 //
 // The 8-bit version requires UTF-8 encoding.
-GURL_API void ExtractFileName(const char* url,
-                              const Component& path,
-                              Component* file_name);
-GURL_API void ExtractFileName(const char16* url,
-                              const Component& path,
-                              Component* file_name);
+void ExtractFileName(const char* url,
+                     const Component& path,
+                     Component* file_name);
+void ExtractFileName(const char16* url,
+                     const Component& path,
+                     Component* file_name);
 
 // Extract the first key/value from the range defined by |*query|. Updates
 // |*query| to start at the end of the extracted key/value pair. This is
 // designed for use in a loop: you can keep calling it with the same query
 // object and it will iterate over all items in the query.
 //
 // Some key/value pairs may have the key, the value, or both be empty (for
 // example, the query string "?&"). These will be returned. Note that an empty
 // last parameter "foo.com?" or foo.com?a&" will not be returned, this case
 // is the same as "done."
 //
 // The initial query component should not include the '?' (this is the default
 // for parsed URLs).
 //
 // If no key/value are found |*key| and |*value| will be unchanged and it will
 // return false.
-GURL_API bool ExtractQueryKeyValue(const char* url,
-                                   Component* query,
-                                   Component* key,
-                                   Component* value);
-GURL_API bool ExtractQueryKeyValue(const char16* url,
-                                   Component* query,
-                                   Component* key,
-                                   Component* value);
+bool ExtractQueryKeyValue(const char* url,
+                          Component* query,
+                          Component* key,
+                          Component* value);
+bool ExtractQueryKeyValue(const char16* url,
+                          Component* query,
+                          Component* key,
+                          Component* value);
 
 }  // namespace url_parse
 
-#endif  // GOOGLEURL_SRC_URL_PARSE_H__
+#endif  // URL_URL_PARSE_H_