ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 324 matching lines @@
 static Widget* widgetForElement(const Element& focusedElement)
 {
     LayoutObject* layoutObject = focusedElement.layoutObject();
     if (!layoutObject || !layoutObject->isLayoutPart())
         return 0;
     return toLayoutPart(layoutObject)->widget();
 }
 
 static bool acceptsEditingFocus(const Element& element)
 {
-    ASSERT(element.hasEditableStyle());
+    DCHECK(element.hasEditableStyle());
 
     return element.document().frame() && element.rootEditableElement();
 }
 
 static bool isOriginPotentiallyTrustworthy(SecurityOrigin* origin, String* errorMessage)
 {
     if (origin->isPotentiallyTrustworthy())
         return true;
     if (errorMessage)
         *errorMessage = origin->isPotentiallyTrustworthyErrorMessage();
@@ skipping 100 matching lines @@
     , m_timeline(AnimationTimeline::create(this))
     , m_compositorPendingAnimations(new CompositorPendingAnimations())
     , m_templateDocumentHost(nullptr)
     , m_didAssociateFormControlsTimer(this, &Document::didAssociateFormControlsTimerFired)
     , m_timers(timerTaskRunner()->adoptClone())
     , m_hasViewportUnits(false)
     , m_parserSyncPolicy(AllowAsynchronousParsing)
     , m_nodeCount(0)
 {
     if (m_frame) {
-        ASSERT(m_frame->page());
+        DCHECK(m_frame->page());
         provideContextFeaturesToDocumentFrom(*this, *m_frame->page());
 
         m_fetcher = m_frame->loader().documentLoader()->fetcher();
         FrameFetchContext::provideDocumentToContext(m_fetcher->context(), this);
     } else if (m_importsController) {
         m_fetcher = FrameFetchContext::createContextAndFetcher(nullptr, this);
     } else {
         m_fetcher = ResourceFetcher::create(nullptr);
     }
 
@@ skipping 19 matching lines @@
 
     // Since CSSFontSelector requires Document::m_fetcher and StyleEngine owns
     // CSSFontSelector, need to initialize m_styleEngine after initializing
     // m_fetcher.
     m_styleEngine = StyleEngine::create(*this);
 
     // The parent's parser should be suspended together with all the other objects,
     // else this new Document would have a new ExecutionContext which suspended state
     // would not match the one from the parent, and could start loading resources
     // ignoring the defersLoading flag.
-    ASSERT(!parentDocument() || !parentDocument()->activeDOMObjectsAreSuspended());
+    DCHECK(!parentDocument() || !parentDocument()->activeDOMObjectsAreSuspended());
 
     liveDocumentSet().add(this);
 }
 
 Document::~Document()
 {
-    ASSERT(!layoutView());
-    ASSERT(!parentTreeScope());
+    DCHECK(!layoutView());
+    DCHECK(!parentTreeScope());
     // If a top document with a cache, verify that it was comprehensively
     // cleared during detach.
-    ASSERT(!m_axObjectCache);
+    DCHECK(!m_axObjectCache);
 #if !ENABLE(OILPAN)
-    ASSERT(m_ranges.isEmpty());
-    ASSERT(!hasGuardRefCount());
-    ASSERT(!m_importsController);
+    DCHECK(m_ranges.isEmpty());
+    DCHECK(!hasGuardRefCount());
+    DCHECK(!m_importsController);
     // With Oilpan, either the document outlives the visibility observers
     // or the visibility observers and the document die in the same GC round.
     // When they die in the same GC round, the list of visibility observers
     // will not be empty on Document destruction.
-    ASSERT(m_visibilityObservers.isEmpty());
+    DCHECK(m_visibilityObservers.isEmpty());
 
     if (m_templateDocument)
         m_templateDocument->m_templateDocumentHost = nullptr; // balanced in ensureTemplateDocument().
 
     m_scriptRunner.clear();
 
     // FIXME: Oilpan: Not removing event listeners here also means that we do
     // not notify the inspector instrumentation that the event listeners are
     // gone. The Document and all the nodes in the document are gone, so maybe
     // that is OK?
     removeAllEventListenersRecursively();
 
     // Currently we believe that Document can never outlive the parser.
     // Although the Document may be replaced synchronously, DocumentParsers
     // generally keep at least one reference to an Element which would in turn
     // has a reference to the Document.  If you hit this ASSERT, then that
     // assumption is wrong.  DocumentParser::detach() should ensure that even
     // if the DocumentParser outlives the Document it won't cause badness.
-    ASSERT(!m_parser || m_parser->refCount() == 1);
+    DCHECK(!m_parser || m_parser->refCount() == 1);
     detachParser();
 
     if (m_styleSheetList)
         m_styleSheetList->detachFromDocument();
 
     m_timeline->detachFromDocument();
 
     // We need to destroy CSSFontSelector before destroying m_fetcher.
     m_styleEngine->detachFromDocument();
 
     if (m_elemSheet)
         m_elemSheet->clearOwnerNode();
 
     // We must call clearRareData() here since a Document class inherits TreeScope
     // as well as Node. See a comment on TreeScope.h for the reason.
     if (hasRareData())
         clearRareData();
 
-    ASSERT(m_listsInvalidatedAtDocument.isEmpty());
+    DCHECK(m_listsInvalidatedAtDocument.isEmpty());
 
     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListCounts); ++i)
-        ASSERT(!m_nodeListCounts[i]);
+        DCHECK(!m_nodeListCounts[i]);
 
     liveDocumentSet().remove(this);
 #endif
 
     InstanceCounters::decrementCounter(InstanceCounters::DocumentCounter);
 }
 
 #if !ENABLE(OILPAN)
 void Document::dispose()
 {
@@ skipping 78 matching lines @@
 }
 
 String Document::compatMode() const
 {
     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
 }
 
 void Document::setDoctype(RawPtr<DocumentType> docType)
 {
     // This should never be called more than once.
-    ASSERT(!m_docType || !docType);
+    DCHECK(!m_docType || !docType);
     m_docType = docType;
     if (m_docType) {
         this->adoptIfNeeded(*m_docType);
         if (m_docType->publicId().startsWith("-//wapforum//dtd xhtml mobile 1.", TextCaseInsensitive))
             m_isMobileDocument = true;
     }
     // Doctype affects the interpretation of the stylesheets.
     styleEngine().clearResolver();
 }
 
