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

url/url_util.cc

 // 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.
 
 #include "url/url_util.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <vector>
 
@@ skipping 22 matching lines @@
   {kWssScheme, SCHEME_WITH_PORT},   // WebSocket secure.
   {kFileSystemScheme, SCHEME_WITHOUT_AUTHORITY},
 };
 
 const int kNumReferrerURLSchemes = 2;
 const SchemeWithType kReferrerURLSchemes[kNumReferrerURLSchemes] = {
   {kHttpScheme, SCHEME_WITH_PORT},
   {kHttpsScheme, SCHEME_WITH_PORT},
 };
 
+const int kNumPathURLSchemes = 6;
+const SchemeWithType kPathURLSchemes[kNumPathURLSchemes] = {
+    {kAboutScheme, SCHEME_WITHOUT_PORT},
+    {kBlobScheme, SCHEME_WITHOUT_PORT},
+    {kContentScheme, SCHEME_WITHOUT_PORT},
+    {kContentIDScheme, SCHEME_WITHOUT_PORT},
+    {kDataScheme, SCHEME_WITHOUT_PORT},
+    {kJavaScriptScheme, SCHEME_WITHOUT_PORT},
+};
+
 // Lists of the currently installed standard and referrer schemes. These lists
 // are lazily initialized by InitStandardSchemes and InitReferrerSchemes and are
 // leaked on shutdown to prevent any destructors from being called that will
 // slow us down or cause problems.
 std::vector<SchemeWithType>* standard_schemes = nullptr;
 std::vector<SchemeWithType>* referrer_schemes = nullptr;
+std::vector<SchemeWithType>* path_schemes = nullptr;
 
 // See the LockSchemeRegistries declaration in the header.
 bool scheme_registries_locked = false;
 
 // This template converts a given character type to the corresponding
 // StringPiece type.
 template<typename CHAR> struct CharToStringPiece {
 };
 template<> struct CharToStringPiece<char> {
   typedef base::StringPiece Piece;
@@ skipping 18 matching lines @@
 void InitStandardSchemes() {
   InitSchemes(&standard_schemes, kStandardURLSchemes, kNumStandardURLSchemes);
 }
 
 // Ensures that the referrer_schemes list is initialized, does nothing if
 // it already has values.
 void InitReferrerSchemes() {
   InitSchemes(&referrer_schemes, kReferrerURLSchemes, kNumReferrerURLSchemes);
 }
 
+// Ensures that the path_schemes list is initialized, does nothing if
+// it already has values.
+void InitPathSchemes() {
+  InitSchemes(&path_schemes, kPathURLSchemes, kNumPathURLSchemes);
+}
+
 // Given a string and a range inside the string, compares it to the given
 // lower-case |compare_to| buffer.
 template<typename CHAR>
 inline bool DoCompareSchemeComponent(const CHAR* spec,
                                      const Component& component,
                                      const char* compare_to) {
   if (!component.is_nonempty())
     return compare_to[0] == 0;  // When component is empty, match empty scheme.
   return base::LowerCaseEqualsASCII(
       typename CharToStringPiece<CHAR>::Piece(
@@ skipping 21 matching lines @@
   }
   return false;
 }
 
 template<typename CHAR>
 bool DoIsStandard(const CHAR* spec, const Component& scheme, SchemeType* type) {
   InitStandardSchemes();
   return DoIsInSchemes(spec, scheme, type, *standard_schemes);
 }
 
+template <typename CHAR>
+bool DoIsPath(const CHAR* spec, const Component& scheme, SchemeType* type) {
+  InitPathSchemes();
+  return DoIsInSchemes(spec, scheme, type, *path_schemes);
+}
 
 template<typename CHAR>
 bool DoFindAndCompareScheme(const CHAR* str,
                             int str_len,
                             const char* compare,
                             Component* found_scheme) {
   // Before extracting scheme, canonicalize the URL to remove any whitespace.
   // This matches the canonicalization done in DoCanonicalize function.
   RawCanonOutputT<CHAR> whitespace_buffer;
   int spec_len;
@@ skipping 72 matching lines @@
     success = CanonicalizeStandardURL(spec, spec_len, parsed_input,
                                       charset_converter, output, output_parsed);
 
   } else if (DoCompareSchemeComponent(spec, scheme, url::kMailToScheme)) {
     // Mailto URLs are treated like standard URLs, with only a scheme, path,
     // and query.
     ParseMailtoURL(spec, spec_len, &parsed_input);
     success = CanonicalizeMailtoURL(spec, spec_len, parsed_input, output,
                                     output_parsed);
 
-  } else {
+  } else if (DoIsPath(spec, scheme, &unused_scheme_type)) {
     // "Weird" URLs like data: and javascript:.
     ParsePathURL(spec, spec_len, trim_path_end, &parsed_input);
     success = CanonicalizePathURL(spec, spec_len, parsed_input, output,
                                   output_parsed);
+
+  } else {
+    // All other urls.
+    ParseNonStandardURL(spec, spec_len, &parsed_input);
+    success = CanonicalizeNonStandardURL(
+        spec, spec_len, parsed_input, charset_converter, output, output_parsed);
   }
   return success;
 }
 
 template<typename CHAR>
 bool DoResolveRelative(const char* base_spec,
                        int base_spec_len,
                        const Parsed& base_parsed,
                        const CHAR* in_relative,
                        int in_relative_length,
@@ skipping 387 matching lines @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 bool CompareSchemeComponent(const base::char16* spec,
                             const Component& component,
                             const char* compare_to) {
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 }  // namespace url