Fix inconsistent values of anchor element IDL attributes compare to other vendors

url/third_party/mozilla/url_parse.cc

 /* Based on nsURLParsers.cc from Mozilla
  * -------------------------------------
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
@@ skipping 546 matching lines @@
 
   // For compatability with the standard URL parser, treat no path as
   // -1, rather than having a length of 0
   if (path_begin == path_end) {
     parsed->path.reset();
   } else {
     parsed->path = MakeRange(path_begin, path_end);
   }
 }
 
+template <typename CHAR>
+void DoParseNonStandardURL(const CHAR* spec, int spec_len, Parsed* parsed) {
+  // Get the non-scheme parts of the URL out of the way, we don't know how to
+  // interpret them.
+  parsed->username.reset();
+  parsed->password.reset();
+  parsed->host.reset();
+  parsed->port.reset();
+  parsed->path.reset();
+  parsed->query.reset();
+  parsed->ref.reset();
+
+  // Strip leading & trailing spaces and control characters.
+  int scheme_begin = 0;
+  TrimURL(spec, &scheme_begin, &spec_len);
+
+  // Handle empty specs or ones that contain only whitespace or control chars.
+  if (scheme_begin == spec_len) {
+    parsed->scheme.reset();
+    parsed->path.reset();
+    return;
+  }
+
+  // Extract the scheme. We also
+  // handle the case where there is no scheme.
+  if (ExtractScheme(&spec[scheme_begin], spec_len - scheme_begin,
+                    &parsed->scheme)) {
+    // Offset the results since we gave ExtractScheme a substring.
+    parsed->scheme.begin += scheme_begin;
+  } else {
+    // No scheme case.
+    parsed->scheme.reset();
+  }
+}
+
 // Converts a port number in a string to an integer. We'd like to just call
 // sscanf but our input is not NULL-terminated, which sscanf requires. Instead,
 // we copy the digits to a small stack buffer (since we know the maximum number
 // of digits in a valid port number) that we can NULL terminate.
 template<typename CHAR>
 int DoParsePort(const CHAR* spec, const Component& component) {
   // Easy success case when there is no port.
   const int kMaxDigits = 5;
   if (!component.is_nonempty())
     return PORT_UNSPECIFIED;
@@ skipping 317 matching lines @@
 }
 
 void ParseMailtoURL(const char* url, int url_len, Parsed* parsed) {
   DoParseMailtoURL(url, url_len, parsed);
 }
 
 void ParseMailtoURL(const base::char16* url, int url_len, Parsed* parsed) {
   DoParseMailtoURL(url, url_len, parsed);
 }
 
+void ParseNonStandardURL(const char* url, int url_len, Parsed* parsed) {
+  DoParseNonStandardURL(url, url_len, parsed);
+}
+
+void ParseNonStandardURL(const base::char16* url, int url_len, Parsed* parsed) {
+  DoParseNonStandardURL(url, url_len, parsed);
+}
+
 void ParsePathInternal(const char* spec,
                        const Component& path,
                        Component* filepath,
                        Component* query,
                        Component* ref) {
   ParsePath(spec, path, filepath, query, ref);
 }
 
 void ParsePathInternal(const base::char16* spec,
                        const Component& path,
@@ skipping 11 matching lines @@
 }
 
 void ParseAfterScheme(const base::char16* spec,
                       int spec_len,
                       int after_scheme,
                       Parsed* parsed) {
   DoParseAfterScheme(spec, spec_len, after_scheme, parsed);
 }
 
 }  // namespace url