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

third_party/WebKit/Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 247 matching lines @@
 
 private:
     WebAutofillClient* const m_client;
     bool* const m_userGestureObserved;
 };
 
 UserGestureNotifier::UserGestureNotifier(WebAutofillClient* client, bool* userGestureObserved)
     : m_client(client)
     , m_userGestureObserved(userGestureObserved)
 {
-    ASSERT(m_userGestureObserved);
+    DCHECK(m_userGestureObserved);
 }
 
 UserGestureNotifier::~UserGestureNotifier()
 {
     if (!*m_userGestureObserved && UserGestureIndicator::processedUserGestureSinceLoad()) {
         *m_userGestureObserved = true;
         if (m_client)
             m_client->firstUserGestureObserved();
     }
 }
@@ skipping 76 matching lines @@
     Page::allVisitedStateChanged(invalidateVisitedLinkHashes);
 }
 
 void WebView::willEnterModalLoop()
 {
     pageLoadDeferrerStack().append(adoptPtr(new ScopedPageLoadDeferrer()));
 }
 
 void WebView::didExitModalLoop()
 {
-    ASSERT(pageLoadDeferrerStack().size());
+    DCHECK(pageLoadDeferrerStack().size());
     pageLoadDeferrerStack().removeLast();
 }
 
 void WebViewImpl::setMainFrame(WebFrame* frame)
 {
     frame->toImplBase()->initializeCoreFrame(&page()->frameHost(), 0, nullAtom, nullAtom);
 }
 
 void WebViewImpl::setCredentialManagerClient(WebCredentialManagerClient* webCredentialManagerClient)
 {
-    ASSERT(m_page);
+    DCHECK(m_page);
     provideCredentialManagerClientTo(*m_page, new CredentialManagerClient(webCredentialManagerClient));
 }
 
 void WebViewImpl::setPrerendererClient(WebPrerendererClient* prerendererClient)
 {
-    ASSERT(m_page);
+    DCHECK(m_page);
     providePrerendererClientTo(*m_page, new PrerendererClientImpl(prerendererClient));
 }
 
 void WebViewImpl::setSpellCheckClient(WebSpellCheckClient* spellCheckClient)
 {
     m_spellCheckClient = spellCheckClient;
 }
 
 // static
 HashSet<WebViewImpl*>& WebViewImpl::allInstances()