@@ skipping 122 matching lines @@
 
 CustomElementMicrotaskRunQueue* Document::customElementMicrotaskRunQueue()
 {
     if (!m_customElementMicrotaskRunQueue)
         m_customElementMicrotaskRunQueue = CustomElementMicrotaskRunQueue::create();
     return m_customElementMicrotaskRunQueue.get();
 }
 
 void Document::setImportsController(HTMLImportsController* controller)
 {
-    ASSERT(!m_importsController || !controller);
+    DCHECK(!m_importsController || !controller);
     m_importsController = controller;
     if (!m_importsController && !loader())
         m_fetcher->clearContext();
 }
 
 HTMLImportLoader* Document::importLoader() const
 {
     if (!m_importsController)
         return 0;
     return m_importsController->loaderFor(*this);
@@ skipping 222 matching lines @@
         e = SVGElementFactory::createSVGElement(qName.localName(), *this, createdByParser);
 
     if (e)
         m_sawElementsInKnownNamespaces = true;
     else
         e = Element::create(qName, this);
 
     if (e->prefix() != qName.prefix())
         e->setTagNameForCreateElementNS(qName);
 
-    ASSERT(qName == e->tagQName());
+    DCHECK(qName == e->tagQName());
 
     return e.release();
 }
 
 String Document::readyState() const
 {
     DEFINE_STATIC_LOCAL(const String, loading, ("loading"));
     DEFINE_STATIC_LOCAL(const String, interactive, ("interactive"));
     DEFINE_STATIC_LOCAL(const String, complete, ("complete"));
 
@@ skipping 357 matching lines @@
 
     if (state == PageVisibilityStateVisible)
         timeline().setAllCompositorPending();
 
     if (hidden() && m_canvasFontCache)
         m_canvasFontCache->pruneAll();
 }
 
 void Document::registerVisibilityObserver(DocumentVisibilityObserver* observer)
 {
-    ASSERT(!m_visibilityObservers.contains(observer));
+    DCHECK(!m_visibilityObservers.contains(observer));
     m_visibilityObservers.add(observer);
 }
 
 void Document::unregisterVisibilityObserver(DocumentVisibilityObserver* observer)
 {
-    ASSERT(m_visibilityObservers.contains(observer));
+    DCHECK(m_visibilityObservers.contains(observer));
     m_visibilityObservers.remove(observer);
 }
 
 String Document::nodeName() const
 {
     return "#document";
 }
 
 Node::NodeType Document::getNodeType() const
 {
@@ skipping 44 matching lines @@
     return m_frame ? m_frame->settings() : 0;
 }
 
 RawPtr<Range> Document::createRange()
 {
     return Range::create(*this);
 }
 
 RawPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, RawPtr<NodeFilter> filter)
 {
-    ASSERT(root);
+    DCHECK(root);
     return NodeIterator::create(root, whatToShow, filter);
 }
 
 RawPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, RawPtr<NodeFilter> filter)
 {
-    ASSERT(root);
+    DCHECK(root);
     return TreeWalker::create(root, whatToShow, filter);
 }
 
 bool Document::needsLayoutTreeUpdate() const
 {
     if (!isActive() || !view())
         return false;
     if (needsFullLayoutTreeUpdate())
         return true;
     if (childNeedsStyleRecalc())
@@ skipping 34 matching lines @@
     // InPreLayout will recalc style itself. There's no reason to schedule another recalc.
     if (m_lifecycle.state() == DocumentLifecycle::InPreLayout)
         return false;
     if (!shouldScheduleLayout())
         return false;
     return true;
 }
 
 void Document::scheduleLayoutTreeUpdate()
 {
-    ASSERT(!hasPendingVisualUpdate());
-    ASSERT(shouldScheduleLayoutTreeUpdate());
-    ASSERT(needsLayoutTreeUpdate());
+    DCHECK(!hasPendingVisualUpdate());
+    DCHECK(shouldScheduleLayoutTreeUpdate());
+    DCHECK(needsLayoutTreeUpdate());
 
     if (!view()->canThrottleRendering())
         page()->animator().scheduleVisualUpdate(frame());
     m_lifecycle.ensureStateAtMost(DocumentLifecycle::VisualUpdatePending);
 
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ScheduleStyleRecalculation", TRACE_EVENT_SCOPE_THREAD, "data", InspectorRecalculateStylesEvent::data(frame()));
     InspectorInstrumentation::didScheduleStyleRecalculation(this);
 
     ++m_styleVersion;
 }
@@ skipping 17 matching lines @@
 
 void Document::setupFontBuilder(ComputedStyle& documentStyle)
 {
     FontBuilder fontBuilder(*this);
     RawPtr<CSSFontSelector> selector = styleEngine().fontSelector();
     fontBuilder.createFontForDocument(selector, documentStyle);
 }
 
 void Document::inheritHtmlAndBodyElementStyles(StyleRecalcChange change)
 {
-    ASSERT(inStyleRecalc());
-    ASSERT(documentElement());
+    DCHECK(inStyleRecalc());
+    DCHECK(documentElement());
 
     bool didRecalcDocumentElement = false;
     RefPtr<ComputedStyle> documentElementStyle = documentElement()->mutableComputedStyle();
     if (change == Force)
         documentElement()->clearAnimationStyleChange();
     if (!documentElementStyle || documentElement()->needsStyleRecalc() || change == Force) {
         documentElementStyle = ensureStyleResolver().styleForElement(documentElement());
         didRecalcDocumentElement = true;
     }
 
@@ skipping 32 matching lines @@
         if (currentLayer->attachment() == ScrollBackgroundAttachment)
             currentLayer->setAttachment(LocalBackgroundAttachment);
     }
     EImageRendering imageRendering = backgroundStyle->imageRendering();
 
     const ComputedStyle* overflowStyle = nullptr;
     if (Element* element = viewportDefiningElement(documentElementStyle.get())) {
         if (element == body) {
             overflowStyle = bodyStyle.get();
         } else {
-            ASSERT(element == documentElement());
+            DCHECK_EQ(element, documentElement());
             overflowStyle = documentElementStyle.get();
 
             // The body element has its own scrolling box, independent from the viewport.
             // This is a bit of a weird edge case in the CSS spec that we might want to try to
             // eliminate some day (eg. for ScrollTopLeftInterop - see http://crbug.com/157855).
             if (bodyStyle && !bodyStyle->isOverflowVisible())
                 UseCounter::count(*this, UseCounter::BodyScrollsInAdditionToViewport);
         }
     }
 
