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

trunk/src/url/url_parse.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_PARSE_H_
 #define URL_URL_PARSE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
+#include "url/url_export.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 51 matching lines @@
 //    if (!url_parse::ExtractScheme(url, url_len, &scheme))
 //      return I_CAN_NOT_FIND_THE_SCHEME_DUDE;
 //
 //    if (IsStandardScheme(url, scheme))  // Not provided by this component
 //      url_parseParseStandardURL(url, url_len, &parsed);
 //    else if (IsFileURL(url, scheme))    // Not provided by this component
 //      url_parse::ParseFileURL(url, url_len, &parsed);
 //    else
 //      url_parse::ParsePathURL(url, url_len, &parsed);
 //
-struct Parsed {
+struct URL_EXPORT Parsed {
   // Identifies different components.
   enum ComponentType {
     SCHEME,
     USERNAME,
     PASSWORD,
     HOST,
     PORT,
     PATH,
     QUERY,
     REF,
@@ skipping 33 matching lines @@
   //              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
   //
-  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.
-void ParseStandardURL(const char* url, int url_len, Parsed* parsed);
-void ParseStandardURL(const char16* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParseStandardURL(const char* url,
+                                 int url_len,
+                                 Parsed* parsed);
+URL_EXPORT 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:"
-void ParsePathURL(const char* url, int url_len, Parsed* parsed);
-void ParsePathURL(const char16* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParsePathURL(const char* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParsePathURL(const char16* url, int url_len, Parsed* parsed);
 
 // FileURL is for file URLs. There are some special rules for interpreting
 // these.
-void ParseFileURL(const char* url, int url_len, Parsed* parsed);
-void ParseFileURL(const char16* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParseFileURL(const char* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParseFileURL(const char16* url, int url_len, Parsed* parsed);
 
 // Filesystem URLs are structured differently than other URLs.
-void ParseFileSystemURL(const char* url,
-                        int url_len,
-                        Parsed* parsed);
-void ParseFileSystemURL(const char16* url,
-                        int url_len,
-                        Parsed* parsed);
+URL_EXPORT void ParseFileSystemURL(const char* url,
+                                   int url_len,
+                                   Parsed* parsed);
+URL_EXPORT void ParseFileSystemURL(const char16* url,
+                                   int url_len,
+                                   Parsed* parsed);
 
 // MailtoURL is for mailto: urls. They are made up scheme,path,query
-void ParseMailtoURL(const char* url, int url_len, Parsed* parsed);
-void ParseMailtoURL(const char16* url, int url_len, Parsed* parsed);
+URL_EXPORT void ParseMailtoURL(const char* url, int url_len, Parsed* parsed);
+URL_EXPORT 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.
-bool ExtractScheme(const char* url, int url_len, Component* scheme);
-bool ExtractScheme(const char16* url, int url_len, Component* scheme);
+URL_EXPORT bool ExtractScheme(const char* url,
+                              int url_len,
+                              Component* scheme);
+URL_EXPORT 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.
-bool IsAuthorityTerminator(char16 ch);
+URL_EXPORT 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.
-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);
+URL_EXPORT void ParseAuthority(const char* spec,
+                               const Component& auth,
+                               Component* username,
+                               Component* password,
+                               Component* hostname,
+                               Component* port_num);
+URL_EXPORT 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 };
-int ParsePort(const char* url, const Component& port);
-int ParsePort(const char16* url, const Component& port);
+URL_EXPORT int ParsePort(const char* url, const Component& port);
+URL_EXPORT 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.
-void ExtractFileName(const char* url,
-                     const Component& path,
-                     Component* file_name);
-void ExtractFileName(const char16* url,
-                     const Component& path,
-                     Component* file_name);
+URL_EXPORT void ExtractFileName(const char* url,
+                                const Component& path,
+                                Component* file_name);
+URL_EXPORT 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.
-bool ExtractQueryKeyValue(const char* url,
-                          Component* query,
-                          Component* key,
-                          Component* value);
-bool ExtractQueryKeyValue(const char16* url,
-                          Component* query,
-                          Component* key,
-                          Component* value);
+URL_EXPORT bool ExtractQueryKeyValue(const char* url,
+                                     Component* query,
+                                     Component* key,
+                                     Component* value);
+URL_EXPORT bool ExtractQueryKeyValue(const char16* url,
+                                     Component* query,
+                                     Component* key,
+                                     Component* value);
 
 }  // namespace url_parse
 
 #endif  // URL_URL_PARSE_H_