Replace ASSERT()s with DCHECK*() in core/html/*.{cpp,h}.

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 162 matching lines @@
 bool HTMLInputElement::shouldAutocomplete() const
 {
     if (m_autocomplete != Uninitialized)
         return m_autocomplete == On;
     return HTMLTextFormControlElement::shouldAutocomplete();
 }
 
 bool HTMLInputElement::isValidValue(const String& value) const
 {
     if (!m_inputType->canSetStringValue()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return false;
     }
     return !m_inputType->typeMismatchFor(value)
         && !m_inputType->stepMismatch(value)
         && !m_inputType->rangeUnderflow(value)
         && !m_inputType->rangeOverflow(value)
         && !tooLong(value, IgnoreDirtyFlag)
         && !tooShort(value, IgnoreDirtyFlag)
         && !m_inputType->patternMismatch(value)
         && !m_inputType->valueMissing(value);
@@ skipping 152 matching lines @@
             layoutObject()->scrollRectToVisible(boundingBox());
         if (document().frame())
             document().frame()->selection().revealSelection();
     } else {
         HTMLTextFormControlElement::updateFocusAppearance(selectionBehavior);
     }
 }
 
 void HTMLInputElement::beginEditing()
 {
-    ASSERT(document().isActive());
+    DCHECK(document().isActive());
     if (!document().isActive())
         return;
 
     if (!isTextField())
         return;
 
     document().frame()->spellChecker().didBeginEditing(this);
 }
 
 void HTMLInputElement::endEditing()
 {
-    ASSERT(document().isActive());
+    DCHECK(document().isActive());
     if (!document().isActive())
         return;
 
     if (!isTextField())
         return;
 
     LocalFrame* frame = document().frame();
     frame->spellChecker().didEndEditingOnTextField(this);
     frame->host()->chromeClient().didEndEditingOnTextField(*this);
 }
@@ skipping 17 matching lines @@
     m_inputTypeView->handleBlurEvent();
 }
 
 void HTMLInputElement::setType(const AtomicString& type)
 {
     setAttribute(typeAttr, type);
 }
 
 void HTMLInputElement::updateTouchEventHandlerRegistry()
 {
-    ASSERT(m_inputTypeView);
+    DCHECK(m_inputTypeView);
 
     bool hasTouchEventHandler = m_inputTypeView->hasTouchEventHandler();
     if (hasTouchEventHandler == !!m_hasTouchEventHandler)
         return;
     // If the Document is being or has been stopped, don't register any handlers.
     if (document().frameHost() && document().lifecycle().state() < DocumentLifecycle::Stopping) {
         EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
         // TODO(dtapuska): Make this passive touch listener see crbug.com/584438
         if (hasTouchEventHandler)
             registry.didAddEventHandler(*this, EventHandlerRegistry::TouchStartOrMoveEventBlocking);
         else
             registry.didRemoveEventHandler(*this, EventHandlerRegistry::TouchStartOrMoveEventBlocking);
         m_hasTouchEventHandler = hasTouchEventHandler;
     }
 }
 
 void HTMLInputElement::initializeTypeInParsing()
 {
-    ASSERT(m_parsingInProgress);
-    ASSERT(!m_inputType);
-    ASSERT(!m_inputTypeView);
+    DCHECK(m_parsingInProgress);
+    DCHECK(!m_inputType);
+    DCHECK(!m_inputTypeView);
 
     const AtomicString& newTypeName = InputType::normalizeTypeName(fastGetAttribute(typeAttr));
     m_inputType = InputType::create(*this, newTypeName);
     m_inputTypeView = m_inputType->createView();
     ensureUserAgentShadowRoot();
 
     updateTouchEventHandlerRegistry();
 
     setNeedsWillValidateCheck();
 
     m_inputType->warnIfValueIsInvalid(fastGetAttribute(valueAttr).getString());
 
     m_inputTypeView->updateView();
     setTextAsOfLastFormControlChangeEvent(value());
     setChangedSinceLastFormControlChangeEvent(false);
 }
 
 void HTMLInputElement::updateType()
 {
-    ASSERT(m_inputType);
-    ASSERT(m_inputTypeView);
+    DCHECK(m_inputType);
+    DCHECK(m_inputTypeView);
 
     const AtomicString& newTypeName = InputType::normalizeTypeName(fastGetAttribute(typeAttr));
     if (m_inputType->formControlType() == newTypeName)
         return;
 
     InputType* newType = InputType::create(*this, newTypeName);
     removeFromRadioButtonGroup();
 
     bool didStoreValue = m_inputType->storesValueSeparateFromAttribute();
     bool didRespectHeightAndWidth = m_inputType->shouldRespectHeightAndWidthAttributes();
@@ skipping 23 matching lines @@
     } else {
         if (!hasDirtyValue())
             m_inputType->warnIfValueIsInvalid(fastGetAttribute(valueAttr).getString());
         updateValueIfNeeded();
     }
 
     m_needsToUpdateViewValue = true;
     m_inputTypeView->updateView();
 
     if (didRespectHeightAndWidth != m_inputType->shouldRespectHeightAndWidthAttributes()) {
-        ASSERT(elementData());
+        DCHECK(elementData());
         AttributeCollection attributes = attributesWithoutUpdate();
         if (const Attribute* height = attributes.find(heightAttr))
             HTMLTextFormControlElement::attributeChanged(heightAttr, height->value(), height->value());
         if (const Attribute* width = attributes.find(widthAttr))
             HTMLTextFormControlElement::attributeChanged(widthAttr, width->value(), width->value());
         if (const Attribute* align = attributes.find(alignAttr))
             HTMLTextFormControlElement::attributeChanged(alignAttr, align->value(), align->value());
     }
 
     if (document().focusedElement() == this)
@@ skipping 151 matching lines @@
             addHTMLLengthToStyle(style, CSSPropertyHeight, value);
     } else if (name == borderAttr && type() == InputTypeNames::image) { // FIXME: Remove type check.
         applyBorderAttributeToStyle(value, style);
     } else {
         HTMLTextFormControlElement::collectStyleForPresentationAttribute(name, value, style);
     }
 }
 
 void HTMLInputElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
-    ASSERT(m_inputType);
-    ASSERT(m_inputTypeView);
+    DCHECK(m_inputType);
+    DCHECK(m_inputTypeView);
 
     if (name == nameAttr) {
         removeFromRadioButtonGroup();
         m_name = value;
         addToRadioButtonGroup();
         HTMLTextFormControlElement::parseAttribute(name, oldValue, value);
     } else if (name == autocompleteAttr) {
         if (equalIgnoringCase(value, "off")) {
             m_autocomplete = Off;
         } else {
@@ skipping 84 matching lines @@
     } else {
         if (name == formactionAttr)
             logUpdateAttributeIfIsolatedWorldAndInDocument("input", formactionAttr, oldValue, value);
         HTMLTextFormControlElement::parseAttribute(name, oldValue, value);
     }
     m_inputTypeView->attributeChanged();
 }
 
 void HTMLInputElement::parserDidSetAttributes()
 {
-    ASSERT(m_parsingInProgress);
+    DCHECK(m_parsingInProgress);
     initializeTypeInParsing();
 }
 
 void HTMLInputElement::finishParsingChildren()
 {
     m_parsingInProgress = false;
-    ASSERT(m_inputType);
-    ASSERT(m_inputTypeView);
+    DCHECK(m_inputType);
+    DCHECK(m_inputTypeView);
     HTMLTextFormControlElement::finishParsingChildren();
     if (!m_stateRestored) {
         bool checked = hasAttribute(checkedAttr);
         if (checked)
             setChecked(checked);
         m_dirtyCheckedness = false;
     }
 }
 
 bool HTMLInputElement::layoutObjectIsNeeded(const ComputedStyle& style)
@@ skipping 316 matching lines @@
     if (std::isinf(newValue)) {
         exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(newValue));
         return;
     }
     m_inputType->setValueAsDouble(newValue, eventBehavior, exceptionState);
 }
 
 void HTMLInputElement::setValueFromRenderer(const String& value)
 {
     // File upload controls will never use this.
-    ASSERT(type() != InputTypeNames::file);
+    DCHECK_NE(type(), InputTypeNames::file);
 
     m_suggestedValue = String();
 
     // Renderer and our event handler are responsible for sanitizing values.
-    ASSERT(value == m_inputType->sanitizeUserInputValue(value) || m_inputType->sanitizeUserInputValue(value).isEmpty());
+    DCHECK(value == m_inputType->sanitizeUserInputValue(value) || m_inputType->sanitizeUserInputValue(value).isEmpty());
 
     m_valueIfDirty = value;
     m_needsToUpdateViewValue = false;
 
     // Input event is fired by the Node::defaultEventHandler for editable controls.
     if (!isTextField())
         dispatchInputEvent();
     notifyFormStateChanged();
 
     setNeedsValidityCheck();
@@ skipping 355 matching lines @@
     logAddElementIfIsolatedWorldAndInDocument("input", typeAttr, formactionAttr);
     return InsertionShouldCallDidNotifySubtreeInsertions;
 }
 
 void HTMLInputElement::removedFrom(ContainerNode* insertionPoint)
 {
     m_inputTypeView->closePopupView();
     if (insertionPoint->isConnected() && !form())
         removeFromRadioButtonGroup();
     HTMLTextFormControlElement::removedFrom(insertionPoint);
-    ASSERT(!isConnected());
+    DCHECK(!isConnected());
     resetListAttributeTargetObserver();
 }
 
 void HTMLInputElement::didMoveToNewDocument(Document& oldDocument)
 {
     if (imageLoader())
         imageLoader()->elementDidMoveToNewDocument();
 
     // FIXME: Remove type check.
     if (type() == InputTypeNames::radio)
@@ skipping 195 matching lines @@
     int minLength;
     if (!parseHTMLInteger(value, minLength) || minLength < 0)
         minLength = -1;
     m_minLength = minLength;
     setNeedsValidityCheck();
 }
 
 void HTMLInputElement::updateValueIfNeeded()
 {
     String newValue = sanitizeValue(m_valueIfDirty);
-    ASSERT(!m_valueIfDirty.isNull() || newValue.isNull());
+    DCHECK(!m_valueIfDirty.isNull() || newValue.isNull());
     if (newValue != m_valueIfDirty)
         setValue(newValue);
 }
 
 bool HTMLInputElement::supportsAutocapitalize() const
 {
     return m_inputType->supportsAutocapitalize();
 }
 
 const AtomicString& HTMLInputElement::defaultAutocapitalize() const
 {
     return m_inputType->defaultAutocapitalize();
 }
 
 String HTMLInputElement::defaultToolTip() const
 {
     return m_inputType->defaultToolTip(*m_inputTypeView);
 }
 
 bool HTMLInputElement::shouldAppearIndeterminate() const
 {
     return m_inputType->shouldAppearIndeterminate();
 }
 
 bool HTMLInputElement::isInRequiredRadioButtonGroup()
 {
-    // FIXME: Remove type check.
-    ASSERT(type() == InputTypeNames::radio);
+    // TODO(tkent): Remove type check.
+    DCHECK_EQ(type(), InputTypeNames::radio);
     if (RadioButtonGroupScope* scope = radioButtonGroupScope())
         return scope->isInRequiredGroup(this);
     return false;
 }
 
 HTMLInputElement* HTMLInputElement::checkedRadioButtonForGroup()
 {
     if (checked())
         return this;
     if (RadioButtonGroupScope* scope = radioButtonGroupScope())
@@ skipping 198 matching lines @@
 {
     return m_inputTypeView->hasFallbackContent();
 }
 
 void HTMLInputElement::setFilesFromPaths(const Vector<String>& paths)
 {
     return m_inputType->setFilesFromPaths(paths);
 }
 
 } // namespace blink