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

third_party/WebKit/Source/web/ChromeClientImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  *
  * 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.
@@ skipping 325 matching lines @@
 
 } // namespace
 
 Page* ChromeClientImpl::createWindow(LocalFrame* frame, const FrameLoadRequest& r, const WindowFeatures& features,
     NavigationPolicy navigationPolicy, ShouldSetOpener shouldSetOpener)
 {
     if (!m_webView->client())
         return nullptr;
 
     WebNavigationPolicy policy = effectiveNavigationPolicy(navigationPolicy, features);
-    ASSERT(frame->document());
+    DCHECK(frame->document());
     Fullscreen::fullyExitFullscreen(*frame->document());
 
     WebViewImpl* newView = toWebViewImpl(
         m_webView->client()->createView(WebLocalFrameImpl::fromFrame(frame), WrappedResourceRequest(r.resourceRequest()), features, r.frameName(), policy, shouldSetOpener == NeverSetOpener));
     if (!newView)
         return nullptr;
     return newView->page();
 }
 
 void ChromeClientImpl::didOverscroll(const FloatSize& unusedDelta, const FloatSize& accumulatedRootOverScroll, const FloatPoint& position, const FloatSize& velocity)
@@ skipping 163 matching lines @@
 }
 
 void ChromeClientImpl::invalidateRect(const IntRect& updateRect)
 {
     if (!updateRect.isEmpty())
         m_webView->invalidateRect(updateRect);
 }
 
 void ChromeClientImpl::scheduleAnimation(Widget* widget)
 {
-    ASSERT(widget->isFrameView());
+    DCHECK(widget->isFrameView());
     FrameView* view = toFrameView(widget);
     LocalFrame* frame = view->frame().localFrameRoot();
 
     // If the frame is still being created, it might not yet have a WebWidget.
     // FIXME: Is this the right thing to do? Is there a way to avoid having
     // a local frame root that doesn't have a WebWidget? During initialization
     // there is no content to draw so this call serves no purpose.
     if (WebLocalFrameImpl::fromFrame(frame) && WebLocalFrameImpl::fromFrame(frame)->frameWidget()) {
         WebLocalFrameImpl::fromFrame(frame)->frameWidget()->scheduleAnimation();
     } else {
         // TODO(lfg): We need to keep this for now because we still have some
         // WebViews who don't have a WebViewFrameWidget. This should be
         // removed once the WebViewFrameWidget refactor is complete.
         m_webView->scheduleAnimation();
     }
 }
 
 IntRect ChromeClientImpl::viewportToScreen(const IntRect& rectInViewport, const Widget* widget) const
 {
     WebRect screenRect(rectInViewport);
 
-    ASSERT(widget->isFrameView());
+    DCHECK(widget->isFrameView());
     const FrameView* view = toFrameView(widget);
     LocalFrame* frame = view->frame().localFrameRoot();
     WebWidgetClient* client = nullptr;
 
     // TODO(kenrb): Consolidate this to a single case when WebViewFrameWidget refactor is complete.
     if (WebLocalFrameImpl::fromFrame(frame) && WebLocalFrameImpl::fromFrame(frame)->frameWidget() && WebLocalFrameImpl::fromFrame(frame)->frameWidget()->forSubframe())
         client = toWebFrameWidgetImpl(WebLocalFrameImpl::fromFrame(frame)->frameWidget())->client();
     else
         client = m_webView->client();
 
@@ skipping 142 matching lines @@
 }
 
 void ChromeClientImpl::enumerateChosenDirectory(FileChooser* fileChooser)
 {
     WebViewClient* client = m_webView->client();
     if (!client)
         return;
 
     WebFileChooserCompletionImpl* chooserCompletion = new WebFileChooserCompletionImpl(fileChooser);
 
-    ASSERT(fileChooser);
-    ASSERT(fileChooser->settings().selectedFiles.size());
+    DCHECK(fileChooser);
+    DCHECK(fileChooser->settings().selectedFiles.size());
 
     // If the enumeration can't happen, call the callback with an empty list.
     if (!client->enumerateChosenDirectory(fileChooser->settings().selectedFiles[0], chooserCompletion))
         chooserCompletion->didChooseFile(WebVector<WebString>());
 }
 
 Cursor ChromeClientImpl::lastSetCursorForTesting() const
 {
     return m_lastSetMouseCursorForTesting;
 }
@@ skipping 17 matching lines @@
 #endif
     if (!m_webView->client())
         return;
     // TODO(kenrb, dcheng): For top-level frames we still use the WebView as
     // a WebWidget. This special case will be removed when top-level frames
     // get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->client()->didChangeCursor(cursor);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
-        ASSERT(webFrame);
-        ASSERT(webFrame->frameWidget());
+        DCHECK(webFrame);
+        DCHECK(webFrame->frameWidget());
         if (toWebFrameWidgetImpl(webFrame->frameWidget())->client())
             toWebFrameWidgetImpl(webFrame->frameWidget())->client()->didChangeCursor(cursor);
     }
 }
 
 void ChromeClientImpl::setCursorForPlugin(const WebCursorInfo& cursor, LocalFrame* localRoot)
 {
     setCursor(cursor, localRoot);
 }
 
