RELEASE_ASSERT -> CHECK and ASSERT -> DCHECK in web.

third_party/WebKit/Source/web/PopupMenuImpl.cpp

 // Copyright (c) 2014 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.
 
 #include "web/PopupMenuImpl.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExecutionContextTask.h"
@@ skipping 151 matching lines @@
 class PopupMenuImpl::ItemIterationContext {
     STACK_ALLOCATED();
 public:
     ItemIterationContext(const ComputedStyle& style, SharedBuffer* buffer)
         : m_baseStyle(style)
         , m_backgroundColor(style.visitedDependentColor(CSSPropertyBackgroundColor))
         , m_listIndex(0)
         , m_isInGroup(false)
         , m_buffer(buffer)
     {
-        ASSERT(m_buffer);
+        DCHECK(m_buffer);
 #if OS(LINUX)
         // On other platforms, the <option> background color is the same as the
         // <select> background color. On Linux, that makes the <option>
         // background color very dark, so by default, try to use a lighter
         // background color for <option>s.
         if (LayoutTheme::theme().systemColor(CSSValueButtonface) == m_backgroundColor)
             m_backgroundColor = LayoutTheme::theme().systemColor(CSSValueMenu);
 #endif
     }
 
     void serializeBaseStyle()
     {
-        ASSERT(!m_isInGroup);
+        DCHECK(!m_isInGroup);
         PagePopupClient::addString("baseStyle: {", m_buffer);
         addProperty("backgroundColor", m_backgroundColor.serialized(), m_buffer);
         addProperty("color", baseStyle().visitedDependentColor(CSSPropertyColor).serialized(), m_buffer);
         addProperty("textTransform", String(textTransformToString(baseStyle().textTransform())), m_buffer);
         addProperty("fontSize", baseFont().specifiedSize(), m_buffer);
         addProperty("fontStyle", String(fontStyleToString(baseFont().style())), m_buffer);
         addProperty("fontVariant", String(fontVariantToString(baseFont().variant())), m_buffer);
 
         PagePopupClient::addString("fontFamily: [", m_buffer);
         for (const FontFamily* f = &baseFont().family(); f; f = f->next()) {
             addJavaScriptString(f->family().getString(), m_buffer);
             if (f->next())
                 PagePopupClient::addString(",", m_buffer);
         }
         PagePopupClient::addString("]", m_buffer);
         PagePopupClient::addString("},\n", m_buffer);
     }
 
     Color backgroundColor() const { return m_isInGroup ? m_groupStyle->visitedDependentColor(CSSPropertyBackgroundColor) : m_backgroundColor; }
     // Do not use baseStyle() for background-color, use backgroundColor()
     // instead.
     const ComputedStyle& baseStyle() { return m_isInGroup ? *m_groupStyle : m_baseStyle; }
     const FontDescription& baseFont() { return m_isInGroup ? m_groupStyle->getFontDescription() : m_baseStyle.getFontDescription(); }
     void startGroupChildren(const ComputedStyle& groupStyle)
     {
-        ASSERT(!m_isInGroup);
+        DCHECK(!m_isInGroup);
         PagePopupClient::addString("children: [", m_buffer);
         m_isInGroup = true;
         m_groupStyle = &groupStyle;
     }
     void finishGroupIfNecessary()
     {
         if (!m_isInGroup)
             return;
         PagePopupClient::addString("],},\n", m_buffer);
         m_isInGroup = false;
@@ skipping 19 matching lines @@
 PopupMenuImpl::PopupMenuImpl(ChromeClientImpl* chromeClient, HTMLSelectElement& ownerElement)
     : m_chromeClient(chromeClient)
     , m_ownerElement(ownerElement)
     , m_popup(nullptr)
     , m_needsUpdate(false)
 {
 }
 
 PopupMenuImpl::~PopupMenuImpl()
 {
-    ASSERT(!m_popup);
+    DCHECK(!m_popup);
 }
 
 DEFINE_TRACE(PopupMenuImpl)
 {
     visitor->trace(m_chromeClient);
     visitor->trace(m_ownerElement);
     PopupMenu::trace(visitor);
 }
 
 void PopupMenuImpl::writeDocument(SharedBuffer* data)
@@ skipping 35 matching lines @@
     addProperty("paddingStart", isRTL ? ownerElement.clientPaddingRight().toDouble() / zoom : ownerElement.clientPaddingLeft().toDouble() / zoom, data);
     PagePopupClient::addString("};\n", data);
     data->append(Platform::current()->loadResource("pickerCommon.js"));
     data->append(Platform::current()->loadResource("listPicker.js"));
     PagePopupClient::addString("</script></body>\n", data);
 }
 
 void PopupMenuImpl::addElementStyle(ItemIterationContext& context, HTMLElement& element)
 {
     const ComputedStyle* style = m_ownerElement->itemComputedStyle(element);
-    ASSERT(style);
+    DCHECK(style);
     SharedBuffer* data = context.m_buffer;
     // TODO(tkent): We generate unnecessary "style: {\n},\n" even if no
     // additional style.
     PagePopupClient::addString("style: {\n", data);
     if (style->visibility() == HIDDEN)
         addProperty("visibility", String("hidden"), data);
     if (style->display() == NONE)
         addProperty("display", String("none"), data);
     const ComputedStyle& baseStyle = context.baseStyle();
     if (baseStyle.direction() != style->direction())
@@ skipping 79 matching lines @@
 }
 
 void PopupMenuImpl::selectFontsFromOwnerDocument(Document& document)
 {
     Document& ownerDocument = ownerElement().document();
     document.styleEngine().setFontSelector(PopupMenuCSSFontSelector::create(&document, ownerDocument.styleEngine().fontSelector()));
 }
 
 void PopupMenuImpl::setValueAndClosePopup(int numValue, const String& stringValue)
 {
-    ASSERT(m_popup);
-    ASSERT(m_ownerElement);
+    DCHECK(m_popup);
+    DCHECK(m_ownerElement);
     RawPtr<PopupMenuImpl> protector(this);
     bool success;
     int listIndex = stringValue.toInt(&success);
-    ASSERT(success);
+    DCHECK(success);
     {
         EventQueueScope scope;
         m_ownerElement->valueChanged(listIndex);
         if (m_popup)
             m_chromeClient->closePagePopup(m_popup);
         // 'change' event is dispatched here.  For compatbility with
         // Angular 1.2, we need to dispatch a change event before
         // mouseup/click events.
     }
     // We dispatch events on the owner element to match the legacy behavior.
     // Other browsers dispatch click events before and after showing the popup.
     if (m_ownerElement) {
         PlatformMouseEvent event;
         RawPtr<Element> owner = &ownerElement();
         owner->dispatchMouseEvent(event, EventTypeNames::mouseup);
         owner->dispatchMouseEvent(event, EventTypeNames::click);
     }
 }
 
 void PopupMenuImpl::setValue(const String& value)
 {
-    ASSERT(m_ownerElement);
+    DCHECK(m_ownerElement);
     bool success;
     int listIndex = value.toInt(&success);
-    ASSERT(success);
+    DCHECK(success);
     m_ownerElement->provisionalSelectionChanged(listIndex);
 }
 
 void PopupMenuImpl::didClosePopup()
 {
     // Clearing m_popup first to prevent from trying to close the popup again.
     m_popup = nullptr;
     RawPtr<PopupMenuImpl> protector(this);
     if (m_ownerElement)
         m_ownerElement->popupDidHide();
@@ skipping 18 matching lines @@
 }
 
 void PopupMenuImpl::dispose()
 {
     if (m_popup)
         m_chromeClient->closePagePopup(m_popup);
 }
 
 void PopupMenuImpl::show()
 {
-    ASSERT(!m_popup);
+    DCHECK(!m_popup);
     m_popup = m_chromeClient->openPagePopup(this);
 }
 
 void PopupMenuImpl::hide()
 {
     if (m_popup)
         m_chromeClient->closePagePopup(m_popup);
 }
 
 void PopupMenuImpl::updateFromElement()
@@ skipping 48 matching lines @@
 
 void PopupMenuImpl::disconnectClient()
 {
     m_ownerElement = nullptr;
     // Cannot be done during finalization, so instead done when the
     // layout object is destroyed and disconnected.
     dispose();
 }
 
 } // namespace blink