@@ skipping 53 matching lines @@
                 body->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::WritingModeChange));
         }
     }
 
     if (const ComputedStyle* style = documentElement()->computedStyle()) {
         if (style->direction() != rootDirection || style->getWritingMode() != rootWritingMode)
             documentElement()->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::WritingModeChange));
     }
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 static void assertLayoutTreeUpdated(Node& root)
 {
     for (Node& node : NodeTraversal::inclusiveDescendantsOf(root)) {
         // We leave some nodes with dirty bits in the tree because they don't
         // matter like Comment and ProcessingInstruction nodes.
         // TODO(esprehn): Don't even mark those nodes as needing recalcs in the
         // first place.
         if (!node.isElementNode()
             && !node.isTextNode()
             && !node.isShadowRoot()
             && !node.isDocumentNode())
             continue;
-        ASSERT(!node.needsStyleRecalc());
-        ASSERT(!node.childNeedsStyleRecalc());
-        ASSERT(!node.childNeedsDistributionRecalc());
-        ASSERT(!node.needsStyleInvalidation());
-        ASSERT(!node.childNeedsStyleInvalidation());
+        DCHECK(!node.needsStyleRecalc());
+        DCHECK(!node.childNeedsStyleRecalc());
+        DCHECK(!node.childNeedsDistributionRecalc());
+        DCHECK(!node.needsStyleInvalidation());
+        DCHECK(!node.childNeedsStyleInvalidation());
         for (ShadowRoot* shadowRoot = node.youngestShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
             assertLayoutTreeUpdated(*shadowRoot);
     }
 }
 #endif
 
 void Document::updateLayoutTree()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     ScriptForbiddenScope forbidScript;
     // We should forbid script execution for plugins here because update while layout is changing,
     // HTMLPlugin element can be reattached and plugin can be destroyed. Plugin can execute scripts
     // on destroy. It produces crash without PluginScriptForbiddenScope: crbug.com/550427.
     PluginScriptForbiddenScope pluginForbidScript;
 
     if (!view() || !isActive())
         return;
 
@@ skipping 54 matching lines @@
     // As a result of the style recalculation, the currently hovered element might have been
     // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event
     // to check if any other elements ended up under the mouse pointer due to re-layout.
     if (hoverNode() && !hoverNode()->layoutObject() && frame())
         frame()->eventHandler().dispatchFakeMouseMoveEventSoon();
 
     if (m_focusedElement && !m_focusedElement->isFocusable())
         clearFocusedElementSoon();
     layoutView()->clearHitTestCache();
 
-    ASSERT(!DocumentAnimations::needsAnimationTimingUpdate(*this));
+    DCHECK(!DocumentAnimations::needsAnimationTimingUpdate(*this));
 
     unsigned elementCount = styleEngine().styleForElementCount() - startElementCount;
 
     TRACE_EVENT_END1("blink,devtools.timeline", "UpdateLayoutTree", "elementCount", elementCount);
     InspectorInstrumentation::didRecalculateStyle(cookie, elementCount);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     assertLayoutTreeUpdated(*this);
 #endif
 }
 
 void Document::updateStyle()
 {
-    ASSERT(!view()->shouldThrottleRendering());
+    DCHECK(!view()->shouldThrottleRendering());
     TRACE_EVENT_BEGIN0("blink,blink_style", "Document::updateStyle");
     unsigned initialElementCount = styleEngine().styleForElementCount();
 
     HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
     m_lifecycle.advanceTo(DocumentLifecycle::InStyleRecalc);
 
     StyleRecalcChange change = NoChange;
     if (getStyleChangeType() >= SubtreeStyleChange)
         change = Force;
 
@@ skipping 31 matching lines @@
 
     view()->recalcOverflowAfterStyleChange();
     view()->setFrameTimingRequestsDirty(true);
 
     clearChildNeedsStyleRecalc();
 
     resolver.clearStyleSharingList();
 
     m_wasPrinting = m_printing;
 
-    ASSERT(!needsStyleRecalc());
-    ASSERT(!childNeedsStyleRecalc());
-    ASSERT(inStyleRecalc());
-    ASSERT(styleResolver() == &resolver);
+    DCHECK(!needsStyleRecalc());
+    DCHECK(!childNeedsStyleRecalc());
+    DCHECK(inStyleRecalc());
+    DCHECK_EQ(styleResolver(), &resolver);
     m_lifecycle.advanceTo(DocumentLifecycle::StyleClean);
     if (shouldRecordStats) {
         TRACE_EVENT_END2("blink,blink_style", "Document::updateStyle",
             "resolverAccessCount", styleEngine().styleForElementCount() - initialElementCount,
             "counters", styleEngine().stats()->toTracedValue());
     } else {
         TRACE_EVENT_END1("blink,blink_style", "Document::updateStyle",
             "resolverAccessCount", styleEngine().styleForElementCount() - initialElementCount);
     }
 }
 
 void Document::notifyLayoutTreeOfSubtreeChanges()
 {
     if (!layoutView()->wasNotifiedOfSubtreeChange())
         return;
 
     m_lifecycle.advanceTo(DocumentLifecycle::InLayoutSubtreeChange);
 
     layoutView()->handleSubtreeModifications();
-    ASSERT(!layoutView()->wasNotifiedOfSubtreeChange());
+    DCHECK(!layoutView()->wasNotifiedOfSubtreeChange());
 
     m_lifecycle.advanceTo(DocumentLifecycle::LayoutSubtreeChangeClean);
 }
 
 bool Document::needsLayoutTreeUpdateForNode(const Node& node) const
 {
     if (!node.canParticipateInFlatTree())
         return false;
     if (!needsLayoutTreeUpdate())
         return false;
     if (!node.inShadowIncludingDocument())
         return false;
 
     if (needsFullLayoutTreeUpdate() || node.needsStyleRecalc() || node.needsStyleInvalidation())
         return true;
     for (const ContainerNode* ancestor = LayoutTreeBuilderTraversal::parent(node); ancestor; ancestor = LayoutTreeBuilderTraversal::parent(*ancestor)) {
         if (ancestor->needsStyleRecalc() || ancestor->needsStyleInvalidation() || ancestor->needsAdjacentStyleRecalc())
             return true;
     }
     return false;
 }
 
 void Document::updateLayoutTreeForNode(Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     if (!needsLayoutTreeUpdateForNode(*node))
         return;
     updateLayoutTree();
 }
 
 void Document::updateLayoutIgnorePendingStylesheetsForNode(Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     if (!node->inActiveDocument())
         return;
     updateLayoutIgnorePendingStylesheets();
 }
 
 void Document::updateLayout()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     ScriptForbiddenScope forbidScript;
 
     RawPtr<FrameView> frameView = view();
     if (frameView && frameView->isInPerformLayout()) {
         // View layout should not be re-entrant.
         ASSERT_NOT_REACHED();
         return;
     }
 