@@ skipping 78 matching lines @@
 
     m_devToolsEmulator = DevToolsEmulator::create(this);
 
     allInstances().add(this);
 
     m_pageImportanceSignals.setObserver(client);
 }
 
 WebViewImpl::~WebViewImpl()
 {
-    ASSERT(!m_page);
+    DCHECK(!m_page);
 
     // Each highlight uses m_owningWebViewImpl->m_linkHighlightsTimeline
     // in destructor. m_linkHighlightsTimeline might be destroyed earlier
     // than m_linkHighlights.
-    ASSERT(m_linkHighlights.isEmpty());
+    DCHECK(m_linkHighlights.isEmpty());
 }
 
 WebDevToolsAgentImpl* WebViewImpl::mainFrameDevToolsAgentImpl()
 {
     WebLocalFrameImpl* mainFrame = mainFrameImpl();
     return mainFrame ? mainFrame->devToolsAgentImpl() : nullptr;
 }
 
 InspectorOverlay* WebViewImpl::inspectorOverlay()
 {
     if (WebDevToolsAgentImpl* devtools = mainFrameDevToolsAgentImpl())
         return devtools->overlay();
     return nullptr;
 }
 
 WebLocalFrameImpl* WebViewImpl::mainFrameImpl() const
 {
     return m_page && m_page->mainFrame() && m_page->mainFrame()->isLocalFrame()
         ? WebLocalFrameImpl::fromFrame(m_page->deprecatedLocalMainFrame()) : nullptr;
 }
 
 bool WebViewImpl::tabKeyCyclesThroughElements() const
 {
-    ASSERT(m_page);
+    DCHECK(m_page);
     return m_page->tabKeyCyclesThroughElements();
 }
 
 void WebViewImpl::setTabKeyCyclesThroughElements(bool value)
 {
     if (m_page)
         m_page->setTabKeyCyclesThroughElements(value);
 }
 
 void WebViewImpl::handleMouseLeave(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     m_client->setMouseOverURL(WebURL());
     PageWidgetEventHandler::handleMouseLeave(mainFrame, event);
 }
 
 void WebViewImpl::handleMouseDown(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     // If there is a popup open, close it as the user is clicking on the page
     // (outside of the popup). We also save it so we can prevent a click on an
     // element from immediately reopening the same popup.
     RefPtr<WebPagePopupImpl> pagePopup;
     if (event.button == WebMouseEvent::ButtonLeft) {
         pagePopup = m_pagePopup;
         hidePopups();
-        ASSERT(!m_pagePopup);
+        DCHECK(!m_pagePopup);
     }
 
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     // Take capture on a mouse down on a plugin so we can send it mouse events.
     // If the hit node is a plugin but a scrollbar is over it don't start mouse
     // capture because it will interfere with the scrollbar receiving events.
     IntPoint point(event.x, event.y);
     if (event.button == WebMouseEvent::ButtonLeft && m_page->mainFrame()->isLocalFrame()) {
         point = m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(point);
@@ skipping 106 matching lines @@
     gestureEvent.x = m_positionOnFlingStart.x;
     gestureEvent.y = m_positionOnFlingStart.y;
     gestureEvent.globalX = m_globalPositionOnFlingStart.x;
     gestureEvent.globalY = m_globalPositionOnFlingStart.y;
     gestureEvent.modifiers = m_flingModifier;
     return gestureEvent;
 }
 
 bool WebViewImpl::scrollBy(const WebFloatSize& delta, const WebFloatSize& velocity)
 {
-    ASSERT(m_flingSourceDevice != WebGestureDeviceUninitialized);
+    DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
     if (!m_page || !m_page->mainFrame() || !m_page->mainFrame()->isLocalFrame() || !m_page->deprecatedLocalMainFrame()->view())
         return false;
 
     if (m_flingSourceDevice == WebGestureDeviceTouchpad) {
         WebMouseWheelEvent syntheticWheel;
         const float tickDivisor = WheelEvent::TickMultiplier;
 
         syntheticWheel.type = WebInputEvent::MouseWheel;
         syntheticWheel.timeStampSeconds = WTF::monotonicallyIncreasingTime();
         syntheticWheel.deltaX = delta.width;
@@ skipping 56 matching lines @@
     switch (event.type) {
     case WebInputEvent::GestureFlingStart: {
         if (mainFrameImpl()->frame()->eventHandler().isScrollbarHandlingGestures())
             break;
         endActiveFlingAnimation();
         m_client->cancelScheduledContentIntents();
         m_positionOnFlingStart = WebPoint(event.x, event.y);
         m_globalPositionOnFlingStart = WebPoint(event.globalX, event.globalY);
         m_flingModifier = event.modifiers;
         m_flingSourceDevice = event.sourceDevice;
-        ASSERT(m_flingSourceDevice != WebGestureDeviceUninitialized);
+        DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
         OwnPtr<WebGestureCurve> flingCurve = adoptPtr(Platform::current()->createFlingAnimationCurve(event.sourceDevice, WebFloatPoint(event.data.flingStart.velocityX, event.data.flingStart.velocityY), WebSize()));
-        ASSERT(flingCurve);
+        DCHECK(flingCurve);
         m_gestureAnimation = WebActiveGestureAnimation::createAtAnimationStart(flingCurve.release(), this);
         scheduleAnimation();
         eventResult = WebInputEventResult::HandledSystem;
 
         // Plugins may need to see GestureFlingStart to balance
         // GestureScrollBegin (since the former replaces GestureScrollEnd when
         // transitioning to a fling).
         PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(), event);
         // TODO(dtapuska): Why isn't the response used?
         mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(platformEvent);
@@ skipping 67 matching lines @@
         break;
     }
 
     switch (event.type) {
     case WebInputEvent::GestureTap: {
         // If there is a popup open, close it as the user is clicking on the page
         // (outside of the popup). We also save it so we can prevent a tap on an
         // element from immediately reopening the same popup.
         RefPtr<WebPagePopupImpl> pagePopup = m_pagePopup;
         hidePopups();
-        ASSERT(!m_pagePopup);
+        DCHECK(!m_pagePopup);
 
         m_client->cancelScheduledContentIntents();
         if (detectContentOnTouch(targetedEvent)) {
             eventResult = WebInputEventResult::HandledSystem;
             break;
         }
 
         // Don't trigger a disambiguation popup on sites designed for mobile devices.
         // Instead, assume that the page has been designed with big enough buttons and links.
         // Don't trigger a disambiguation popup when screencasting, since it's implemented outside of
@@ skipping 65 matching lines @@
     }
     default:
         ASSERT_NOT_REACHED();
     }
     m_client->didHandleGestureEvent(event, eventCancelled);
     return eventResult;
 }
 
 WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent(const WebGestureEvent& pinchEvent)
 {
-    ASSERT(pinchEvent.type == WebInputEvent::GesturePinchUpdate);
+    DCHECK_EQ(pinchEvent.type, WebInputEvent::GesturePinchUpdate);
 
     // Touchscreen pinch events should not reach Blink.
-    ASSERT(pinchEvent.sourceDevice == WebGestureDeviceTouchpad);
+    DCHECK_EQ(pinchEvent.sourceDevice, WebGestureDeviceTouchpad);
 
     // For pinch gesture events, match typical trackpad behavior on Windows by sending fake
     // wheel events with the ctrl modifier set when we see trackpad pinch gestures.  Ideally
     // we'd someday get a platform 'pinch' event and send that instead.
     WebMouseWheelEvent wheelEvent;
     wheelEvent.type = WebInputEvent::MouseWheel;
     wheelEvent.timeStampSeconds = pinchEvent.timeStampSeconds;
     wheelEvent.windowX = wheelEvent.x = pinchEvent.x;
     wheelEvent.windowY = wheelEvent.y = pinchEvent.y;
     wheelEvent.globalX = pinchEvent.globalX;
     wheelEvent.globalY = pinchEvent.globalY;
     wheelEvent.modifiers =
         pinchEvent.modifiers | WebInputEvent::ControlKey;
     wheelEvent.deltaX = 0;
 
     // The function to convert scales to deltaY values is designed to be
     // compatible with websites existing use of wheel events, and with existing
     // Windows trackpad behavior.  In particular, we want:
     //  - deltas should accumulate via addition: f(s1*s2)==f(s1)+f(s2)
     //  - deltas should invert via negation: f(1/s) == -f(s)
     //  - zoom in should be positive: f(s) > 0 iff s > 1
     //  - magnitude roughly matches wheels: f(2) > 25 && f(2) < 100
     //  - a formula that's relatively easy to use from JavaScript
     // Note that 'wheel' event deltaY values have their sign inverted.  So to
     // convert a wheel deltaY back to a scale use Math.exp(-deltaY/100).
-    ASSERT(pinchEvent.data.pinchUpdate.scale > 0);
+    DCHECK_GT(pinchEvent.data.pinchUpdate.scale, 0);
     wheelEvent.deltaY = 100.0f * log(pinchEvent.data.pinchUpdate.scale);
     wheelEvent.hasPreciseScrollingDeltas = true;
     wheelEvent.wheelTicksX = 0;
     wheelEvent.wheelTicksY =
         pinchEvent.data.pinchUpdate.scale > 1 ? 1 : -1;
     wheelEvent.canScroll = false;
 
     return handleInputEvent(wheelEvent);
 }
 
 void WebViewImpl::transferActiveWheelFlingAnimation(const WebActiveWheelFlingParameters& parameters)
 {
     TRACE_EVENT0("blink", "WebViewImpl::transferActiveWheelFlingAnimation");
-    ASSERT(!m_gestureAnimation);
+    DCHECK(!m_gestureAnimation);
     m_positionOnFlingStart = parameters.point;
     m_globalPositionOnFlingStart = parameters.globalPoint;
     m_flingModifier = parameters.modifiers;
     OwnPtr<WebGestureCurve> curve = adoptPtr(Platform::current()->createFlingAnimationCurve(parameters.sourceDevice, WebFloatPoint(parameters.delta), parameters.cumulativeScroll));
-    ASSERT(curve);
+    DCHECK(curve);
     m_gestureAnimation = WebActiveGestureAnimation::createWithTimeOffset(curve.release(), this, parameters.startTime);
-    ASSERT(parameters.sourceDevice != WebGestureDeviceUninitialized);
+    DCHECK_NE(parameters.sourceDevice, WebGestureDeviceUninitialized);
     m_flingSourceDevice = parameters.sourceDevice;
     scheduleAnimation();
 }
 
 bool WebViewImpl::endActiveFlingAnimation()
 {
     if (m_gestureAnimation) {
         m_gestureAnimation.clear();
         m_flingSourceDevice = WebGestureDeviceUninitialized;
         if (m_layerTreeView)
@@ skipping 81 matching lines @@
         FontCache::acceptLanguagesChanged(m_client->acceptLanguages());
 
     if (!page())
         return;
 
     page()->acceptLanguagesChanged();
 }
 
 WebInputEventResult WebViewImpl::handleKeyEvent(const WebKeyboardEvent& event)
 {
-    ASSERT((event.type == WebInputEvent::RawKeyDown)
+    DCHECK((event.type == WebInputEvent::RawKeyDown)
         || (event.type == WebInputEvent::KeyDown)
         || (event.type == WebInputEvent::KeyUp));
     TRACE_EVENT2("input", "WebViewImpl::handleKeyEvent",
         "type", inputTypeToName(event.type),
         "text", String(event.text).utf8());
 
     // Halt an in-progress fling on a key event.
     endActiveFlingAnimation();
 
     // Please refer to the comments explaining the m_suppressNextKeypressEvent
@@ skipping 68 matching lines @@
     }
 #endif // !OS(MACOSX)
 
     if (keyEventDefault(event))
         return WebInputEventResult::HandledSystem;
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult WebViewImpl::handleCharEvent(const WebKeyboardEvent& event)
 {
-    ASSERT(event.type == WebInputEvent::Char);
+    DCHECK_EQ(event.type, WebInputEvent::Char);
     TRACE_EVENT1("input", "WebViewImpl::handleCharEvent",
         "text", String(event.text).utf8());
 
     // Please refer to the comments explaining the m_suppressNextKeypressEvent
     // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
     // handled by Webkit. A keyDown event is typically associated with a
     // keyPress(char) event and a keyUp event. We reset this flag here as it
     // only applies to the current keyPress event.
     bool suppress = m_suppressNextKeypressEvent;
     m_suppressNextKeypressEvent = false;
@@ skipping 84 matching lines @@
 
     const int maximumRightMargin = maxSize.width - (source.width + absoluteSourceX);
     if (rightMargin > maximumRightMargin) {
         rightMargin = maximumRightMargin;
         leftMargin = std::min(leftMargin, std::max(rightMargin, minimumMargin));
     }
 
     const int newWidth = source.width + leftMargin + rightMargin;
     const int newX = source.x - leftMargin;
 
-    ASSERT(newWidth >= 0);
-    ASSERT(scrollOffset.width() + newX + newWidth <= maxSize.width);
+    DCHECK_GE(newWidth, 0);
+    DCHECK_LE(scrollOffset.width() + newX + newWidth, maxSize.width);
 
     return WebRect(newX, source.y, newWidth, source.height);
 }
 
 float WebViewImpl::maximumLegiblePageScale() const
 {
     // Pages should be as legible as on desktop when at dpi scale, so no
     // need to zoom in further when automatically determining zoom level
     // (after double tap, find in page, etc), though the user should still
     // be allowed to manually pinch zoom in further if they desire.
@@ skipping 404 matching lines @@
         break;
     default:
         return false;
     }
 
     return true;
 }
 
 PagePopup* WebViewImpl::openPagePopup(PagePopupClient* client)
 {
-    ASSERT(client);
+    DCHECK(client);
     if (hasOpenedPopup())
         hidePopups();
-    ASSERT(!m_pagePopup);
+    DCHECK(!m_pagePopup);
 
     WebWidget* popupWidget = m_client->createPopupMenu(WebPopupTypePage);
     // createPopupMenu returns nullptr if this renderer process is about to die.
     if (!popupWidget)
         return nullptr;
     m_pagePopup = toWebPagePopupImpl(popupWidget);
     if (!m_pagePopup->initialize(this, client)) {
         m_pagePopup->closePopup();
         m_pagePopup = nullptr;
     }
     enablePopupMouseWheelEventListener();
     return m_pagePopup.get();
 }
 
 void WebViewImpl::closePagePopup(PagePopup* popup)
 {
-    ASSERT(popup);
+    DCHECK(popup);
     WebPagePopupImpl* popupImpl = toWebPagePopupImpl(popup);
-    ASSERT(m_pagePopup.get() == popupImpl);
+    DCHECK_EQ(m_pagePopup.get(), popupImpl);
     if (m_pagePopup.get() != popupImpl)
         return;
     m_pagePopup->closePopup();
 }
 
 void WebViewImpl::cleanupPagePopup()
 {
     m_pagePopup = nullptr;
     disablePopupMouseWheelEventListener();
 }
 
 void WebViewImpl::cancelPagePopup()
 {
     if (m_pagePopup)
         m_pagePopup->cancel();
 }
 
 void WebViewImpl::enablePopupMouseWheelEventListener()
 {
     // TODO(kenrb): Popup coordination for out-of-process iframes needs to be
     // added. Because of the early return here a select element
     // popup can remain visible even when the element underneath it is
     // scrolled to a new position. This is part of a larger set of issues with
     // popups.
     // See https://crbug.com/566130
     if (!mainFrameImpl() || !mainFrameImpl()->frame()->isLocalFrame())
         return;
-    ASSERT(!m_popupMouseWheelEventListener);
+    DCHECK(!m_popupMouseWheelEventListener);
     Document* document = mainFrameImpl()->frame()->document();
-    ASSERT(document);
+    DCHECK(document);
     // We register an empty event listener, EmptyEventListener, so that mouse
     // wheel events get sent to the WebView.
     m_popupMouseWheelEventListener = EmptyEventListener::create();
     document->addEventListener(EventTypeNames::mousewheel, m_popupMouseWheelEventListener, false);
 }
 
 void WebViewImpl::disablePopupMouseWheelEventListener()
 {
     // TODO(kenrb): Concerns the same as in enablePopupMouseWheelEventListener.
     // See https://crbug.com/566130
     if (!mainFrameImpl() || !mainFrameImpl()->frame()->isLocalFrame())
         return;
-    ASSERT(m_popupMouseWheelEventListener);
+    DCHECK(m_popupMouseWheelEventListener);
     Document* document = mainFrameImpl()->frame()->document();
-    ASSERT(document);
+    DCHECK(document);
     // Document may have already removed the event listener, for instance, due
     // to a navigation, but remove it anyway.
     document->removeEventListener(EventTypeNames::mousewheel, m_popupMouseWheelEventListener.release(), false);
 }
 
 LocalDOMWindow* WebViewImpl::pagePopupWindow() const
 {
     return m_pagePopup ? m_pagePopup->window() : nullptr;
 }
 
 Frame* WebViewImpl::focusedCoreFrame() const
 {
     return m_page ? m_page->focusController().focusedOrMainFrame() : nullptr;
 }
 
 WebViewImpl* WebViewImpl::fromPage(Page* page)
 {
     return page ? static_cast<WebViewImpl*>(page->chromeClient().webView()) : nullptr;
 }
 
 // WebWidget ------------------------------------------------------------------
 
 void WebViewImpl::close()
 {
     WebDevToolsAgentImpl::webViewImplClosed(this);
-    ASSERT(allInstances().contains(this));
+    DCHECK(allInstances().contains(this));
     allInstances().remove(this);
 
     if (m_page) {
         // Initiate shutdown for the entire frameset.  This will cause a lot of
         // notifications to be sent.
         m_page->willBeDestroyed();
         m_page.clear();
     }
 
     // Reset the delegate to prevent notifications being sent as we're being
@@ skipping 71 matching lines @@
     view->setTopControlsViewportAdjustment(topControlsViewportAdjustment / minimumPageScaleFactor());
 }
 
 TopControls& WebViewImpl::topControls()
 {
     return page()->frameHost().topControls();
 }
 
 void WebViewImpl::resizeViewWhileAnchored(FrameView* view)
 {
-    ASSERT(mainFrameImpl() && mainFrameImpl()->frame()->isLocalFrame());
+    DCHECK(mainFrameImpl() && mainFrameImpl()->frame()->isLocalFrame());

[tkent, 2016/03/31 23:05:21]

Please split this into two.
    DCHECK(mainFrameImpl());
    DCHECK(mainFrameImpl()->frame()->isLocalFrame());

 
     {
         // Avoids unnecessary invalidations while various bits of state in TextAutosizer are updated.
         TextAutosizer::DeferUpdatePageInfo deferUpdatePageInfo(page());
         performResize();
     }
 
     m_fullscreenController->updateSize();
 
     // Update lifecyle phases immediately to recalculate the minimum scale limit for rotation anchoring,
@@ skipping 48 matching lines @@
 }
 
 void WebViewImpl::didExitFullScreen()
 {
     m_fullscreenController->didExitFullScreen();
 }
 
 void WebViewImpl::beginFrame(double lastFrameTimeMonotonic)
 {
     TRACE_EVENT1("blink", "WebViewImpl::beginFrame", "frameTime", lastFrameTimeMonotonic);
-    ASSERT(lastFrameTimeMonotonic);
+    DCHECK(lastFrameTimeMonotonic);
 
     // Create synthetic wheel events as necessary for fling.
     if (m_gestureAnimation) {
         if (m_gestureAnimation->animate(lastFrameTimeMonotonic))
             scheduleAnimation();
         else {
-            ASSERT(m_flingSourceDevice != WebGestureDeviceUninitialized);
+            DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
             WebGestureDevice lastFlingSourceDevice = m_flingSourceDevice;
             endActiveFlingAnimation();
 
             PlatformGestureEvent endScrollEvent(PlatformEvent::GestureScrollEnd,
                 m_positionOnFlingStart, m_globalPositionOnFlingStart,
                 IntSize(), 0, PlatformEvent::NoModifiers, lastFlingSourceDevice == WebGestureDeviceTouchpad ? PlatformGestureSourceTouchpad : PlatformGestureSourceTouchscreen);
             endScrollEvent.setScrollGestureData(0, 0, ScrollByPrecisePixel, 0, 0, true, false, -1 /* null plugin id */);
 
             mainFrameImpl()->frame()->eventHandler().handleGestureScrollEnd(endScrollEvent);
         }
@@ skipping 50 matching lines @@
             m_shouldDispatchFirstLayoutAfterFinishedLoading = false;
             client()->didMeaningfulLayout(WebMeaningfulLayout::FinishedLoading);
         }
     }
 }
 
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
     // This should only be used when compositing is not being used for this
     // WebView, and it is painting into the recording of its parent.
-    ASSERT(!isAcceleratedCompositingActive());
+    DCHECK(!isAcceleratedCompositingActive());
 
     double paintStart = currentTime();
     PageWidgetDelegate::paint(*m_page, canvas, rect, *m_page->deprecatedLocalMainFrame());
     double paintEnd = currentTime();
     double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
     DEFINE_STATIC_LOCAL(CustomCountHistogram, softwarePaintDurationHistogram, ("Renderer4.SoftwarePaintDurationMS", 0, 120, 30));
     softwarePaintDurationHistogram.count((paintEnd - paintStart) * 1000);
     DEFINE_STATIC_LOCAL(CustomCountHistogram, softwarePaintRateHistogram, ("Renderer4.SoftwarePaintMegapixPerSecond", 10, 210, 30));
     softwarePaintRateHistogram.count(pixelsPerSec / 1000000);
 }
 
 #if OS(ANDROID)
 void WebViewImpl::paintCompositedDeprecated(WebCanvas* canvas, const WebRect& rect)
 {
     // Note: This method exists on OS(ANDROID) and will hopefully be
     //       removed once the link disambiguation feature renders using
     //       the compositor.
-    ASSERT(isAcceleratedCompositingActive());
+    DCHECK(isAcceleratedCompositingActive());
 
     PageWidgetDelegate::paintIgnoringCompositing(*m_page, canvas, rect, *m_page->deprecatedLocalMainFrame());
 }
 #endif
 
 void WebViewImpl::layoutAndPaintAsync(WebLayoutAndPaintAsyncCallback* callback)
 {
     m_layerTreeView->layoutAndPaintAsync(callback);
 }
 
@@ skipping 341 matching lines @@
 
     LocalFrame* focused = toLocalFrame(frame);
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     const EphemeralRange range = focused->inputMethodController().compositionEphemeralRange();
     if (range.isNull())
         return false;
 
     Element* editable = focused->selection().rootEditableElementOrDocumentElement();
-    ASSERT(editable);
+    DCHECK(editable);
     PlainTextRange plainTextRange(PlainTextRange::create(*editable, range));
     if (plainTextRange.isNull())
         return false;
     *location = plainTextRange.start();
     *length = plainTextRange.length();
     return true;
 }
 
 WebTextInputInfo WebViewImpl::textInputInfo()
 {
@@ skipping 377 matching lines @@
     if (mainFrameImpl()->frameView())
         mainFrameImpl()->frameView()->windowResizerRectChanged();
 }
 
 // WebView --------------------------------------------------------------------
 
 WebSettingsImpl* WebViewImpl::settingsImpl()
 {
     if (!m_webSettings)
         m_webSettings = adoptPtr(new WebSettingsImpl(&m_page->settings(), m_devToolsEmulator.get()));
-    ASSERT(m_webSettings);
+    DCHECK(m_webSettings);
     return m_webSettings.get();
 }
 
 WebSettings* WebViewImpl::settings()
 {
     return settingsImpl();
 }
 
 WebString WebViewImpl::pageEncoding() const
 {
@@ skipping 318 matching lines @@
     return page()->frameHost().visualViewport().scale();
 }
 
 float WebViewImpl::clampPageScaleFactorToLimits(float scaleFactor) const
 {
     return pageScaleConstraintsSet().finalConstraints().clampToConstraints(scaleFactor);
 }
 
 void WebViewImpl::setVisualViewportOffset(const WebFloatPoint& offset)
 {
-    ASSERT(page());
+    DCHECK(page());
     page()->frameHost().visualViewport().setLocation(offset);
 }
 
 WebFloatPoint WebViewImpl::visualViewportOffset() const
 {
-    ASSERT(page());
+    DCHECK(page());
     return page()->frameHost().visualViewport().visibleRect().location();
 }
 
 WebFloatSize WebViewImpl::visualViewportSize() const
 {
-    ASSERT(page());
+    DCHECK(page());
     return page()->frameHost().visualViewport().visibleRect().size();
 }
 
 void WebViewImpl::scrollAndRescaleViewports(float scaleFactor,
     const IntPoint& mainFrameOrigin,
     const FloatPoint& visualViewportOrigin)
 {
     if (!page())
         return;
 
     if (!mainFrameImpl())
         return;
 
     FrameView * view = mainFrameImpl()->frameView();
     if (!view)
         return;
 
     // Order is important: visual viewport location is clamped based on
     // main frame scroll position and visual viewport scale.
 
     view->setScrollPosition(mainFrameOrigin, ProgrammaticScroll);
 
     setPageScaleFactor(scaleFactor);
 
     page()->frameHost().visualViewport().setLocation(visualViewportOrigin);
 }
 
 void WebViewImpl::setPageScaleFactorAndLocation(float scaleFactor, const FloatPoint& location)
 {
-    ASSERT(page());
+    DCHECK(page());
 
     page()->frameHost().visualViewport().setScaleAndLocation(
         clampPageScaleFactorToLimits(scaleFactor),
         location);
 }
 
 void WebViewImpl::setPageScaleFactor(float scaleFactor)
 {
-    ASSERT(page());
+    DCHECK(page());
 
     scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
     if (scaleFactor == pageScaleFactor())
         return;
 
     page()->frameHost().visualViewport().setScale(scaleFactor);
 }
 
 void WebViewImpl::setDeviceScaleFactor(float scaleFactor)
 {
@@ skipping 416 matching lines @@
     }
 }
 
 WebDragOperation WebViewImpl::dragTargetDragEnter(
     const WebDragData& webDragData,
     const WebPoint& clientPoint,
     const WebPoint& screenPoint,
     WebDragOperationsMask operationsAllowed,
     int modifiers)
 {
-    ASSERT(!m_currentDragData);
+    DCHECK(!m_currentDragData);
 
     m_currentDragData = DataObject::create(webDragData);
     m_operationsAllowed = operationsAllowed;
 
     return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragEnter, modifiers);
 }
 
 WebDragOperation WebViewImpl::dragTargetDragOver(
     const WebPoint& clientPoint,
     const WebPoint& screenPoint,
     WebDragOperationsMask operationsAllowed,
     int modifiers)
 {
     m_operationsAllowed = operationsAllowed;
 
     return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragOver, modifiers);
 }
 
 void WebViewImpl::dragTargetDragLeave()
 {
-    ASSERT(m_currentDragData);
+    DCHECK(m_currentDragData);
 
     DragData dragData(
         m_currentDragData.get(),
         IntPoint(),
         IntPoint(),
         static_cast<DragOperation>(m_operationsAllowed));
 
     m_page->dragController().dragExited(&dragData);
 
     // FIXME: why is the drag scroll timer not stopped here?
 
     m_dragOperation = WebDragOperationNone;
     m_currentDragData = nullptr;
 }
 
 void WebViewImpl::dragTargetDrop(const WebPoint& clientPoint,
                                  const WebPoint& screenPoint,
                                  int modifiers)
 {
-    ASSERT(m_currentDragData);
+    DCHECK(m_currentDragData);
 
     WebAutofillClient* autofillClient = mainFrameImpl() ? mainFrameImpl()->autofillClient() : 0;
     UserGestureNotifier notifier(autofillClient, &m_userGestureObserved);
 
     // If this webview transitions from the "drop accepting" state to the "not
     // accepting" state, then our IPC message reply indicating that may be in-
     // flight, or else delayed by javascript processing in this webview.  If a
     // drop happens before our IPC reply has reached the browser process, then
     // the browser forwards the drop to this webview.  So only allow a drop to
     // proceed if our webview m_dragOperation state is not DragOperationNone.
@@ skipping 36 matching lines @@
     convertedWords.append(words.data(), words.size());
 
     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         if (frame->isLocalFrame())
             toLocalFrame(frame)->removeSpellingMarkersUnderWords(convertedWords);
     }
 }
 
 WebDragOperation WebViewImpl::dragTargetDragEnterOrOver(const WebPoint& clientPoint, const WebPoint& screenPoint, DragAction dragAction, int modifiers)
 {
-    ASSERT(m_currentDragData);
+    DCHECK(m_currentDragData);
 
     m_currentDragData->setModifiers(modifiers);
     DragData dragData(
         m_currentDragData.get(),
         clientPoint,
         screenPoint,
         static_cast<DragOperation>(m_operationsAllowed));
 
     DragSession dragSession;
     if (dragAction == DragEnter)
@@ skipping 391 matching lines @@
 }
 
 void WebViewImpl::startDragging(LocalFrame* frame,
                                 const WebDragData& dragData,
                                 WebDragOperationsMask mask,
                                 const WebImage& dragImage,
                                 const WebPoint& dragImageOffset)
 {
     if (!m_client)
         return;
-    ASSERT(!m_doingDragAndDrop);
+    DCHECK(!m_doingDragAndDrop);
     m_doingDragAndDrop = true;
     m_client->startDragging(WebLocalFrameImpl::fromFrame(frame), dragData, mask, dragImage, dragImageOffset);
 }
 
 void WebViewImpl::setIgnoreInputEvents(bool newValue)
 {
-    ASSERT(m_ignoreInputEvents != newValue);
+    DCHECK_NE(m_ignoreInputEvents, newValue);
     m_ignoreInputEvents = newValue;
 }
 
 void WebViewImpl::setBackgroundColorOverride(WebColor color)
 {
     m_backgroundColorOverride = color;
     updateLayerTreeBackgroundColor();
 }
 
 void WebViewImpl::setZoomFactorOverride(float zoomFactor)
