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

third_party/WebKit/Source/web/WebLocalFrameImpl.cpp

 /*
  * Copyright (C) 2009 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 268 matching lines @@
     ChromePrintContext(LocalFrame* frame)
         : PrintContext(frame)
         , m_printedPageWidth(0)
     {
     }
 
     ~ChromePrintContext() override {}
 
     virtual void begin(float width, float height)
     {
-        ASSERT(!m_printedPageWidth);
+        DCHECK(!m_printedPageWidth);
         m_printedPageWidth = width;
         PrintContext::begin(m_printedPageWidth, height);
     }
 
     virtual float getPageShrink(int pageNumber) const
     {
         IntRect pageRect = m_pageRects[pageNumber];
         return m_printedPageWidth / pageRect.width();
     }
 
@@ skipping 406 matching lines @@
 void WebLocalFrameImpl::dispatchUnloadEvent()
 {
     if (!frame())
         return;
     SubframeLoadingDisabler disabler(frame()->document());
     frame()->loader().dispatchUnloadEvent();
 }
 
 void WebLocalFrameImpl::executeScript(const WebScriptSource& source)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
     v8::HandleScope handleScope(toIsolate(frame()));
     frame()->script().executeScriptInMainWorld(ScriptSourceCode(source.code, source.url, position));
 }
 
 void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup)
 {
-    ASSERT(frame());
-    RELEASE_ASSERT(worldID > 0);
-    RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
+    DCHECK(frame());
+    CHECK_GT(worldID, 0);
+    CHECK_LT(worldID, EmbedderWorldIdLimit);
 
     WillBeHeapVector<ScriptSourceCode> sources = createSourcesVector(sourcesIn, numSources);
     v8::HandleScope handleScope(toIsolate(frame()));
     frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
 }
 
 void WebLocalFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin& securityOrigin)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     DOMWrapperWorld::setIsolatedWorldSecurityOrigin(worldID, securityOrigin.get());
 }
 
 void WebLocalFrameImpl::setIsolatedWorldContentSecurityPolicy(int worldID, const WebString& policy)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     DOMWrapperWorld::setIsolatedWorldContentSecurityPolicy(worldID, policy);
 }
 
 void WebLocalFrameImpl::setIsolatedWorldHumanReadableName(int worldID, const WebString& humanReadableName)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     DOMWrapperWorld::setIsolatedWorldHumanReadableName(worldID, humanReadableName);
 }
 
 void WebLocalFrameImpl::addMessageToConsole(const WebConsoleMessage& message)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     MessageLevel webCoreMessageLevel;
     switch (message.level) {
     case WebConsoleMessage::LevelDebug:
         webCoreMessageLevel = DebugMessageLevel;
         break;
     case WebConsoleMessage::LevelLog:
         webCoreMessageLevel = LogMessageLevel;
         break;
     case WebConsoleMessage::LevelWarning:
@@ skipping 14 matching lines @@
 {
     if (!frame())
         return;
     if (!frame()->settings()->scriptEnabled())
         return;
     V8GCController::collectGarbage(v8::Isolate::GetCurrent());
 }
 
 v8::Local<v8::Value> WebLocalFrameImpl::executeScriptAndReturnValue(const WebScriptSource& source)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
     return frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(source.code, source.url, position));
 }
 
 void WebLocalFrameImpl::requestExecuteScriptAndReturnValue(const WebScriptSource& source, bool userGesture, WebScriptExecutionCallback* callback)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     SuspendableScriptExecutor::createAndRun(frame(), 0, createSourcesVector(&source, 1), 0, userGesture, callback);
 }
 
 void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup, WebVector<v8::Local<v8::Value>>* results)
 {
-    ASSERT(frame());
-    RELEASE_ASSERT(worldID > 0);
-    RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
+    DCHECK(frame());
+    CHECK_GT(worldID, 0);
+    CHECK_LT(worldID, EmbedderWorldIdLimit);
 
     WillBeHeapVector<ScriptSourceCode> sources = createSourcesVector(sourcesIn, numSources);
 
     if (results) {
         Vector<v8::Local<v8::Value>> scriptResults;
         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, &scriptResults);
         WebVector<v8::Local<v8::Value>> v8Results(scriptResults.size());
         for (unsigned i = 0; i < scriptResults.size(); i++)
             v8Results[i] = v8::Local<v8::Value>::New(toIsolate(frame()), scriptResults[i]);
         results->swap(v8Results);
     } else {
         v8::HandleScope handleScope(toIsolate(frame()));
         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
     }
 }
 
 void WebLocalFrameImpl::requestExecuteScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup, bool userGesture, WebScriptExecutionCallback* callback)
 {
-    ASSERT(frame());
-    RELEASE_ASSERT(worldID > 0);
-    RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
+    DCHECK(frame());
+    CHECK_GT(worldID, 0);
+    CHECK_LT(worldID, EmbedderWorldIdLimit);
 
     SuspendableScriptExecutor::createAndRun(frame(), worldID, createSourcesVector(sourcesIn, numSources), extensionGroup, userGesture, callback);
 }
 
 // TODO(bashi): Consider returning MaybeLocal.
 v8::Local<v8::Value> WebLocalFrameImpl::callFunctionEvenIfScriptDisabled(v8::Local<v8::Function> function, v8::Local<v8::Value> receiver, int argc, v8::Local<v8::Value> argv[])
 {
-    ASSERT(frame());
+    DCHECK(frame());
     v8::Local<v8::Value> result;
     if (!frame()->script().callFunction(function, receiver, argc, static_cast<v8::Local<v8::Value>*>(argv)).ToLocal(&result))
         return v8::Local<v8::Value>();
     return result;
 }
 
 v8::Local<v8::Context> WebLocalFrameImpl::mainWorldScriptContext() const
 {
     ScriptState* scriptState = ScriptState::forMainWorld(frame());
-    ASSERT(scriptState);
+    DCHECK(scriptState);
     return scriptState->context();
 }
 
 bool WebFrame::scriptCanAccess(WebFrame* target)
 {
     return BindingSecurity::shouldAllowAccessToFrame(mainThreadIsolate(), callingDOMWindow(mainThreadIsolate()), target->toImplBase()->frame(), DoNotReportSecurityError);
 }
 
 void WebLocalFrameImpl::reload(bool ignoreCache)
 {
     // TODO(clamy): Remove this function once RenderFrame calls load for all
     // requests.
     reloadWithOverrideURL(KURL(), ignoreCache);
 }
 
 void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
 {
     // TODO(clamy): Remove this function once RenderFrame calls load for all
     // requests.
-    ASSERT(frame());
+    DCHECK(frame());
     WebFrameLoadType loadType = ignoreCache ?
         WebFrameLoadType::ReloadFromOrigin : WebFrameLoadType::Reload;
     WebURLRequest request = requestForReload(loadType, overrideUrl);
     if (request.isNull())
         return;
     load(request, loadType, WebHistoryItem(), WebHistoryDifferentDocumentLoad, false);
 }
 
 void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
 {
@@ skipping 20 matching lines @@
     WebURLRequest::CachePolicy cachePolicy)
 {
     // TODO(clamy): Remove this function once RenderFrame calls load for all
     // requests.
     WebURLRequest request = requestFromHistoryItem(item, cachePolicy);
     load(request, WebFrameLoadType::BackForward, item, loadType, false);
 }
 
 void WebLocalFrameImpl::loadHTMLString(const WebData& data, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     loadData(data, WebString::fromUTF8("text/html"), WebString::fromUTF8("UTF-8"), baseURL, unreachableURL, replace,
         WebFrameLoadType::Standard, WebHistoryItem(), WebHistoryDifferentDocumentLoad, false);
 }
 
 void WebLocalFrameImpl::stopLoading()
 {
     if (!frame())
         return;
     // FIXME: Figure out what we should really do here. It seems like a bug
     // that FrameLoader::stopLoading doesn't call stopAllLoaders.
     frame()->loader().stopAllLoaders();
 }
 
 WebDataSource* WebLocalFrameImpl::provisionalDataSource() const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     return DataSourceForDocLoader(frame()->loader().provisionalDocumentLoader());
 }
 
 WebDataSource* WebLocalFrameImpl::dataSource() const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     return DataSourceForDocLoader(frame()->loader().documentLoader());
 }
 
 void WebLocalFrameImpl::enableViewSourceMode(bool enable)
 {
     if (frame())
         frame()->setInViewSourceMode(enable);
 }
 
 bool WebLocalFrameImpl::isViewSourceModeEnabled() const
@@ skipping 82 matching lines @@
 {
     if (!frame())
         return kNotFound;
 
     IntPoint point = frame()->view()->viewportToContents(pointInViewport);
     HitTestResult result = frame()->eventHandler().hitTestResultAtPoint(point, HitTestRequest::ReadOnly | HitTestRequest::Active);
     const EphemeralRange range = frame()->rangeForPoint(result.roundedPointInInnerNodeFrame());
     if (range.isNull())
         return kNotFound;
     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
-    ASSERT(editable);
+    DCHECK(editable);
     return PlainTextRange::create(*editable, range).start();
 }
 
 bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebNode& node)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     if (name.length() <= 2)
         return false;
 
     // Since we don't have NSControl, we will convert the format of command
     // string and call the function on Editor directly.
     String command = name;
 
     // Make sure the first letter is upper case.
     command.replace(0, 1, command.substring(0, 1).upper());
 
     // Remove the trailing ':' if existing.
     if (command[command.length() - 1] == UChar(':'))
         command = command.substring(0, command.length() - 1);
 
     WebPluginContainerImpl* pluginContainer = pluginContainerFromNode(frame(), node);
     if (pluginContainer && pluginContainer->executeEditCommand(name))
         return true;
 
     return frame()->editor().executeCommand(command);
 }
 
 bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebString& value, const WebNode& node)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     WebPluginContainerImpl* pluginContainer = pluginContainerFromNode(frame(), node);
     if (pluginContainer && pluginContainer->executeEditCommand(name, value))
         return true;
 
     return frame()->editor().executeCommand(name, value);
 }
 
 bool WebLocalFrameImpl::isCommandEnabled(const WebString& name) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     return frame()->editor().createCommand(name).isEnabled();
 }
 
 void WebLocalFrameImpl::enableContinuousSpellChecking(bool enable)
 {
     if (enable == isContinuousSpellCheckingEnabled())
         return;
     frame()->spellChecker().toggleContinuousSpellChecking();
 }
 
@@ skipping 162 matching lines @@
 WebPlugin* WebLocalFrameImpl::focusedPluginIfInputMethodSupported()
 {
     WebPluginContainerImpl* container = WebLocalFrameImpl::pluginContainerFromNode(frame(), WebNode(frame()->document()->focusedElement()));
     if (container && container->supportsInputMethod())
         return container->plugin();
     return 0;
 }
 
 int WebLocalFrameImpl::printBegin(const WebPrintParams& printParams, const WebNode& constrainToNode)
 {
-    ASSERT(!frame()->document()->isFrameSet());
+    DCHECK(!frame()->document()->isFrameSet());
     WebPluginContainerImpl* pluginContainer = nullptr;
     if (constrainToNode.isNull()) {
         // If this is a plugin document, check if the plugin supports its own
         // printing. If it does, we will delegate all printing to that.
         pluginContainer = pluginContainerFromFrame(frame());
     } else {
         // We only support printing plugin nodes for now.
         pluginContainer = toWebPluginContainerImpl(constrainToNode.pluginContainer());
     }
 
     if (pluginContainer && pluginContainer->supportsPaginatedPrint())
         m_printContext = adoptPtrWillBeNoop(new ChromePluginPrintContext(frame(), pluginContainer, printParams));
     else
         m_printContext = adoptPtrWillBeNoop(new ChromePrintContext(frame()));
 
     FloatRect rect(0, 0, static_cast<float>(printParams.printContentArea.width), static_cast<float>(printParams.printContentArea.height));
     m_printContext->begin(rect.width(), rect.height());
     float pageHeight;
     // We ignore the overlays calculation for now since they are generated in the
     // browser. pageHeight is actually an output parameter.
     m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight);
 
     return static_cast<int>(m_printContext->pageCount());
 }
 
 float WebLocalFrameImpl::getPrintPageShrink(int page)
 {
-    ASSERT(m_printContext && page >= 0);
+    DCHECK(m_printContext && page >= 0);

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

Please split this into two.
    DCHECK(m_printContext);
    DCHECK_GE(page, 0);

     return m_printContext->getPageShrink(page);
 }
 
 float WebLocalFrameImpl::printPage(int page, WebCanvas* canvas)
 {
 #if ENABLE(PRINTING)
 
-    ASSERT(m_printContext && page >= 0 && frame() && frame()->document());
+    DCHECK(m_printContext && page >= 0 && frame() && frame()->document());

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

Please split this into four.
    DCHECK(m_printContext);
    DCHECK_GE(page, 0);
    DCHECK(frame());
    DCHECK(frame()->document());

 
     return m_printContext->spoolSinglePage(canvas, page);
 #else
     return 0;
 #endif
 }
 
 void WebLocalFrameImpl::printEnd()
 {
-    ASSERT(m_printContext);
+    DCHECK(m_printContext);
     m_printContext->end();
     m_printContext.clear();
 }
 
 bool WebLocalFrameImpl::isPrintScalingDisabledForPlugin(const WebNode& node)
 {
     WebPluginContainerImpl* pluginContainer =  node.isNull() ? pluginContainerFromFrame(frame()) : toWebPluginContainerImpl(node.pluginContainer());
 
     if (!pluginContainer || !pluginContainer->supportsPaginatedPrint())
         return false;
@@ skipping 23 matching lines @@
 
 void WebLocalFrameImpl::pageSizeAndMarginsInPixels(int pageIndex, WebSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
 {
     IntSize size = pageSize;
     frame()->document()->pageSizeAndMarginsInPixels(pageIndex, size, marginTop, marginRight, marginBottom, marginLeft);
     pageSize = size;
 }
 
 WebString WebLocalFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
 {
-    ASSERT(m_printContext);
+    DCHECK(m_printContext);
     return m_printContext->pageProperty(frame(), propertyName.utf8().data(), pageIndex);
 }
 
 void WebLocalFrameImpl::registerTestInterface(const WebString& name, WebTestInterfaceFactory* factory)
 {
     m_testInterfaces.set(name, adoptPtr(factory));
 }
 
 v8::Local<v8::Value> WebLocalFrameImpl::createTestInterface(const AtomicString& name)
 {
     if (WebTestInterfaceFactory* factory = m_testInterfaces.get(name)) {
         ScriptState* scriptState = ScriptState::forMainWorld(frame());
-        ASSERT(scriptState->contextIsValid());
+        DCHECK(scriptState->contextIsValid());
         v8::EscapableHandleScope handleScope(scriptState->isolate());
         ScriptState::Scope scope(scriptState);
         return handleScope.Escape(factory->createInstance(scriptState->context()));
     }
     return v8::Local<v8::Value>();
 }
 
 void WebLocalFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
 {
-    ASSERT(m_printContext);
+    DCHECK(m_printContext);
 
     m_printContext->spoolAllPagesWithBoundaries(canvas, FloatSize(pageSizeInPixels.width, pageSizeInPixels.height));
 }
 
 WebRect WebLocalFrameImpl::selectionBoundsRect() const
 {
     return hasSelection() ? WebRect(IntRect(frame()->selection().bounds())) : WebRect();
 }
 
 bool WebLocalFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
@@ skipping 93 matching lines @@
 }
 
 WebLocalFrameImpl::WebLocalFrameImpl(WebRemoteFrame* oldWebFrame, WebFrameClient* client)
     : WebLocalFrameImpl(oldWebFrame->inShadowTree() ? WebTreeScopeType::Shadow : WebTreeScopeType::Document, client)
 {
 }
 
 WebLocalFrameImpl::~WebLocalFrameImpl()
 {
     // The widget for the frame, if any, must have already been closed.
-    ASSERT(!m_frameWidget);
+    DCHECK(!m_frameWidget);
     frameCount--;
 
 #if !ENABLE(OILPAN)
     cancelPendingScopingEffort();
 #endif
 }
 
 #if ENABLE(OILPAN)
 DEFINE_TRACE(WebLocalFrameImpl)
 {
@@ skipping 61 matching lines @@
     frame()->tree().setPrecalculatedName(name, uniqueName);
     // We must call init() after m_frame is assigned because it is referenced
     // during init(). Note that this may dispatch JS events; the frame may be
     // detached after init() returns.
     frame()->init();
 }
 
 PassRefPtrWillBeRawPtr<LocalFrame> WebLocalFrameImpl::createChildFrame(const FrameLoadRequest& request,
     const AtomicString& name, HTMLFrameOwnerElement* ownerElement)
 {
-    ASSERT(m_client);
+    DCHECK(m_client);
     TRACE_EVENT0("blink", "WebLocalFrameImpl::createChildframe");
     WebTreeScopeType scope = frame()->document() == ownerElement->treeScope()
         ? WebTreeScopeType::Document
         : WebTreeScopeType::Shadow;
     WebFrameOwnerProperties ownerProperties(ownerElement->scrollingMode(), ownerElement->marginWidth(), ownerElement->marginHeight());
     // FIXME: Using subResourceAttributeName as fallback is not a perfect
     // solution. subResourceAttributeName returns just one attribute name. The
     // element might not have the attribute, and there might be other attributes
     // which can identify the element.
     AtomicString uniqueName = frame()->tree().calculateUniqueNameForNewChildFrame(
@@ skipping 28 matching lines @@
     // detached by script in the page.
     if (!webframeChild->parent())
         return nullptr;
     return webframeChild->frame();
 }
 
 void WebLocalFrameImpl::didChangeContentsSize(const IntSize& size)
 {
     // This is only possible on the main frame.
     if (m_textFinder && m_textFinder->totalMatchCount() > 0) {
-        ASSERT(!parent());
+        DCHECK(!parent());
         m_textFinder->increaseMarkerVersion();
     }
 }
 
 void WebLocalFrameImpl::createFrameView()
 {
     TRACE_EVENT0("blink", "WebLocalFrameImpl::createFrameView");
 
-    ASSERT(frame()); // If frame() doesn't exist, we probably didn't init properly.
+    DCHECK(frame()); // If frame() doesn't exist, we probably didn't init properly.
 
     WebViewImpl* webView = viewImpl();
 
     bool isMainFrame = !parent();
     IntSize initialSize = (isMainFrame || !frameWidget()) ? webView->mainFrameSize() : (IntSize)frameWidget()->size();
     bool isTransparent = !isMainFrame && parent()->isWebRemoteFrame() ? true : webView->isTransparent();
 
     frame()->createView(initialSize, webView->baseBackgroundColor(), isTransparent);
     if (webView->shouldAutoResize() && frame()->isLocalRoot())
         frame()->view()->enableAutoSizeMode(webView->minAutoSize(), webView->maxAutoSize());
@@ skipping 197 matching lines @@
     m_autofillClient = autofillClient;
 }
 
 WebAutofillClient* WebLocalFrameImpl::autofillClient()
 {
     return m_autofillClient;
 }
 
 void WebLocalFrameImpl::setDevToolsAgentClient(WebDevToolsAgentClient* devToolsClient)
 {
-    ASSERT(devToolsClient);
+    DCHECK(devToolsClient);
     m_devToolsAgent = WebDevToolsAgentImpl::create(this, devToolsClient);
 }
 
 WebDevToolsAgent* WebLocalFrameImpl::devToolsAgent()
 {
     return m_devToolsAgent.get();
 }
 
 void WebLocalFrameImpl::setFrameOwnerProperties(const WebFrameOwnerProperties& frameOwnerProperties)
 {
     // At the moment, this is only used to replicate frame owner properties
     // for frames with a remote owner.
     FrameOwner* owner = frame()->owner();
-    ASSERT(owner);
+    DCHECK(owner);
     toRemoteFrameOwner(owner)->setScrollingMode(frameOwnerProperties.scrollingMode);
     toRemoteFrameOwner(owner)->setMarginWidth(frameOwnerProperties.marginWidth);
     toRemoteFrameOwner(owner)->setMarginHeight(frameOwnerProperties.marginHeight);
 }
 
 WebLocalFrameImpl* WebLocalFrameImpl::localRoot()
 {
     // This can't use the LocalFrame::localFrameRoot, since it may be called
     // when the WebLocalFrame exists but the core LocalFrame does not.
     // TODO(alexmos, dcheng): Clean this up to only calculate this in one place.
@@ skipping 14 matching lines @@
 WebLocalFrame* WebLocalFrameImpl::traverseNextLocal(bool wrap) const
 {
     WebFrame* nextLocalFrame = this->traverseNext(wrap);
     while (nextLocalFrame && !nextLocalFrame->isWebLocalFrame())
         nextLocalFrame = nextLocalFrame->traverseNext(wrap);
     return nextLocalFrame ? nextLocalFrame->toWebLocalFrame() : nullptr;
 }
 
 void WebLocalFrameImpl::sendPings(const WebNode& contextNode, const WebURL& destinationURL)
 {
-    ASSERT(frame());
+    DCHECK(frame());
     Element* anchor = contextNode.constUnwrap<Node>()->enclosingLinkEventParentOrSelf();
     if (isHTMLAnchorElement(anchor))
         toHTMLAnchorElement(anchor)->sendPings(destinationURL);
 }
 
 WebURLRequest WebLocalFrameImpl::requestFromHistoryItem(const WebHistoryItem& item,
     WebURLRequest::CachePolicy cachePolicy) const
 {
     RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
     ResourceRequest request = FrameLoader::resourceRequestFromHistoryItem(
         historyItem.get(), static_cast<ResourceRequestCachePolicy>(cachePolicy));
     return WrappedResourceRequest(request);
 }
 
 WebURLRequest WebLocalFrameImpl::requestForReload(WebFrameLoadType loadType,
     const WebURL& overrideUrl) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     ResourceRequest request = frame()->loader().resourceRequestForReload(
         static_cast<FrameLoadType>(loadType), overrideUrl);
     return WrappedResourceRequest(request);
 }
 
 void WebLocalFrameImpl::load(const WebURLRequest& request, WebFrameLoadType webFrameLoadType,
     const WebHistoryItem& item, WebHistoryLoadType webHistoryLoadType, bool isClientRedirect)
 {
-    ASSERT(frame());
-    ASSERT(!request.isNull());
+    DCHECK(frame());
+    DCHECK(!request.isNull());
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
     if (resourceRequest.url().protocolIs("javascript")
         && webFrameLoadType == WebFrameLoadType::Standard) {
         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
     FrameLoadRequest frameRequest = FrameLoadRequest(nullptr, resourceRequest);
     if (isClientRedirect)
         frameRequest.setClientRedirect(ClientRedirect);
     RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
     frame()->loader().load(
         frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType,
     const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace,
     WebFrameLoadType webFrameLoadType, const WebHistoryItem& item,
     WebHistoryLoadType webHistoryLoadType, bool isClientRedirect)
 {
-    ASSERT(frame());
+    DCHECK(frame());
 
     // If we are loading substitute data to replace an existing load, then
     // inherit all of the properties of that original request. This way,
     // reload will re-attempt the original request. It is essential that
     // we only do this when there is an unreachableURL since a non-empty
     // unreachableURL informs FrameLoader::reload to load unreachableURL
     // instead of the currently loaded URL.
     ResourceRequest request;
     if (replace && !unreachableURL.isEmpty() && frame()->loader().provisionalDocumentLoader())
         request = frame()->loader().provisionalDocumentLoader()->originalRequest();
     request.setURL(baseURL);
     request.setCheckForBrowserSideNavigation(false);
 
     FrameLoadRequest frameRequest(0, request, SubstituteData(data, mimeType, textEncoding, unreachableURL));
-    ASSERT(frameRequest.substituteData().isValid());
+    DCHECK(frameRequest.substituteData().isValid());
     frameRequest.setReplacesCurrentItem(replace);
     if (isClientRedirect)
         frameRequest.setClientRedirect(ClientRedirect);
 
     RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
     frame()->loader().load(
         frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
@@ skipping 11 matching lines @@
     return frame()->document()->fetcher()->requestCount();
 }
 
 bool WebLocalFrameImpl::isNavigationScheduledWithin(double intervalInSeconds) const
 {
     return frame() && frame()->navigationScheduler().isNavigationScheduledWithin(intervalInSeconds);
 }
 
 void WebLocalFrameImpl::setCommittedFirstRealLoad()
 {
-    ASSERT(frame());
+    DCHECK(frame());
     ensureFrameLoaderHasCommitted(frame()->loader());
 }
 
 void WebLocalFrameImpl::sendOrientationChangeEvent()
 {
     if (!frame())
         return;
 
     // Screen Orientation API
     if (ScreenOrientationController::from(*frame()))
         ScreenOrientationController::from(*frame())->notifyOrientationChanged();
 
     // Legacy window.orientation API
     if (RuntimeEnabledFeatures::orientationEventEnabled() && frame()->domWindow())
         frame()->localDOMWindow()->sendOrientationChangeEvent();
 }
 
 void WebLocalFrameImpl::willShowInstallBannerPrompt(int requestId, const WebVector<WebString>& platforms, WebAppBannerPromptReply* reply)
 {
     if (!RuntimeEnabledFeatures::appBannerEnabled() || !frame())
         return;
 
     AppBannerController::willShowInstallBannerPrompt(requestId, client()->appBannerClient(), frame(), platforms, reply);
 }
 
 void WebLocalFrameImpl::requestRunTask(WebSuspendableTask* task) const
 {
-    ASSERT(frame());
-    ASSERT(frame()->document());
+    DCHECK(frame());
+    DCHECK(frame()->document());
     frame()->document()->postSuspendableTask(WebSuspendableTaskWrapper::create(adoptPtr(task)));
 }
 
 void WebLocalFrameImpl::didCallAddSearchProvider()
 {
     UseCounter::count(frame(), UseCounter::ExternalAddSearchProvider);
 }
 
 void WebLocalFrameImpl::didCallIsSearchProviderInstalled()
 {
@@ skipping 21 matching lines @@
 
 void WebLocalFrameImpl::cancelPendingScopingEffort()
 {
     if (m_textFinder)
         m_textFinder->cancelPendingScopingEffort();
 }
 
 void WebLocalFrameImpl::increaseMatchCount(int count, int identifier)
 {
     // This function should only be called on the mainframe.
-    ASSERT(!parent());
+    DCHECK(!parent());
     ensureTextFinder().increaseMatchCount(identifier, count);
 }
 
 void WebLocalFrameImpl::resetMatchCount()
 {
     ensureTextFinder().resetMatchCount();
 }
 
 void WebLocalFrameImpl::dispatchMessageEventWithOriginCheck(const WebSecurityOrigin& intendedTargetOrigin, const WebDOMEvent& event)
 {
-    ASSERT(!event.isNull());
+    DCHECK(!event.isNull());
     frame()->localDOMWindow()->dispatchMessageEventWithOriginCheck(intendedTargetOrigin.get(), event, nullptr);
 }
 
 int WebLocalFrameImpl::findMatchMarkersVersion() const
 {
-    ASSERT(!parent());
+    DCHECK(!parent());
 
     if (m_textFinder)
         return m_textFinder->findMatchMarkersVersion();
     return 0;
 }
 
 int WebLocalFrameImpl::selectNearestFindMatch(const WebFloatPoint& point, WebRect* selectionRect)
 {
-    ASSERT(!parent());
+    DCHECK(!parent());
     return ensureTextFinder().selectNearestFindMatch(point, selectionRect);
 }
 
 WebFloatRect WebLocalFrameImpl::activeFindMatchRect()
 {
-    ASSERT(!parent());
+    DCHECK(!parent());
 
     if (m_textFinder)
         return m_textFinder->activeFindMatchRect();
     return WebFloatRect();
 }
 
 void WebLocalFrameImpl::findMatchRects(WebVector<WebFloatRect>& outputRects)
 {
-    ASSERT(!parent());
+    DCHECK(!parent());
     ensureTextFinder().findMatchRects(outputRects);
 }
 
 void WebLocalFrameImpl::setTickmarks(const WebVector<WebRect>& tickmarks)
 {
     if (frameView()) {
         Vector<IntRect> tickmarksConverted(tickmarks.size());
         for (size_t i = 0; i < tickmarks.size(); ++i)
             tickmarksConverted[i] = tickmarks[i];
         frameView()->setTickmarks(tickmarksConverted);
@@ skipping 15 matching lines @@
         // There is a possibility that the frame being detached was the only
         // pending one. We need to make sure final replies can be sent.
         m_textFinder->flushCurrentScoping();
 
         m_textFinder->cancelPendingScopingEffort();
     }
 }
 
 WebLocalFrameImpl* WebLocalFrameImpl::activeMatchFrame() const
 {
-    ASSERT(!parent());
+    DCHECK(!parent());
 
     if (m_textFinder)
         return m_textFinder->activeMatchFrame();
     return 0;
 }
 
 Range* WebLocalFrameImpl::activeMatch() const
 {
     if (m_textFinder)
         return m_textFinder->activeMatch();
@@ skipping 24 matching lines @@
         return WebSandboxFlags::None;
     return static_cast<WebSandboxFlags>(frame()->loader().effectiveSandboxFlags());
 }
 
 void WebLocalFrameImpl::forceSandboxFlags(WebSandboxFlags flags)
 {
     frame()->loader().forceSandboxFlags(static_cast<SandboxFlags>(flags));
 }
 
 } // namespace blink