Update dangling markup mitigations.

url/url_canon_etc.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.
 
 // Canonicalizers for random bits that aren't big enough for their own files.
 
 #include <string.h>
 
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 
 namespace url {
 
 namespace {
 
 // Returns true if the given character should be removed from the middle of a
 // URL.
 inline bool IsRemovableURLWhitespace(int ch) {
   return ch == '\r' || ch == '\n' || ch == '\t';
 }
 
 // Backend for RemoveURLWhitespace (see declaration in url_canon.h).
 // It sucks that we have to do this, since this takes about 13% of the total URL
 // canonicalization time.
-template<typename CHAR>
-const CHAR* DoRemoveURLWhitespace(const CHAR* input, int input_len,
+template <typename CHAR>
+const CHAR* DoRemoveURLWhitespace(const CHAR* input,
+                                  int input_len,
                                   CanonOutputT<CHAR>* buffer,
-                                  int* output_len) {
+                                  int* output_len,
+                                  bool* potentially_dangling_markup) {
   // Fast verification that there's nothing that needs removal. This is the 99%
   // case, so we want it to be fast and don't care about impacting the speed
   // when we do find whitespace.
   int found_whitespace = false;
   for (int i = 0; i < input_len; i++) {
     if (!IsRemovableURLWhitespace(input[i]))
       continue;
     found_whitespace = true;
     break;
   }
 
   if (!found_whitespace) {
     // Didn't find any whitespace, we don't need to do anything. We can just
     // return the input as the output.
     *output_len = input_len;
     return input;
   }
 
   // Remove the whitespace into the new buffer and return it.
   for (int i = 0; i < input_len; i++) {
-    if (!IsRemovableURLWhitespace(input[i]))
+    if (!IsRemovableURLWhitespace(input[i])) {
+      if (potentially_dangling_markup && input[i] == 0x3C)
+        *potentially_dangling_markup = true;
       buffer->push_back(input[i]);
+    }
   }
   *output_len = buffer->length();
   return buffer->data();
 }
 
 // Contains the canonical version of each possible input letter in the scheme
 // (basically, lower-cased). The corresponding entry will be 0 if the letter
 // is not allowed in a scheme.
 const char kSchemeCanonical[0x80] = {
 // 00-1f: all are invalid
@@ skipping 206 matching lines @@
       ReadUTFChar(spec, &i, end, &code_point);
       AppendUTF8Value(code_point, output);
     }
   }
 
   out_ref->len = output->length() - out_ref->begin;
 }
 
 }  // namespace
 
-const char* RemoveURLWhitespace(const char* input, int input_len,
+const char* RemoveURLWhitespace(const char* input,
+                                int input_len,
                                 CanonOutputT<char>* buffer,
-                                int* output_len) {
-  return DoRemoveURLWhitespace(input, input_len, buffer, output_len);
+                                int* output_len,
+                                bool* potentially_dangling_markup) {
+  return DoRemoveURLWhitespace(input, input_len, buffer, output_len,
+                               potentially_dangling_markup);
 }
 
 const base::char16* RemoveURLWhitespace(const base::char16* input,
                                         int input_len,
                                         CanonOutputT<base::char16>* buffer,
-                                        int* output_len) {
-  return DoRemoveURLWhitespace(input, input_len, buffer, output_len);
+                                        int* output_len,
+                                        bool* potentially_dangling_markup) {
+  return DoRemoveURLWhitespace(input, input_len, buffer, output_len,
+                               potentially_dangling_markup);
 }
 
 char CanonicalSchemeChar(base::char16 ch) {
   if (ch >= 0x80)
     return 0;  // Non-ASCII is not supported by schemes.
   return kSchemeCanonical[ch];
 }
 
 bool CanonicalizeScheme(const char* spec,
                         const Component& scheme,
@@ skipping 60 matching lines @@
 }
 
 void CanonicalizeRef(const base::char16* spec,
                      const Component& ref,
                      CanonOutput* output,
                      Component* out_ref) {
   DoCanonicalizeRef<base::char16, base::char16>(spec, ref, output, out_ref);
 }
 
 }  // namespace url