@@ skipping 25 matching lines @@
     if (localRoot->isMainFrame()) {
         m_webView->setRootGraphicsLayer(rootLayer);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
         // FIXME: The following conditional is only needed for staging until the
         // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->setRootGraphicsLayer(rootLayer);
             return;
         }
-        ASSERT(webFrame);
-        ASSERT(webFrame->frameWidget());
+        DCHECK(webFrame);
+        DCHECK(webFrame->frameWidget());
         toWebFrameWidgetImpl(webFrame->frameWidget())->setRootGraphicsLayer(rootLayer);
     }
 }
 
 void ChromeClientImpl::didPaint(const PaintArtifact& paintArtifact)
 {
     // TODO(jbroman): This doesn't handle OOPIF correctly. We probably need a
     // branch for WebFrameWidget, like attachRootGraphicsLayer.
     m_webView->getPaintArtifactCompositor().update(paintArtifact);
 }
 
 void ChromeClientImpl::attachCompositorAnimationTimeline(CompositorAnimationTimeline* compositorTimeline, LocalFrame* localRoot)
 {
     // FIXME: For top-level frames we still use the WebView as a WebWidget. This
     // special case will be removed when top-level frames get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->attachCompositorAnimationTimeline(compositorTimeline);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
         // FIXME: The following conditional is only needed for staging until the
         // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->attachCompositorAnimationTimeline(compositorTimeline);
             return;
         }
-        ASSERT(webFrame);
-        ASSERT(webFrame->frameWidget());
+        DCHECK(webFrame);
+        DCHECK(webFrame->frameWidget());
         toWebFrameWidgetImpl(webFrame->frameWidget())->attachCompositorAnimationTimeline(compositorTimeline);
     }
 }
 
 void ChromeClientImpl::detachCompositorAnimationTimeline(CompositorAnimationTimeline* compositorTimeline, LocalFrame* localRoot)
 {
     // FIXME: For top-level frames we still use the WebView as a WebWidget. This
     // special case will be removed when top-level frames get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->detachCompositorAnimationTimeline(compositorTimeline);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
         // FIXME: The following conditional is only needed for staging until the
         // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->detachCompositorAnimationTimeline(compositorTimeline);
             return;
         }
-        ASSERT(webFrame);
-        ASSERT(webFrame->frameWidget());
+        DCHECK(webFrame);
+        DCHECK(webFrame->frameWidget());
         toWebFrameWidgetImpl(webFrame->frameWidget())->detachCompositorAnimationTimeline(compositorTimeline);
     }
 }
 
 void ChromeClientImpl::enterFullScreenForElement(Element* element)
 {
     m_webView->enterFullScreenForElement(element);
 }
 
 void ChromeClientImpl::exitFullScreenForElement(Element* element)
@@ skipping 15 matching lines @@
 {
     return m_webView->hasOpenedPopup();
 }
 
 RawPtr<PopupMenu> ChromeClientImpl::openPopupMenu(LocalFrame& frame, HTMLSelectElement& select)
 {
     notifyPopupOpeningObservers();
     if (WebViewImpl::useExternalPopupMenus())
         return new ExternalPopupMenu(frame, select, *m_webView);
 
-    ASSERT(RuntimeEnabledFeatures::pagePopupEnabled());
+    DCHECK(RuntimeEnabledFeatures::pagePopupEnabled());
     return PopupMenuImpl::create(this, select);
 }
 
 PagePopup* ChromeClientImpl::openPagePopup(PagePopupClient* client)
 {
     return m_webView->openPagePopup(client);
 }
 
 void ChromeClientImpl::closePagePopup(PagePopup* popup)
 {
@@ skipping 158 matching lines @@
         m_webView->page()->frameHost().visualViewport().registerLayersWithTreeView(m_webView->layerTreeView());
 }
 
 void ChromeClientImpl::didUpdateTopControls() const
 {
     m_webView->didUpdateTopControls();
 }
 
 void ChromeClientImpl::registerPopupOpeningObserver(PopupOpeningObserver* observer)
 {
-    ASSERT(observer);
+    DCHECK(observer);
     m_popupOpeningObservers.append(observer);
 }
 
 void ChromeClientImpl::unregisterPopupOpeningObserver(PopupOpeningObserver* observer)
 {
     size_t index = m_popupOpeningObservers.find(observer);
-    ASSERT(index != kNotFound);
+    DCHECK_NE(index, kNotFound);
     m_popupOpeningObservers.remove(index);
 }
 
 void ChromeClientImpl::notifyPopupOpeningObservers() const
 {
     const Vector<PopupOpeningObserver*> observers(m_popupOpeningObservers);
     for (const auto& observer : observers)
         observer->willOpenPopup();
 }
 
 FloatSize ChromeClientImpl::elasticOverscroll() const
 {
     return m_webView->elasticOverscroll();
 }
 
 void ChromeClientImpl::didObserveNonGetFetchFromScript() const
 {
     if (m_webView->pageImportanceSignals())
         m_webView->pageImportanceSignals()->setIssuedNonGetFetchFromScript();
 }
 
 PassOwnPtr<WebFrameScheduler> ChromeClientImpl::createFrameScheduler(BlameContext* blameContext)
 {
     return m_webView->scheduler()->createFrameScheduler(blameContext).release();
 }
 
 } // namespace blink