@@ skipping 81 matching lines @@
     return m_tabsToLinks;
 }
 
 void WebViewImpl::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     if (!m_layerTreeView)
         return;
 
     // In SPv2, we attach layers via PaintArtifactCompositor, rather than
     // supplying a root GraphicsLayer from PaintLayerCompositor.
-    ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     VisualViewport& visualViewport = page()->frameHost().visualViewport();
     visualViewport.attachToLayerTree(layer);
     if (layer) {
         m_rootGraphicsLayer = visualViewport.rootGraphicsLayer();
         m_rootLayer = m_rootGraphicsLayer->platformLayer();
         updateRootLayerTransform();
         m_layerTreeView->setRootLayer(*m_rootLayer);
         // We register viewport layers here since there may not be a layer
         // tree view prior to this point.
@@ skipping 73 matching lines @@
 
     if (WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl())
         devTools->layerTreeViewChanged(m_layerTreeView);
 
     m_page->settings().setAcceleratedCompositingEnabled(m_layerTreeView);
     if (m_layerTreeView)
         m_page->layerTreeViewInitialized(*m_layerTreeView);
 
     // FIXME: only unittests, click to play, Android printing, and printing (for headers and footers)
     // make this assert necessary. We should make them not hit this code and then delete allowsBrokenNullLayerTreeView.
-    ASSERT(m_layerTreeView || !m_client || m_client->allowsBrokenNullLayerTreeView());
+    DCHECK(m_layerTreeView || !m_client || m_client->allowsBrokenNullLayerTreeView());
 
     if (Platform::current()->isThreadedAnimationEnabled() && m_layerTreeView) {
         m_linkHighlightsTimeline = adoptPtr(CompositorFactory::current().createAnimationTimeline());
         attachCompositorAnimationTimeline(m_linkHighlightsTimeline.get());
     }
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         attachPaintArtifactCompositor();
 }
 
