Introduce HTMLInputElement::m_hasDirtyValue.

third_party/WebKit/Source/core/html/HTMLInputElement.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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
@@ skipping 84 matching lines @@
 // get rather sluggish when a text field has a larger number of characters than
 // this, even when just clicking in the text field.
 const int HTMLInputElement::maximumLength = 524288;
 const int defaultSize = 20;
 
 HTMLInputElement::HTMLInputElement(Document& document, HTMLFormElement* form, bool createdByParser)
     : HTMLTextFormControlElement(inputTag, document, form)
     , m_size(defaultSize)
     , m_maxLength(maximumLength)
     , m_minLength(-1)
+    , m_hasDirtyValue(false)
     , m_isChecked(false)
     , m_dirtyCheckedness(false)
     , m_isIndeterminate(false)
     , m_isActivatedSubmit(false)
     , m_autocomplete(Uninitialized)
     , m_hasNonEmptyList(false)
     , m_stateRestored(false)
     , m_parsingInProgress(createdByParser)
     , m_valueAttributeWasUpdatedAfterParsing(false)
     , m_canReceiveDroppedFiles(false)
@@ skipping 332 matching lines @@
     m_inputTypeView = m_inputType->createView();
     m_inputTypeView->createShadowSubtree();
 
     setNeedsWillValidateCheck();
 
     bool willStoreValue = m_inputType->storesValueSeparateFromAttribute();
 
     if (didStoreValue && !willStoreValue && hasDirtyValue()) {
         setAttribute(valueAttr, AtomicString(m_valueIfDirty));
         m_valueIfDirty = String();
+        m_hasDirtyValue = false;
     }
     if (!didStoreValue && willStoreValue) {
         AtomicString valueString = fastGetAttribute(valueAttr);
         m_inputType->warnIfValueIsInvalid(valueString);
         m_valueIfDirty = sanitizeValue(valueString);
+        m_hasDirtyValue = !m_valueIfDirty.isNull();
     } else {
         if (!hasDirtyValue())
             m_inputType->warnIfValueIsInvalid(fastGetAttribute(valueAttr).getString());
         updateValueIfNeeded();
     }
 
     m_needsToUpdateViewValue = true;
     m_inputTypeView->updateView();
 
     if (didRespectHeightAndWidth != m_inputType->shouldRespectHeightAndWidthAttributes()) {
@@ skipping 452 matching lines @@
 bool HTMLInputElement::sizeShouldIncludeDecoration(int& preferredSize) const
 {
     return m_inputTypeView->sizeShouldIncludeDecoration(defaultSize, preferredSize);
 }
 
 void HTMLInputElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     const HTMLInputElement& sourceElement = static_cast<const HTMLInputElement&>(source);
 
     m_valueIfDirty = sourceElement.m_valueIfDirty;
+    m_hasDirtyValue = sourceElement.m_hasDirtyValue;
     setChecked(sourceElement.m_isChecked);
     m_dirtyCheckedness = sourceElement.m_dirtyCheckedness;
     m_isIndeterminate = sourceElement.m_isIndeterminate;
 
     HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(source);
 
     m_needsToUpdateViewValue = true;
     m_inputTypeView->updateView();
 }
 
 String HTMLInputElement::value() const
 {
     String value;
     if (m_inputType->getTypeSpecificValue(value))
         return value;
 
-    value = m_valueIfDirty;
-    if (!value.isNull())
-        return value;
+    if (hasDirtyValue())
+        return m_valueIfDirty;
 
     AtomicString valueString = fastGetAttribute(valueAttr);
     value = sanitizeValue(valueString);
     if (!value.isNull())
         return value;
 
     return m_inputType->fallbackValue();
 }
 
 String HTMLInputElement::valueWithDefault() const
@@ skipping 76 matching lines @@
 
     if (!valueChanged)
         return;
 
     notifyFormStateChanged();
 }
 
 void HTMLInputElement::setValueInternal(const String& sanitizedValue, TextFieldEventBehavior eventBehavior)
 {
     m_valueIfDirty = sanitizedValue;
+    m_hasDirtyValue = !m_valueIfDirty.isNull();
     setNeedsValidityCheck();
     if (m_inputType->isSteppable()) {
         pseudoStateChanged(CSSSelector::PseudoInRange);
         pseudoStateChanged(CSSSelector::PseudoOutOfRange);
     }
     if (document().focusedElement() == this)
         document().frameHost()->chromeClient().didUpdateTextOfFocusedElementByNonUserInput(*document().frame());
 }
 
+bool HTMLInputElement::hasDirtyValue() const
+{
+    DCHECK_EQ(!m_hasDirtyValue, m_valueIfDirty.isNull());
+    return m_hasDirtyValue;
+}
+
 void HTMLInputElement::updateView()
 {
     m_inputTypeView->updateView();
 }
 
 double HTMLInputElement::valueAsDate(bool& isNull) const
 {
     double date =  m_inputType->valueAsDate();
     isNull = !std::isfinite(date);
     return date;
@@ skipping 23 matching lines @@
 void HTMLInputElement::setValueFromRenderer(const String& value)
 {
     // File upload controls will never use this.
     DCHECK_NE(type(), InputTypeNames::file);
 
     m_suggestedValue = String();
 
     // Renderer and our event handler are responsible for sanitizing values.
     DCHECK(value == m_inputType->sanitizeUserInputValue(value) || m_inputType->sanitizeUserInputValue(value).isEmpty());
 
+    DCHECK(!value.isNull());
     m_valueIfDirty = value;
+    m_hasDirtyValue = true;
     m_needsToUpdateViewValue = false;
 
     // Input event is fired by the Node::defaultEventHandler for editable controls.
     if (!isTextField())
         dispatchInputEvent();
     notifyFormStateChanged();
 
     setNeedsValidityCheck();
 
     // Clear autofill flag (and yellow background) on user edit.
@@ skipping 802 matching lines @@
 {
     return m_inputTypeView->hasFallbackContent();
 }
 
 void HTMLInputElement::setFilesFromPaths(const Vector<String>& paths)
 {
     return m_inputType->setFilesFromPaths(paths);
 }
 
 } // namespace blink