@@ skipping 218 matching lines @@
     return m_styleEngine->resolver();
 }
 
 StyleResolver& Document::ensureStyleResolver() const
 {
     return m_styleEngine->ensureResolver();
 }
 
 void Document::attach(const AttachContext& context)
 {
-    ASSERT(m_lifecycle.state() == DocumentLifecycle::Inactive);
-    ASSERT(!m_axObjectCache || this != &axObjectCacheOwner());
+    DCHECK_EQ(m_lifecycle.state(), DocumentLifecycle::Inactive);
+    DCHECK(!m_axObjectCache || this != &axObjectCacheOwner());
 
     m_layoutView = new LayoutView(this);
     setLayoutObject(m_layoutView);
 
     m_layoutView->setIsInWindow(true);
     m_layoutView->setStyle(StyleResolver::styleForDocument(*this));
     m_layoutView->compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 
     ContainerNode::attach(context);
 
@@ skipping 143 matching lines @@
     if (LocalDOMWindow* domWindow = this->domWindow())
         domWindow->removeAllEventListeners();
 }
 
 Document& Document::axObjectCacheOwner() const
 {
     // Every document has its own axObjectCache if accessibility is enabled,
     // except for page popups, which share the axObjectCache of their owner.
     Document* doc = const_cast<Document*>(this);
     if (doc->frame() && doc->frame()->pagePopupOwner()) {
-        ASSERT(!doc->m_axObjectCache);
+        DCHECK(!doc->m_axObjectCache);
         return doc->frame()->pagePopupOwner()->document().axObjectCacheOwner();
     }
     return *doc;
 }
 
 void Document::clearAXObjectCache()
 {
-    ASSERT(&axObjectCacheOwner() == this);
+    DCHECK_EQ(&axObjectCacheOwner(), this);
     // Clear the cache member variable before calling delete because attempts
     // are made to access it during destruction.
     if (m_axObjectCache)
         m_axObjectCache->dispose();
     m_axObjectCache.clear();
 }
 
 AXObjectCache* Document::existingAXObjectCache() const
 {
     // If the layoutObject is gone then we are in the process of destruction.
@@ skipping 13 matching lines @@
     // The only document that actually has a AXObjectCache is the top-level
     // document.  This is because we need to be able to get from any WebCoreAXObject
     // to any other WebCoreAXObject on the same page.  Using a single cache allows
     // lookups across nested webareas (i.e. multiple documents).
     Document& cacheOwner = this->axObjectCacheOwner();
 
     // If the document has already been detached, do not make a new axObjectCache.
     if (!cacheOwner.layoutView())
         return 0;
 
-    ASSERT(&cacheOwner == this || !m_axObjectCache);
+    DCHECK(&cacheOwner == this || !m_axObjectCache);
     if (!cacheOwner.m_axObjectCache)
         cacheOwner.m_axObjectCache = AXObjectCache::create(cacheOwner);
     return cacheOwner.m_axObjectCache.get();
 }
 
 CanvasFontCache* Document::canvasFontCache()
 {
     if (!m_canvasFontCache)
         m_canvasFontCache = CanvasFontCache::create(*this);
 
@@ skipping 42 matching lines @@
         setSecurityOrigin(enteredDocument->getSecurityOrigin());
         setURL(enteredDocument->url());
         m_cookieURL = enteredDocument->cookieURL();
     }
 
     open();
 }
 
 void Document::open()
 {
-    ASSERT(!importLoader());
+    DCHECK(!importLoader());
 
     if (m_frame) {
         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
             if (parser->isParsing()) {
                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
                 if (parser->isExecutingScript())
                     return;
 
                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
                     return;
@@ skipping 29 matching lines @@
     detachParser();
     setParsingState(FinishedParsing);
     setReadyState(Complete);
 }
 
 RawPtr<DocumentParser> Document::implicitOpen(ParserSynchronizationPolicy parserSyncPolicy)
 {
     detachParser();
 
     removeChildren();
-    ASSERT(!m_focusedElement);
+    DCHECK(!m_focusedElement);
 
     setCompatibilityMode(NoQuirksMode);
 
     if (!threadedParsingEnabledForTesting())
         parserSyncPolicy = ForceSynchronousParsing;
 
     m_parserSyncPolicy = parserSyncPolicy;
     m_parser = createParser();
     DocumentParserTiming::from(*this).markParserStart();
     setParsingState(Parsing);
@@ skipping 119 matching lines @@
         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
         implicitClose();
         return;
     }
 
     m_frame->loader().checkCompleted();
 }
 
 void Document::implicitClose()
 {
-    ASSERT(!inStyleRecalc());
+    DCHECK(!inStyleRecalc());
     if (processingLoadEvent() || !m_parser)
         return;
     if (frame() && frame()->navigationScheduler().locationChangePending()) {
         suppressLoadEvent();
         return;
     }
 
     // The call to dispatchWindowLoadEvent (from documentWasClosed()) can detach
     // the LocalDOMWindow and cause it (and its attached Document) to be
     // destroyed.
@@ skipping 142 matching lines @@
                 return;
 
             // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed
             // while dispatching the event, so protect it to prevent writing the end
             // time into freed memory.
             RawPtr<DocumentLoader> documentLoader = m_frame->loader().provisionalDocumentLoader();
             m_loadEventProgress = UnloadEventInProgress;
             RawPtr<Event> unloadEvent(Event::create(EventTypeNames::unload));
             if (documentLoader && !documentLoader->timing().unloadEventStart() && !documentLoader->timing().unloadEventEnd()) {
                 DocumentLoadTiming& timing = documentLoader->timing();
-                ASSERT(timing.navigationStart());
+                DCHECK(timing.navigationStart());
                 timing.markUnloadEventStart();
                 m_frame->localDOMWindow()->dispatchEvent(unloadEvent, this);
                 timing.markUnloadEventEnd();
             } else {
                 m_frame->localDOMWindow()->dispatchEvent(unloadEvent, m_frame->document());
             }
         }
         m_loadEventProgress = UnloadEventHandled;
     }
 
@@ skipping 90 matching lines @@
     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
 
     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount) {
         addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, ExceptionMessages::failedToExecute("write", "Document", "It isn't possible to write into a document from an asynchronously-loaded external script unless it is explicitly opened.")));
         return;
     }
 
     if (!hasInsertionPoint)
         open(enteredDocument, ASSERT_NO_EXCEPTION);
 
-    ASSERT(m_parser);
+    DCHECK(m_parser);
     m_parser->insert(text);
 }
 
 void Document::write(const String& text, Document* enteredDocument, ExceptionState& exceptionState)
 {
     write(SegmentedString(text), enteredDocument, exceptionState);
 }
 
 void Document::writeln(const String& text, Document* enteredDocument, ExceptionState& exceptionState)
 {
     write(text, enteredDocument, exceptionState);
     if (exceptionState.hadException())
         return;
     write("\n", enteredDocument);
 }
 
 void Document::write(LocalDOMWindow* callingWindow, const Vector<String>& text, ExceptionState& exceptionState)
 {
-    ASSERT(callingWindow);
+    DCHECK(callingWindow);
     StringBuilder builder;
     for (const String& string : text)
         builder.append(string);
     write(builder.toString(), callingWindow->document(), exceptionState);
 }
 
 void Document::writeln(LocalDOMWindow* callingWindow, const Vector<String>& text, ExceptionState& exceptionState)
 {
-    ASSERT(callingWindow);
+    DCHECK(callingWindow);
     StringBuilder builder;
     for (const String& string : text)
         builder.append(string);
     writeln(builder.toString(), callingWindow->document(), exceptionState);
 }
 
 const KURL& Document::virtualURL() const
 {
     return m_url;
 }
