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

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

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * 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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
@@ skipping 203 matching lines @@
 HTMLOptionElement* HTMLSelectElement::activeSelectionEnd() const
 {
     if (m_activeSelectionEnd)
         return m_activeSelectionEnd.get();
     return lastSelectedOption();
 }
 
 void HTMLSelectElement::add(const HTMLOptionElementOrHTMLOptGroupElement& element, const HTMLElementOrLong& before, ExceptionState& exceptionState)
 {
     HTMLElement* elementToInsert;
-    ASSERT(!element.isNull());
+    DCHECK(!element.isNull());
     if (element.isHTMLOptionElement())
         elementToInsert = element.getAsHTMLOptionElement();
     else
         elementToInsert = element.getAsHTMLOptGroupElement();
 
     HTMLElement* beforeElement;
     if (before.isHTMLElement())
         beforeElement = before.getAsHTMLElement();
     else if (before.isLong())
         beforeElement = options()->item(before.getAsLong());
@@ skipping 256 matching lines @@
 }
 
 // Returns the 1st valid OPTION |skip| items from |listIndex| in direction
 // |direction| if there is one.
 // Otherwise, it returns the valid OPTION closest to that boundary which is past
 // |listIndex| if there is one.
 // Otherwise, it returns nullptr.
 // Valid means that it is enabled and visible.
 HTMLOptionElement* HTMLSelectElement::nextValidOption(int listIndex, SkipDirection direction, int skip) const
 {
-    ASSERT(direction == SkipBackwards || direction == SkipForwards);
+    DCHECK(direction == SkipBackwards || direction == SkipForwards);
     const ListItems& listItems = this->listItems();
     HTMLOptionElement* lastGoodOption = nullptr;
     int size = listItems.size();
     for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {
         --skip;
         HTMLElement* element = listItems[listIndex];
         if (!isHTMLOptionElement(*element))
             continue;
         if (toHTMLOptionElement(*element).isDisplayNone())
             continue;
@@ skipping 47 matching lines @@
     // If there is no exact one page away valid option, returns startIndex or
     // the most far index.
     int startIndex = startOption ? startOption->listIndex() : -1;
     int edgeIndex = (direction == SkipForwards) ? 0 : (items.size() - 1);
     int skipAmount = pageSize + ((direction == SkipForwards) ? startIndex : (edgeIndex - startIndex));
     return nextValidOption(edgeIndex, direction, skipAmount);
 }
 
 void HTMLSelectElement::selectAll()
 {
-    ASSERT(!usesMenuList());
+    DCHECK(!usesMenuList());
     if (!layoutObject() || !m_multiple)
         return;
 
     // Save the selection so it can be compared to the new selectAll selection
     // when dispatching change events.
     saveLastSelection();
 
     m_activeSelectionState = true;
     setActiveSelectionAnchor(nextSelectableOption(nullptr));
     setActiveSelectionEnd(previousSelectableOption(nullptr));
@@ skipping 40 matching lines @@
     }
 }
 
 void HTMLSelectElement::setActiveSelectionEnd(HTMLOptionElement* option)
 {
     m_activeSelectionEnd = option;
 }
 
 void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions, bool scroll)
 {
-    ASSERT(layoutObject());
-    ASSERT(layoutObject()->isListBox() || m_multiple);
+    DCHECK(layoutObject());
+    DCHECK(layoutObject()->isListBox() || m_multiple);
 
     int activeSelectionAnchorIndex = m_activeSelectionAnchor ? m_activeSelectionAnchor->index() : -1;
     int activeSelectionEndIndex = m_activeSelectionEnd ? m_activeSelectionEnd->index() : -1;
     int start = std::min(activeSelectionAnchorIndex, activeSelectionEndIndex);
     int end = std::max(activeSelectionAnchorIndex, activeSelectionEndIndex);
 
     int i = 0;
     for (const auto& option : optionList()) {
         if (option->isDisabledFormControl() || !option->layoutObject()) {
             ++i;
@@ skipping 12 matching lines @@
     }
 
     setNeedsValidityCheck();
     if (scroll)
         scrollToSelection();
     notifyFormStateChanged();
 }
 
 void HTMLSelectElement::listBoxOnChange()
 {
-    ASSERT(!usesMenuList() || m_multiple);
+    DCHECK(!usesMenuList() || m_multiple);
 
     const ListItems& items = listItems();
 
     // If the cached selection list is empty, or the size has changed, then fire
     // dispatchFormControlChangeEvent, and return early.
     // FIXME: Why? This looks unreasonable.
     if (m_lastOnChangeSelection.isEmpty() || m_lastOnChangeSelection.size() != items.size()) {
         dispatchFormControlChangeEvent();
         return;
     }
 
     // Update m_lastOnChangeSelection and fire dispatchFormControlChangeEvent.
     bool fireOnChange = false;
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         bool selected = isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected();
         if (selected != m_lastOnChangeSelection[i])
             fireOnChange = true;
         m_lastOnChangeSelection[i] = selected;
     }
 
     if (fireOnChange) {
         dispatchInputEvent();
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::dispatchInputAndChangeEventForMenuList()
 {
-    ASSERT(usesMenuList());
+    DCHECK(usesMenuList());
 
     HTMLOptionElement* selectedOption = this->selectedOption();
     if (m_lastOnChangeOption.get() != selectedOption) {
         m_lastOnChangeOption = selectedOption;
         dispatchInputEvent();
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::scrollToSelection()
@@ skipping 16 matching lines @@
 }
 
 const HTMLSelectElement::ListItems& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems) {
         recalcListItems();
     } else {
 #if ENABLE(ASSERT)
         HeapVector<Member<HTMLElement>> items = m_listItems;
         recalcListItems();
+        // TODO(tkent): Add a stream printer for HeapVector. DCHECK requires it.
         ASSERT(items == m_listItems);
 #endif
     }
 
     return m_listItems;
 }
 
 void HTMLSelectElement::invalidateSelectedItems()
 {
     if (HTMLCollection* collection = cachedCollection<HTMLCollection>(SelectedOptions))
@@ skipping 172 matching lines @@
         document().postTask(BLINK_FROM_HERE, createSameThreadTask(&HTMLSelectElement::scrollToOptionTask, wrapPersistent(this)));
 }
 
 void HTMLSelectElement::scrollToOptionTask()
 {
     HTMLOptionElement* option = m_optionToScrollTo.release();
     if (!option || !isConnected())
         return;
     // optionRemoved() makes sure m_optionToScrollTo doesn't have an option with
     // another owner.
-    ASSERT(option->ownerSelectElement() == this);
+    DCHECK_EQ(option->ownerSelectElement(), this);
     document().updateStyleAndLayoutIgnorePendingStylesheets();
     if (!layoutObject() || !layoutObject()->isListBox())
         return;
     LayoutRect bounds = option->boundingBox();
     toLayoutListBox(layoutObject())->scrollToRect(bounds);
 }
 
 void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
 {
-    ASSERT(option->ownerSelectElement() == this);
+    DCHECK_EQ(option->ownerSelectElement(), this);
     if (optionIsSelected)
         selectOption(option, multiple() ? 0 : DeselectOtherOptions);
     else if (!usesMenuList() || multiple())
         selectOption(nullptr, multiple() ? 0 : DeselectOtherOptions);
     else
         selectOption(nextSelectableOption(nullptr), DeselectOtherOptions);
 }
 
 void HTMLSelectElement::optionInserted(HTMLOptionElement& option, bool optionIsSelected)
 {
-    ASSERT(option.ownerSelectElement() == this);
+    DCHECK_EQ(option.ownerSelectElement(), this);
     setRecalcListItems();
     if (optionIsSelected) {
         selectOption(&option, multiple() ? 0 : DeselectOtherOptions);
     } else {
         // No need to reset if we already have a selected option.
         if (!m_lastOnChangeOption)
             resetToDefaultSelection();
     }
     setNeedsValidityCheck();
     m_lastOnChangeSelection.clear();
@@ skipping 171 matching lines @@
     recalcListItems();
 
     const ListItems& items = listItems();
     size_t itemsSize = items.size();
     if (itemsSize == 0)
         return;
 
     selectOption(nullptr, DeselectOtherOptions);
 
     // The saved state should have at least one value and an index.
-    ASSERT(state.valueSize() >= 2);
+    DCHECK_GE(state.valueSize(), 2u);
     if (!multiple()) {
         size_t index = state[1].toUInt();
         if (index < itemsSize && isHTMLOptionElement(items[index]) && toHTMLOptionElement(items[index])->value() == state[0]) {
             toHTMLOptionElement(items[index])->setSelectedState(true);
             toHTMLOptionElement(items[index])->setDirty(true);
             m_lastOnChangeOption = toHTMLOptionElement(items[index]);
         } else {
             size_t foundIndex = searchOptionsForValue(state[0], 0, itemsSize);
             if (foundIndex != kNotFound) {
                 toHTMLOptionElement(items[foundIndex])->setSelectedState(true);
@@ skipping 210 matching lines @@
     }
 
     if (event->type() == EventTypeNames::blur) {
         if (popupIsVisible())
             hidePopup();
     }
 }
 
 void HTMLSelectElement::updateSelectedState(HTMLOptionElement* clickedOption, bool multi, bool shift)
 {
-    ASSERT(clickedOption);
+    DCHECK(clickedOption);
     // Save the selection so it can be compared to the new selection when
     // dispatching change events during mouseup, or after autoscroll finishes.
     saveLastSelection();
 
     m_activeSelectionState = true;
 
     bool shiftSelect = m_multiple && shift;
     bool multiSelect = m_multiple && multi && !shift;
 
     // Keep track of whether an active selection (like during drag selection),
@@ skipping 645 matching lines @@
 }
 
 void HTMLSelectElement::didMutateSubtree()
 {
     DCHECK(popupIsVisible());
     DCHECK(m_popup);
     m_popup->updateFromElement(PopupMenu::ByDOMChange);
 }
 
 } // namespace blink