@@ skipping 68 matching lines @@
 void WebViewImpl::updateLayerTreeBackgroundColor()
 {
     if (!m_layerTreeView)
         return;
 
     m_layerTreeView->setBackgroundColor(alphaChannel(m_backgroundColorOverride) ? m_backgroundColorOverride : backgroundColor());
 }
 
 void WebViewImpl::updateLayerTreeDeviceScaleFactor()
 {
-    ASSERT(page());
-    ASSERT(m_layerTreeView);
+    DCHECK(page());
+    DCHECK(m_layerTreeView);
 
     float deviceScaleFactor = m_compositorDeviceScaleFactorOverride ? m_compositorDeviceScaleFactorOverride : page()->deviceScaleFactor();
     m_layerTreeView->setDeviceScaleFactor(deviceScaleFactor);
 }
 
 void WebViewImpl::updateRootLayerTransform()
 {
     if (m_rootGraphicsLayer) {
         TransformationMatrix transform;
         transform.translate(m_rootLayerOffset.width, m_rootLayerOffset.height);
@@ skipping 36 matching lines @@
     return true;
 }
 
 WebViewScheduler* WebViewImpl::scheduler() const
 {
     return m_scheduler.get();
 }
 
 void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,
                                      bool isInitialState) {
-    ASSERT(visibilityState == WebPageVisibilityStateVisible || visibilityState == WebPageVisibilityStateHidden || visibilityState == WebPageVisibilityStatePrerender);
+    DCHECK(visibilityState == WebPageVisibilityStateVisible || visibilityState == WebPageVisibilityStateHidden || visibilityState == WebPageVisibilityStatePrerender);
 
     if (page())
         m_page->setVisibilityState(static_cast<PageVisibilityState>(static_cast<int>(visibilityState)), isInitialState);
 
     bool visible = visibilityState == WebPageVisibilityStateVisible;
     if (m_layerTreeView)
         m_layerTreeView->setVisible(visible);
     m_scheduler->setPageVisible(visible);
 }
 
