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

third_party/WebKit/Source/web/WebRemoteFrameImpl.cpp

 // Copyright 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/WebRemoteFrameImpl.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 573 matching lines @@
     WebLocalFrameImpl* child = WebLocalFrameImpl::create(scope, client, opener);
     insertAfter(child, previousSibling);
     RawPtr<RemoteFrameOwner> owner = RemoteFrameOwner::create(static_cast<SandboxFlags>(sandboxFlags), frameOwnerProperties);
     // FIXME: currently this calls LocalFrame::init() on the created LocalFrame, which may
     // result in the browser observing two navigations to about:blank (one from the initial
     // frame creation, and one from swapping it into the remote process). FrameLoader might
     // need a special initialization function for this case to avoid that duplicate navigation.
     child->initializeCoreFrame(frame()->host(), owner.get(), name, uniqueName);
     // Partially related with the above FIXME--the init() call may trigger JS dispatch. However,
     // if the parent is remote, it should never be detached synchronously...
-    ASSERT(child->frame());
+    DCHECK(child->frame());
     return child;
 }
 
 void WebRemoteFrameImpl::initializeCoreFrame(FrameHost* host, FrameOwner* owner, const AtomicString& name, const AtomicString& uniqueName)
 {
     setCoreFrame(RemoteFrame::create(m_frameClient.get(), host, owner));
     frame()->createView();
     m_frame->tree().setPrecalculatedName(name, uniqueName);
 }
 
@@ skipping 13 matching lines @@
 
 WebRemoteFrameImpl* WebRemoteFrameImpl::fromFrame(RemoteFrame& frame)
 {
     if (!frame.client())
         return nullptr;
     return static_cast<RemoteFrameClientImpl*>(frame.client())->webFrame();
 }
 
 void WebRemoteFrameImpl::initializeFromFrame(WebLocalFrame* source) const
 {
-    ASSERT(source);
+    DCHECK(source);
     WebLocalFrameImpl* localFrameImpl = toWebLocalFrameImpl(source);
 
     client()->initializeChildFrame(
         localFrameImpl->frame()->view()->frameRect(),
         localFrameImpl->frame()->page()->deviceScaleFactor());
 }
 
 void WebRemoteFrameImpl::setReplicatedOrigin(const WebSecurityOrigin& origin) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     frame()->securityContext()->setReplicatedOrigin(origin);
 
     // If the origin of a remote frame changed, the accessibility object for the owner
     // element now points to a different child.
     //
     // TODO(dmazzoni, dcheng): there's probably a better way to solve this.
     // Run SitePerProcessAccessibilityBrowserTest.TwoCrossSiteNavigations to
     // ensure an alternate fix works.  http://crbug.com/566222
     FrameOwner* owner = frame()->owner();
     if (owner && owner->isLocal()) {
         HTMLElement* ownerElement = toHTMLFrameOwnerElement(owner);
         AXObjectCache* cache = ownerElement->document().existingAXObjectCache();
         if (cache)
             cache->childrenChanged(ownerElement);
     }
 }
 
 void WebRemoteFrameImpl::setReplicatedSandboxFlags(WebSandboxFlags flags) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     frame()->securityContext()->enforceSandboxFlags(static_cast<SandboxFlags>(flags));
 }
 
 void WebRemoteFrameImpl::setReplicatedName(const WebString& name, const WebString& uniqueName) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     frame()->tree().setPrecalculatedName(name, uniqueName);
 }
 
 void WebRemoteFrameImpl::setReplicatedShouldEnforceStrictMixedContentChecking(bool shouldEnforce) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     frame()->securityContext()->setShouldEnforceStrictMixedContentChecking(shouldEnforce);
 }
 
 void WebRemoteFrameImpl::setReplicatedPotentiallyTrustworthyUniqueOrigin(bool isUniqueOriginPotentiallyTrustworthy) const
 {
-    ASSERT(frame());
+    DCHECK(frame());
     // If |isUniqueOriginPotentiallyTrustworthy| is true, then the origin must be unique.
-    ASSERT(!isUniqueOriginPotentiallyTrustworthy || frame()->securityContext()->getSecurityOrigin()->isUnique());
+    DCHECK(!isUniqueOriginPotentiallyTrustworthy || frame()->securityContext()->getSecurityOrigin()->isUnique());
     frame()->securityContext()->getSecurityOrigin()->setUniqueOriginIsPotentiallyTrustworthy(isUniqueOriginPotentiallyTrustworthy);
 }
 
 void WebRemoteFrameImpl::DispatchLoadEventForFrameOwner() const
 {
-    ASSERT(frame()->owner()->isLocal());
+    DCHECK(frame()->owner()->isLocal());
     frame()->owner()->dispatchLoad();
 }
 
 void WebRemoteFrameImpl::didStartLoading()
 {
     frame()->setIsLoading(true);
 }
 
 void WebRemoteFrameImpl::didStopLoading()
 {
@@ skipping 17 matching lines @@
     : WebRemoteFrame(scope)
     , m_frameClient(RemoteFrameClientImpl::create(this))
     , m_client(client)
 #if ENABLE(OILPAN)
     , m_selfKeepAlive(this)
 #endif
 {
 }
 
 } // namespace blink