@@ skipping 46 matching lines @@
     else
         m_baseURL = m_url;
 
     selectorQueryCache().invalidate();
 
     if (!m_baseURL.isValid())
         m_baseURL = KURL();
 
     if (m_elemSheet) {
         // Element sheet is silly. It never contains anything.
-        ASSERT(!m_elemSheet->contents()->ruleCount());
+        DCHECK(!m_elemSheet->contents()->ruleCount());
         m_elemSheet = CSSStyleSheet::createInline(this, m_baseURL);
     }
 
     if (!equalIgnoringFragmentIdentifier(oldBaseURL, m_baseURL)) {
         // Base URL change changes any relative visited links.
         // FIXME: There are other URLs in the tree that would need to be re-evaluated on dynamic base URL change. Style should be invalidated too.
         for (HTMLAnchorElement& anchor : Traversal<HTMLAnchorElement>::startsAfter(*this))
             anchor.invalidateCachedVisitedLinkHash();
     }
 }
@@ skipping 189 matching lines @@
 
     // See http://www.whatwg.org/specs/web-apps/current-work/#fetching-resources
     // for why we walk the parent chain for srcdoc documents.
     const Document* referrerDocument = this;
     if (LocalFrame* frame = m_frame) {
         while (frame->document()->isSrcdocDocument()) {
             // Srcdoc documents must be local within the containing frame.
             frame = toLocalFrame(frame->tree().parent());
             // Srcdoc documents cannot be top-level documents, by definition,
             // because they need to be contained in iframes with the srcdoc.
-            ASSERT(frame);
+            DCHECK(frame);
         }
         referrerDocument = frame->document();
     }
     return referrerDocument->m_url.strippedForUseAsReferrer();
 }
 
 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
 {
-    ASSERT(!layoutView() || layoutView()->isLayoutView());
+    DCHECK(!layoutView() || layoutView()->isLayoutView());
 
     // LayoutView::hitTest causes a layout, and we don't want to hit that until the first
     // layout because until then, there is nothing shown on the screen - the user can't
     // have intentionally clicked on something belonging to this page. Furthermore,
     // mousemove events before the first layout should not lead to a premature layout()
     // happening, which could show a flash of white.
     // See also the similar code in EventHandler::hitTestResultAtPoint.
     if (!layoutView() || !view() || !view()->didFirstLayout())
         return MouseEventWithHitTestResults(event, HitTestResult(request, LayoutPoint()));
 
@@ skipping 248 matching lines @@
 
 void Document::styleResolverMayHaveChanged()
 {
     styleEngine().resolverChanged(hasNodesWithPlaceholderStyle() ? FullStyleUpdate : AnalyzedStyleUpdate);
 
     if (didLayoutWithPendingStylesheets() && !styleEngine().hasPendingSheets()) {
         // We need to manually repaint because we avoid doing all repaints in layout or style
         // recalc while sheets are still loading to avoid FOUC.
         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
 
-        ASSERT(layoutView() || importsController());
+        DCHECK(layoutView() || importsController());
         if (layoutView())
             layoutView()->invalidatePaintForViewAndCompositedLayers();
     }
 }
 
 void Document::setHoverNode(RawPtr<Node> newHoverNode)
 {
     m_hoverNode = newHoverNode;
 }
 
@@ skipping 64 matching lines @@
 }
 
 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
 {
     m_annotatedRegions = regions;
     setAnnotatedRegionsDirty(false);
 }
 
 bool Document::setFocusedElement(RawPtr<Element> prpNewFocusedElement, const FocusParams& params)
 {
-    ASSERT(!m_lifecycle.inDetach());
+    DCHECK(!m_lifecycle.inDetach());
 
     m_clearFocusedElementTimer.stop();
 
     RawPtr<Element> newFocusedElement = prpNewFocusedElement;
 
     // Make sure newFocusedNode is actually in this document
     if (newFocusedElement && (newFocusedElement->document() != this))
         return true;
 
     if (NodeChildRemovalTracker::isBeingRemoved(newFocusedElement.get()))
@@ skipping 137 matching lines @@
 }
 
 void Document::setSequentialFocusNavigationStartingPoint(Node* node)
 {
     if (!m_frame)
         return;
     if (!node) {
         m_sequentialFocusNavigationStartingPoint = nullptr;
         return;
     }
-    ASSERT(node->document() == this);
+    DCHECK_EQ(node->document(), this);
     if (!m_sequentialFocusNavigationStartingPoint)
         m_sequentialFocusNavigationStartingPoint = Range::create(*this);
     m_sequentialFocusNavigationStartingPoint->selectNodeContents(node, ASSERT_NO_EXCEPTION);
 }
 
 Element* Document::sequentialFocusNavigationStartingPoint(WebFocusType type) const
 {
     if (m_focusedElement)
         return m_focusedElement.get();
     if (!m_sequentialFocusNavigationStartingPoint)
         return nullptr;
     if (!m_sequentialFocusNavigationStartingPoint->collapsed()) {
         Node* node = m_sequentialFocusNavigationStartingPoint->startContainer();
-        ASSERT(node == m_sequentialFocusNavigationStartingPoint->endContainer());
+        DCHECK_EQ(node, m_sequentialFocusNavigationStartingPoint->endContainer());
         if (node->isElementNode())
             return toElement(node);
         if (Element* neighborElement = type == WebFocusTypeForward ? ElementTraversal::previous(*node) : ElementTraversal::next(*node))
             return neighborElement;
         return node->parentOrShadowHostElement();
     }
 
     // Range::selectNodeContents didn't select contents because the element had
     // no children.
     if (m_sequentialFocusNavigationStartingPoint->startContainer()->isElementNode()
@@ skipping 18 matching lines @@
     if (m_cssTarget)
         m_cssTarget->pseudoStateChanged(CSSSelector::PseudoTarget);
     m_cssTarget = newTarget;
     if (m_cssTarget)
         m_cssTarget->pseudoStateChanged(CSSSelector::PseudoTarget);
 }
 
 void Document::registerNodeList(const LiveNodeListBase* list)
 {
 #if ENABLE(OILPAN)
-    ASSERT(!m_nodeLists[list->invalidationType()].contains(list));
+    DCHECK(!m_nodeLists[list->invalidationType()].contains(list));
     m_nodeLists[list->invalidationType()].add(list);
 #else
     m_nodeListCounts[list->invalidationType()]++;
 #endif
     if (list->isRootedAtTreeScope())
         m_listsInvalidatedAtDocument.add(list);
 }
 
 void Document::unregisterNodeList(const LiveNodeListBase* list)
 {
 #if ENABLE(OILPAN)
-    ASSERT(m_nodeLists[list->invalidationType()].contains(list));
+    DCHECK(m_nodeLists[list->invalidationType()].contains(list));
     m_nodeLists[list->invalidationType()].remove(list);
 #else
     m_nodeListCounts[list->invalidationType()]--;
 #endif
     if (list->isRootedAtTreeScope()) {
-        ASSERT(m_listsInvalidatedAtDocument.contains(list));
+        DCHECK(m_listsInvalidatedAtDocument.contains(list));
         m_listsInvalidatedAtDocument.remove(list);
     }
 }
 
 void Document::registerNodeListWithIdNameCache(const LiveNodeListBase* list)
 {
 #if ENABLE(OILPAN)
-    ASSERT(!m_nodeLists[InvalidateOnIdNameAttrChange].contains(list));
+    DCHECK(!m_nodeLists[InvalidateOnIdNameAttrChange].contains(list));
     m_nodeLists[InvalidateOnIdNameAttrChange].add(list);
 #else
     m_nodeListCounts[InvalidateOnIdNameAttrChange]++;
 #endif
 }
 
 void Document::unregisterNodeListWithIdNameCache(const LiveNodeListBase* list)
 {
 #if ENABLE(OILPAN)
-    ASSERT(m_nodeLists[InvalidateOnIdNameAttrChange].contains(list));
+    DCHECK(m_nodeLists[InvalidateOnIdNameAttrChange].contains(list));
     m_nodeLists[InvalidateOnIdNameAttrChange].remove(list);
 #else
-    ASSERT(m_nodeListCounts[InvalidateOnIdNameAttrChange] > 0);
+    DCHECK_GT(m_nodeListCounts[InvalidateOnIdNameAttrChange], 0);
     m_nodeListCounts[InvalidateOnIdNameAttrChange]--;
 #endif
 }
 
 void Document::attachNodeIterator(NodeIterator* ni)
 {
     m_nodeIterators.add(ni);
 }
 
 void Document::detachNodeIterator(NodeIterator* ni)
@@ skipping 15 matching lines @@
 }
 
 void Document::updateRangesAfterChildrenChanged(ContainerNode* container)
 {
     for (Range* range : m_ranges)
         range->nodeChildrenChanged(container);
 }
 
 void Document::updateRangesAfterNodeMovedToAnotherDocument(const Node& node)
 {
-    ASSERT(node.document() != this);
+    DCHECK_NE(node.document(), this);
     if (m_ranges.isEmpty())
         return;
 
     AttachedRangeSet ranges = m_ranges;
     for (Range* range : ranges)
         range->updateOwnerDocumentIfNeeded();
 }
 
 void Document::nodeChildrenWillBeRemoved(ContainerNode& container)
 {
@@ skipping 148 matching lines @@
 const OriginAccessEntry& Document::accessEntryFromURL()
 {
     if (!m_accessEntryFromURL) {
         m_accessEntryFromURL = adoptPtr(new OriginAccessEntry(url().protocol(), url().host(), OriginAccessEntry::AllowRegisterableDomains));
     }
     return *m_accessEntryFromURL;
 }
 
 void Document::registerEventFactory(PassOwnPtr<EventFactoryBase> eventFactory)
 {
-    ASSERT(!eventFactories().contains(eventFactory.get()));
+    DCHECK(!eventFactories().contains(eventFactory.get()));
     eventFactories().add(eventFactory);
 }
 
 RawPtr<Event> Document::createEvent(ExecutionContext* executionContext, const String& eventType, ExceptionState& exceptionState)
 {
     RawPtr<Event> event = nullptr;
     for (const auto& factory : eventFactories()) {
         event = factory->create(executionContext, eventType);
         if (event)
             return event.release();
@@ skipping 51 matching lines @@
         return 0;
     // FIXME: This probably breaks the attempts to layout after a load is finished in implicitClose(), and probably tons of other things...
     return frame()->deprecatedLocalOwner();
 }
 
 bool Document::isInInvisibleSubframe() const
 {
     if (!ownerElement())
         return false; // this is the root element
 
-    ASSERT(frame());
+    DCHECK(frame());
     return !frame()->ownerLayoutObject();
 }
 
 String Document::cookie(ExceptionState& exceptionState) const
 {
     if (settings() && !settings()->cookieEnabled())
         return String();
 
     // FIXME: The HTML5 DOM spec states that this attribute can raise an
     // InvalidStateError exception on getting if the Document has no
@@ skipping 126 matching lines @@
     // Sandboxing a document into a unique origin shouldn't effect first-/third-party status for
     // cookies and site data.
     const OriginAccessEntry& accessEntry = frame()->tree().top()->isLocalFrame()
         ? topDocument().accessEntryFromURL()
         : OriginAccessEntry(topDocumentURL.protocol(), topDocumentURL.host(), OriginAccessEntry::AllowRegisterableDomains);
     const Frame* currentFrame = frame();
     while (currentFrame) {
         // Skip over srcdoc documents, as they are always same-origin with their closest non-srcdoc parent.
         while (currentFrame->isLocalFrame() && toLocalFrame(currentFrame)->document()->isSrcdocDocument())
             currentFrame = currentFrame->tree().parent();
-        ASSERT(currentFrame);
+        DCHECK(currentFrame);
 
         // We use 'matchesDomain' here, as it turns out that some folks embed HTTPS login forms
         // into HTTP pages; we should allow this kind of upgrade.
         if (accessEntry.matchesDomain(*currentFrame->securityContext()->getSecurityOrigin()) == OriginAccessEntry::DoesNotMatchOrigin)
             return SecurityOrigin::urlWithUniqueSecurityOrigin();
 
         currentFrame = currentFrame->tree().parent();
     }
 
     return topDocumentURL;
@@ skipping 152 matching lines @@
         message.appendLiteral("contains the invalid name-start character '");
         message.append(returnValue.character);
         message.appendLiteral("'.");
     } else if (returnValue.status == QNInvalidChar) {
         message.appendLiteral("contains the invalid character '");
         message.append(returnValue.character);
         message.appendLiteral("'.");
     } else if (returnValue.status == QNEmptyPrefix) {
         message.appendLiteral("has an empty namespace prefix.");
     } else {
-        ASSERT(returnValue.status == QNEmptyLocalName);
+        DCHECK_EQ(returnValue.status, QNEmptyLocalName);
         message.appendLiteral("has an empty local name.");
     }
 
     if (returnValue.status == QNInvalidStartChar || returnValue.status == QNInvalidChar)
         exceptionState.throwDOMException(InvalidCharacterError, message.toString());
     else
         exceptionState.throwDOMException(NamespaceError, message.toString());
     return false;
 }
 
@@ skipping 10 matching lines @@
         && !ElementTraversal::firstWithin(*m_titleElement)
         && encoding() == Latin1Encoding()
         && m_titleElement->textContent().containsOnlyLatin1()) {
 
         CString originalBytes = m_titleElement->textContent().latin1();
         OwnPtr<TextCodec> codec = newTextCodec(newData.encoding());
         String correctlyDecodedTitle = codec->decode(originalBytes.data(), originalBytes.length(), DataEOF);
         m_titleElement->setTextContent(correctlyDecodedTitle);
     }
 