@@ skipping 63 matching lines @@
     }
 }
 
 void WebViewImpl::attachPaintArtifactCompositor()
 {
     if (!m_layerTreeView)
         return;
 
     // Otherwise, PaintLayerCompositor is expected to supply a root
     // GraphicsLayer via setRootGraphicsLayer.
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     // TODO(jbroman): This should probably have hookups for overlays, visual
     // viewport, etc.
 
     WebLayer* rootLayer = m_paintArtifactCompositor.getWebLayer();
-    ASSERT(rootLayer);
+    DCHECK(rootLayer);
     m_layerTreeView->setRootLayer(*rootLayer);
 
     // TODO(jbroman): This is cargo-culted from setRootGraphicsLayer. Is it
     // necessary?
     m_layerTreeView->setVisible(page()->isPageVisible());
 }
 
 void WebViewImpl::detachPaintArtifactCompositor()
 {
     if (!m_layerTreeView)
         return;
 
     m_layerTreeView->setDeferCommits(true);
     m_layerTreeView->clearRootLayer();
 }
 
 float WebViewImpl::deviceScaleFactor() const
 {
     // TODO(oshima): Investigate if this should return the ScreenInfo's scale factor rather than
     // page's scale factor, which can be 1 in use-zoom-for-dsf mode.
     if (!page())
         return 1;
 
     return page()->deviceScaleFactor();
 }
 
 } // namespace blink