Change the linebreak behavior of minlength and maxlength attributes of TEXTAREA.

third_party/WebKit/Source/core/html/HTMLTextAreaElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 42 matching lines @@
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static const unsigned defaultRows = 2;
 static const unsigned defaultCols = 20;
 
-// On submission, LF characters are converted into CRLF.
-// This function returns number of characters considering this.
-static unsigned numberOfLineBreaks(const String& text)
+static inline unsigned computeLengthForAPIValue(const String& text)
 {
     unsigned length = text.length();
-    unsigned count = 0;
-    for (unsigned i = 0; i < length; i++) {
-        if (text[i] == '\n')
-            count++;
+    unsigned crlfCount = 0;
+    for (unsigned i = 0; i < length; ++i) {
+        if (text[i] == '\r' && i + 1 < length && text[i + 1] == '\n')
+            crlfCount++;
     }
-    return count;
-}
-
-static inline unsigned computeLengthForSubmission(const String& text)
-{
-    return text.length() + numberOfLineBreaks(text);
+    return text.length() - crlfCount;
 }
 
 HTMLTextAreaElement::HTMLTextAreaElement(Document& document, HTMLFormElement* form)
     : HTMLTextFormControlElement(textareaTag, document, form)
     , m_rows(defaultRows)
     , m_cols(defaultCols)
     , m_wrap(SoftWrap)
     , m_isDirty(false)
     , m_valueIsUpToDate(true)
     , m_isPlaceholderVisible(false)
@@ skipping 224 matching lines @@
 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event) const
 {
     DCHECK(event);
     DCHECK(layoutObject());
     int signedMaxLength = maxLength();
     if (signedMaxLength < 0)
         return;
     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
 
     const String& currentValue = innerEditorValue();
-    unsigned currentLength = computeLengthForSubmission(currentValue);
-    if (currentLength + computeLengthForSubmission(event->text()) < unsignedMaxLength)
+    unsigned currentLength = computeLengthForAPIValue(currentValue);
+    if (currentLength + computeLengthForAPIValue(event->text()) < unsignedMaxLength)
         return;
 
     // selectionLength represents the selection length of this text field to be
     // removed by this insertion.
     // If the text field has no focus, we don't need to take account of the
     // selection length. The selection is the source of text drag-and-drop in
     // that case, and nothing in the text field will be removed.
     unsigned selectionLength = 0;
     if (focused()) {
         // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
         // needs to be audited.  See http://crbug.com/590369 for more details.
         document().updateStyleAndLayoutIgnorePendingStylesheets();
 
-        selectionLength = computeLengthForSubmission(document().frame()->selection().selectedText());
+        selectionLength = computeLengthForAPIValue(document().frame()->selection().selectedText());
     }
     DCHECK_GE(currentLength, selectionLength);
     unsigned baseLength = currentLength - selectionLength;
     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
     event->setText(sanitizeUserInputValue(event->text(), appendableLength));
 }
 
 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
 {
     unsigned submissionLength = 0;
     unsigned i = 0;
     for (; i < proposedValue.length(); ++i) {
-        submissionLength += proposedValue[i] == '\n' ? 2 : 1;
+        if (proposedValue[i] == '\r' && i + 1 < proposedValue.length() && proposedValue[i + 1] == '\n')
+            continue;
+        ++submissionLength;
         if (submissionLength == maxLength) {
             ++i;
             break;
         }
         if (submissionLength > maxLength)
             break;
     }
     if (i > 0 && U16_IS_LEAD(proposedValue[i - 1]))
         --i;
     return proposedValue.left(i);
@@ skipping 181 matching lines @@
     if (!willValidate())
         return String();
 
     if (customError())
         return customValidationMessage();
 
     if (valueMissing())
         return locale().queryString(WebLocalizedString::ValidationValueMissing);
 
     if (tooLong())
-        return locale().validationMessageTooLongText(computeLengthForSubmission(value()), maxLength());
+        return locale().validationMessageTooLongText(value().length(), maxLength());
 
     if (tooShort())
-        return locale().validationMessageTooShortText(computeLengthForSubmission(value()), minLength());
+        return locale().validationMessageTooShortText(value().length(), minLength());
 
     return String();
 }
 
 bool HTMLTextAreaElement::valueMissing() const
 {
     // We should not call value() for performance.
     return willValidate() && valueMissing(nullptr);
 }
 
@@ skipping 17 matching lines @@
 bool HTMLTextAreaElement::tooLong(const String* value, NeedsToCheckDirtyFlag check) const
 {
     // Return false for the default value or value set by script even if it is
     // longer than maxLength.
     if (check == CheckDirtyFlag && !lastChangeWasUserEdit())
         return false;
 
     int max = maxLength();
     if (max < 0)
         return false;
-    return computeLengthForSubmission(value ? *value : this->value()) > static_cast<unsigned>(max);
+    unsigned len = value ? computeLengthForAPIValue(*value) : this->value().length();
+    return len > static_cast<unsigned>(max);
 }
 
 bool HTMLTextAreaElement::tooShort(const String* value, NeedsToCheckDirtyFlag check) const
 {
     // Return false for the default value or value set by script even if it is
     // shorter than minLength.
     if (check == CheckDirtyFlag && !lastChangeWasUserEdit())
         return false;
 
     int min = minLength();
     if (min <= 0)
         return false;
     // An empty string is excluded from minlength check.
-    unsigned len = computeLengthForSubmission(value ? *value : this->value());
+    unsigned len = value ? computeLengthForAPIValue(*value) : this->value().length();
     return len > 0 && len < static_cast<unsigned>(min);
 }
 
 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
 {
     return !valueMissing(&candidate) && !tooLong(&candidate, IgnoreDirtyFlag) && !tooShort(&candidate, IgnoreDirtyFlag);
 }
 
 void HTMLTextAreaElement::accessKeyAction(bool)
 {
@@ skipping 63 matching lines @@
 
 void HTMLTextAreaElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     const HTMLTextAreaElement& sourceElement = static_cast<const HTMLTextAreaElement&>(source);
     setValueCommon(sourceElement.value(), DispatchNoEvent, SetSeletion);
     m_isDirty = sourceElement.m_isDirty;
     HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(source);
 }
 
 } // namespace blink