-    ASSERT(newData.encoding().isValid());
+    DCHECK(newData.encoding().isValid());
     m_encodingData = newData;
 
     // FIXME: Should be removed as part of https://code.google.com/p/chromium/issues/detail?id=319643
     bool shouldUseVisualOrdering = m_encodingData.encoding().usesVisualOrdering();
     if (shouldUseVisualOrdering != m_visuallyOrdered) {
         m_visuallyOrdered = shouldUseVisualOrdering;
         // FIXME: How is possible to not have a layoutObject here?
         if (layoutView())
             layoutView()->mutableStyleRef().setRTLOrdering(m_visuallyOrdered ? VisualOrder : LogicalOrder);
         setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::VisuallyOrdered));
     }
 }
 
 KURL Document::completeURL(const String& url) const
 {
     return completeURLWithOverride(url, m_baseURL);
 }
 
 KURL Document::completeURLWithOverride(const String& url, const KURL& baseURLOverride) const
 {
-    ASSERT(baseURLOverride.isEmpty() || baseURLOverride.isValid());
+    DCHECK(baseURLOverride.isEmpty() || baseURLOverride.isValid());
 
     // Always return a null URL when passed a null string.
     // FIXME: Should we change the KURL constructor to have this behavior?
     // See also [CSS]StyleSheet::completeURL(const String&)
     if (url.isNull())
         return KURL();
     // This logic is deliberately spread over many statements in an attempt to track down http://crbug.com/312410.
     const KURL& baseURL = baseURLForOverride(baseURLOverride);
     if (!encoding().isValid())
         return KURL(baseURL, url);
@@ skipping 139 matching lines @@
 
 HTMLScriptElement* Document::currentScriptForBinding() const
 {
     if (HTMLScriptElement* script = currentScript())
         return script->isInV1ShadowTree() ? nullptr : script;
     return nullptr;
 }
 
 void Document::pushCurrentScript(RawPtr<HTMLScriptElement> newCurrentScript)
 {
-    ASSERT(newCurrentScript);
+    DCHECK(newCurrentScript);
     m_currentScriptStack.append(newCurrentScript);
 }
 
 void Document::popCurrentScript()
 {
-    ASSERT(!m_currentScriptStack.isEmpty());
+    DCHECK(!m_currentScriptStack.isEmpty());
     m_currentScriptStack.removeLast();
 }
 
 void Document::setTransformSource(PassOwnPtr<TransformSource> source)
 {
     m_transformSource = source;
 }
 
 String Document::designMode() const
 {
@@ skipping 26 matching lines @@
 }
 
 Document& Document::topDocument() const
 {
     // FIXME: Not clear what topDocument() should do in the OOPI case--should it return the topmost
     // available Document, or something else?
     Document* doc = const_cast<Document*>(this);
     for (HTMLFrameOwnerElement* element = doc->ownerElement(); element; element = doc->ownerElement())
         doc = &element->document();
 
-    ASSERT(doc);
+    DCHECK(doc);
     return *doc;
 }
 
 RawPtr<Document> Document::contextDocument()
 {
     if (m_contextDocument)
         return m_contextDocument;
     if (m_frame) {
         return createWeakPtr();
     }
@@ skipping 91 matching lines @@
     return ensureCachedCollection<WindowNameCollection>(WindowNamedItems, name);
 }
 
 RawPtr<DocumentNameCollection> Document::documentNamedItems(const AtomicString& name)
 {
     return ensureCachedCollection<DocumentNameCollection>(DocumentNamedItems, name);
 }
 
 void Document::finishedParsing()
 {
-    ASSERT(!scriptableDocumentParser() || !m_parser->isParsing());
-    ASSERT(!scriptableDocumentParser() || m_readyState != Loading);
+    DCHECK(!scriptableDocumentParser() || !m_parser->isParsing());
+    DCHECK(!scriptableDocumentParser() || m_readyState != Loading);
     setParsingState(InDOMContentLoaded);
     DocumentParserTiming::from(*this).markParserStop();
 
     // FIXME: DOMContentLoaded is dispatched synchronously, but this should be dispatched in a queued task,
     // See https://crbug.com/425790
     if (!m_documentTiming.domContentLoadedEventStart())
         m_documentTiming.markDomContentLoadedEventStart();
     dispatchEvent(Event::createBubble(EventTypeNames::DOMContentLoaded));
     if (!m_documentTiming.domContentLoadedEventEnd())
         m_documentTiming.markDomContentLoadedEventEnd();
@@ skipping 128 matching lines @@
     m_frame->selection().updateSecureKeyboardEntryIfActive();
 }
 
 bool Document::useSecureKeyboardEntryWhenActive() const
 {
     return m_useSecureKeyboardEntryWhenActive;
 }
 
 void Document::initSecurityContext(const DocumentInit& initializer)
 {
-    ASSERT(!getSecurityOrigin());
+    DCHECK(!getSecurityOrigin());
 
     if (!initializer.hasSecurityContext()) {
         // No source for a security context.
         // This can occur via document.implementation.createDocument().
         m_cookieURL = KURL(ParsedURLString, emptyString());
         setSecurityOrigin(SecurityOrigin::createUnique());
         initContentSecurityPolicy();
         // Unique security origins cannot have a suborigin
         return;
     }
@@ skipping 187 matching lines @@
     Element* element = focusedElement();
     if (!element)
         return;
     updateLayout();
     if (element->isFocusable())
         element->updateFocusAppearance(m_updateFocusAppearanceSelectionBahavior);
 }
 
 void Document::attachRange(Range* range)
 {
-    ASSERT(!m_ranges.contains(range));
+    DCHECK(!m_ranges.contains(range));
     m_ranges.add(range);
 }
 
 void Document::detachRange(Range* range)
 {
     // We don't ASSERT m_ranges.contains(range) to allow us to call this
     // unconditionally to fix: https://bugs.webkit.org/show_bug.cgi?id=26044
     m_ranges.remove(range);
 }
 
@@ skipping 129 matching lines @@
 {
     Page* page = this->page();
     return page && page->defersLoading();
 }
 
 void Document::addToTopLayer(Element* element, const Element* before)
 {
     if (element->isInTopLayer())
         return;
 
-    ASSERT(!m_topLayerElements.contains(element));
-    ASSERT(!before || m_topLayerElements.contains(before));
+    DCHECK(!m_topLayerElements.contains(element));
+    DCHECK(!before || m_topLayerElements.contains(before));
     if (before) {
         size_t beforePosition = m_topLayerElements.find(before);
         m_topLayerElements.insert(beforePosition, element);
     } else {
         m_topLayerElements.append(element);
     }
     element->setIsInTopLayer(true);
 }
 
 void Document::removeFromTopLayer(Element* element)
 {
     if (!element->isInTopLayer())
         return;
     size_t position = m_topLayerElements.find(element);
-    ASSERT(position != kNotFound);
+    DCHECK_NE(position, kNotFound);
     m_topLayerElements.remove(position);
     element->setIsInTopLayer(false);
 }
 
 HTMLDialogElement* Document::activeModalDialog() const
 {
     if (m_topLayerElements.isEmpty())
         return 0;
     return toHTMLDialogElement(m_topLayerElements.last().get());
 }
@@ skipping 21 matching lines @@
 }
 
 void Document::suppressLoadEvent()
 {
     if (!loadEventFinished())
         m_loadEventProgress = LoadEventCompleted;
 }
 
 void Document::decrementLoadEventDelayCount()
 {
-    ASSERT(m_loadEventDelayCount);
+    DCHECK(m_loadEventDelayCount);
     --m_loadEventDelayCount;
 
     if (!m_loadEventDelayCount)
         checkLoadEventSoon();
 }
 
 void Document::checkLoadEventSoon()
 {
     if (frame() && !m_loadEventDelayTimer.isActive())
         m_loadEventDelayTimer.startOneShot(0, BLINK_FROM_HERE);
@@ skipping 195 matching lines @@
             if (currObj1 == currObj2)
                 return currObj1;
         }
     }
 
     return 0;
 }
 
 void Document::updateHoverActiveState(const HitTestRequest& request, Element* innerElement)
 {
-    ASSERT(!request.readOnly());
+    DCHECK(!request.readOnly());
 
     if (request.active() && m_frame)
         m_frame->eventHandler().notifyElementActivated();
 
     Element* innerElementInDocument = innerElement;
     while (innerElementInDocument && innerElementInDocument->document() != this) {
         innerElementInDocument->document().updateHoverActiveState(request, innerElementInDocument);
         innerElementInDocument = innerElementInDocument->document().ownerElement();
     }
 
     updateDistribution();
     Element* oldActiveElement = activeHoverElement();
     if (oldActiveElement && !request.active()) {
         // The oldActiveElement layoutObject is null, dropped on :active by setting display: none,
         // for instance. We still need to clear the ActiveChain as the mouse is released.
         for (RawPtr<Node> node = oldActiveElement; node; node = FlatTreeTraversal::parent(*node)) {
-            ASSERT(!node->isTextNode());
+            DCHECK(!node->isTextNode());
             node->setActive(false);
             m_userActionElements.setInActiveChain(node.get(), false);
         }
         setActiveHoverElement(nullptr);
     } else {
         Element* newActiveElement = innerElementInDocument;
         if (!oldActiveElement && newActiveElement && !newActiveElement->isDisabledFormControl() && request.active() && !request.touchMove()) {
             // We are setting the :active chain and freezing it. If future moves happen, they
             // will need to reference this chain.
             for (Node* node = newActiveElement; node; node = FlatTreeTraversal::parent(*node)) {
-                ASSERT(!node->isTextNode());
+                DCHECK(!node->isTextNode());
                 m_userActionElements.setInActiveChain(node, true);
             }
             setActiveHoverElement(newActiveElement);
         }
     }
     // If the mouse has just been pressed, set :active on the chain. Those (and only those)
     // nodes should remain :active until the mouse is released.
     bool allowActiveChanges = !oldActiveElement && activeHoverElement();
 
     // If the mouse is down and if this is a mouse move event, we want to restrict changes in
@@ skipping 80 matching lines @@
     if (locale.isEmpty() || !RuntimeEnabledFeatures::langAttributeAwareFormControlUIEnabled())
         return Locale::defaultLocale();
     LocaleIdentifierToLocaleMap::AddResult result = m_localeCache.add(localeKey, nullptr);
     if (result.isNewEntry)
         result.storedValue->value = Locale::create(localeKey);
     return *(result.storedValue->value);
 }
 
 AnimationClock& Document::animationClock()
 {
-    ASSERT(page());
+    DCHECK(page());
     return page()->animator().clock();
 }
 
 Document& Document::ensureTemplateDocument()
 {
     if (isTemplateDocument())
         return *this;
 
     if (m_templateDocument)
         return *m_templateDocument;
@@ skipping 56 matching lines @@
 
 void Document::setAutofocusElement(Element* element)
 {
     if (!element) {
         m_autofocusElement = nullptr;
         return;
     }
     if (m_hasAutofocused)
         return;
     m_hasAutofocused = true;
-    ASSERT(!m_autofocusElement);
+    DCHECK(!m_autofocusElement);
     m_autofocusElement = element;
     m_taskRunner->postTask(BLINK_FROM_HERE, AutofocusTask::create());
 }
 
 Element* Document::activeElement() const
 {
     if (Element* element = adjustedFocusedElement())
         return element;
     return body();
 }
@@ skipping 69 matching lines @@
     styleEngine().platformColorsChanged();
 }
 
 v8::Local<v8::Object> Document::wrap(v8::Isolate* isolate, v8::Local<v8::Object> creationContext)
 {
     // It's possible that no one except for the new wrapper owns this object at
     // this moment, so we have to prevent GC to collect this object until the
     // object gets associated with the wrapper.
     RawPtr<Document> protect(this);
 
-    ASSERT(!DOMDataStore::containsWrapper(this, isolate));
+    DCHECK(!DOMDataStore::containsWrapper(this, isolate));
 
     const WrapperTypeInfo* wrapperType = wrapperTypeInfo();
 
     if (frame() && frame()->script().initializeMainWorld()) {
         // initializeMainWorld may have created a wrapper for the object, retry from the start.
         v8::Local<v8::Object> wrapper = DOMDataStore::getWrapper(this, isolate);
         if (!wrapper.IsEmpty())
             return wrapper;
     }
 
@@ skipping 130 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     Document::WeakDocumentSet& set = Document::liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().getString().utf8().data());
 }
 #endif