Add optional debugging output of what paint chunks go into what layers.

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 202 matching lines @@
   LayoutObject* layoutObject = node->layoutObject();
   if (!layoutObject || !layoutObject->isBox())
     return nullptr;
 
   return toLayoutBox(layoutObject)->getScrollableArea();
 }
 
 static RuntimeEnabledFeatures::Backup* sFeaturesBackup = nullptr;
 
 void Internals::resetToConsistentState(Page* page) {
-  ASSERT(page);
+  DCHECK(page);
 
   if (!sFeaturesBackup)
     sFeaturesBackup = new RuntimeEnabledFeatures::Backup;
   sFeaturesBackup->restore();
   page->setIsCursorVisible(true);
   page->setPageScaleFactor(1);
   page->deprecatedLocalMainFrame()
       ->view()
       ->layoutViewportScrollableArea()
       ->setScrollOffset(ScrollOffset(), ProgrammaticScroll);
@@ skipping 45 matching lines @@
 
 String Internals::address(Node* node) {
   char buf[32];
   sprintf(buf, "%p", node);
 
   return String(buf);
 }
 
 GCObservation* Internals::observeGC(ScriptValue scriptValue) {
   v8::Local<v8::Value> observedValue = scriptValue.v8Value();
-  ASSERT(!observedValue.IsEmpty());
+  DCHECK(!observedValue.IsEmpty());
   if (observedValue->IsNull() || observedValue->IsUndefined()) {
     V8ThrowException::throwTypeError(v8::Isolate::GetCurrent(),
                                      "value to observe is null or undefined");
     return nullptr;
   }
 
   return GCObservation::create(observedValue);
 }
 
 unsigned Internals::updateStyleAndReturnAffectedElementCount(
@@ skipping 137 matching lines @@
   if (!document)
     return String();
   Resource* resource = document->fetcher()->allResources().get(
       URLTestHelpers::toKURL(url.utf8().data()));
   if (!resource)
     return String();
   return resource->resourceRequest().httpHeaderField(header.utf8().data());
 }
 
 bool Internals::isSharingStyle(Element* element1, Element* element2) const {
-  ASSERT(element1 && element2);
+  DCHECK(element1 && element2);
   return element1->computedStyle() == element2->computedStyle();
 }
 
 bool Internals::isValidContentSelect(Element* insertionPoint,
                                      ExceptionState& exceptionState) {
-  ASSERT(insertionPoint);
+  DCHECK(insertionPoint);
   if (!insertionPoint->isInsertionPoint()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The element is not an insertion point.");
     return false;
   }
 
   return isHTMLContentElement(*insertionPoint) &&
          toHTMLContentElement(*insertionPoint).isSelectValid();
 }
 
 Node* Internals::treeScopeRootNode(Node* node) {
-  ASSERT(node);
+  DCHECK(node);
   return &node->treeScope().rootNode();
 }
 
 Node* Internals::parentTreeScope(Node* node) {
-  ASSERT(node);
+  DCHECK(node);
   const TreeScope* parentTreeScope = node->treeScope().parentTreeScope();
   return parentTreeScope ? &parentTreeScope->rootNode() : 0;
 }
 
 bool Internals::hasSelectorForIdInShadow(Element* host,
                                          const AtomicString& idValue,
                                          ExceptionState& exceptionState) {
-  ASSERT(host);
+  DCHECK(host);
   if (!host->shadow() || host->shadow()->isV1()) {
     exceptionState.throwDOMException(
         InvalidAccessError, "The host element does not have a v0 shadow.");
     return false;
   }
 
   return host->shadow()->v0().ensureSelectFeatureSet().hasSelectorForId(
       idValue);
 }
 
 bool Internals::hasSelectorForClassInShadow(Element* host,
                                             const AtomicString& className,
                                             ExceptionState& exceptionState) {
-  ASSERT(host);
+  DCHECK(host);
   if (!host->shadow() || host->shadow()->isV1()) {
     exceptionState.throwDOMException(
         InvalidAccessError, "The host element does not have a v0 shadow.");
     return false;
   }
 
   return host->shadow()->v0().ensureSelectFeatureSet().hasSelectorForClass(
       className);
 }
 
 bool Internals::hasSelectorForAttributeInShadow(
     Element* host,
     const AtomicString& attributeName,
     ExceptionState& exceptionState) {
-  ASSERT(host);
+  DCHECK(host);
   if (!host->shadow() || host->shadow()->isV1()) {
     exceptionState.throwDOMException(
         InvalidAccessError, "The host element does not have a v0 shadow.");
     return false;
   }
 
   return host->shadow()->v0().ensureSelectFeatureSet().hasSelectorForAttribute(
       attributeName);
 }
 
 unsigned short Internals::compareTreeScopePosition(
     const Node* node1,
     const Node* node2,
     ExceptionState& exceptionState) const {
-  ASSERT(node1 && node2);
+  DCHECK(node1 && node2);
   const TreeScope* treeScope1 =
       node1->isDocumentNode()
           ? static_cast<const TreeScope*>(toDocument(node1))
           : node1->isShadowRoot()
                 ? static_cast<const TreeScope*>(toShadowRoot(node1))
                 : 0;
   const TreeScope* treeScope2 =
       node2->isDocumentNode()
           ? static_cast<const TreeScope*>(toDocument(node2))
           : node2->isShadowRoot()
@@ skipping 34 matching lines @@
   animation->disableCompositedAnimationForTesting();
 }
 
 void Internals::disableCSSAdditiveAnimations() {
   RuntimeEnabledFeatures::setCSSAdditiveAnimationsEnabled(false);
 }
 
 void Internals::advanceTimeForImage(Element* image,
                                     double deltaTimeInSeconds,
                                     ExceptionState& exceptionState) {
-  ASSERT(image);
+  DCHECK(image);
   if (deltaTimeInSeconds < 0) {
     exceptionState.throwDOMException(
         InvalidAccessError, ExceptionMessages::indexExceedsMinimumBound(
                                 "deltaTimeInSeconds", deltaTimeInSeconds, 0.0));
     return;
   }
 
   ImageResourceContent* resource = nullptr;
   if (isHTMLImageElement(*image)) {
     resource = toHTMLImageElement(*image).cachedImage();
@@ skipping 16 matching lines @@
     exceptionState.throwDOMException(
         InvalidAccessError, "The image resource is not a BitmapImage type.");
     return;
   }
 
   imageData->advanceTime(deltaTimeInSeconds);
 }
 
 void Internals::advanceImageAnimation(Element* image,
                                       ExceptionState& exceptionState) {
-  ASSERT(image);
+  DCHECK(image);
 
   ImageResourceContent* resource = nullptr;
   if (isHTMLImageElement(*image)) {
     resource = toHTMLImageElement(*image).cachedImage();
   } else if (isSVGImageElement(*image)) {
     resource = toSVGImageElement(*image).cachedImage();
   } else {
     exceptionState.throwDOMException(
         InvalidAccessError, "The element provided is not a image element.");
     return;
   }
 
   if (!resource || !resource->hasImage()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The image resource is not available.");
     return;
   }
 
   Image* imageData = resource->getImage();
   imageData->advanceAnimationForTesting();
 }
 
 bool Internals::hasShadowInsertionPoint(const Node* root,
                                         ExceptionState& exceptionState) const {
-  ASSERT(root);
+  DCHECK(root);
   if (!root->isShadowRoot()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The node argument is not a shadow root.");
     return false;
   }
   return toShadowRoot(root)->containsShadowElements();
 }
 
 bool Internals::hasContentElement(const Node* root,
                                   ExceptionState& exceptionState) const {
-  ASSERT(root);
+  DCHECK(root);
   if (!root->isShadowRoot()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The node argument is not a shadow root.");
     return false;
   }
   return toShadowRoot(root)->containsContentElements();
 }
 
 size_t Internals::countElementShadow(const Node* root,
                                      ExceptionState& exceptionState) const {
-  ASSERT(root);
+  DCHECK(root);
   if (!root->isShadowRoot()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The node argument is not a shadow root.");
     return 0;
   }
   return toShadowRoot(root)->childShadowRootCount();
 }
 
 Node* Internals::nextSiblingInFlatTree(Node* node,
                                        ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   if (!node->canParticipateInFlatTree()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The node argument doesn't particite in the flat tree.");
     return 0;
   }
   return FlatTreeTraversal::nextSibling(*node);
 }
 
 Node* Internals::firstChildInFlatTree(Node* node,
                                       ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   if (!node->canParticipateInFlatTree()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The node argument doesn't particite in the flat tree");
     return 0;
   }
   return FlatTreeTraversal::firstChild(*node);
 }
 
 Node* Internals::lastChildInFlatTree(Node* node,
                                      ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   if (!node->canParticipateInFlatTree()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The node argument doesn't particite in the flat tree.");
     return 0;
   }
   return FlatTreeTraversal::lastChild(*node);
 }
 
 Node* Internals::nextInFlatTree(Node* node, ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   if (!node->canParticipateInFlatTree()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The node argument doesn't particite in the flat tree.");
     return 0;
   }
   return FlatTreeTraversal::next(*node);
 }
 
 Node* Internals::previousInFlatTree(Node* node,
                                     ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   if (!node->canParticipateInFlatTree()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The node argument doesn't particite in the flat tree.");
     return 0;
   }
   return FlatTreeTraversal::previous(*node);
 }
 
 String Internals::elementLayoutTreeAsText(Element* element,
                                           ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   element->document().view()->updateAllLifecyclePhases();
 
   String representation = externalRepresentation(element);
   if (representation.isEmpty()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "The element provided has no external representation.");
     return String();
   }
 
   return representation;
 }
 
 CSSStyleDeclaration* Internals::computedStyleIncludingVisitedInfo(
     Node* node) const {
-  ASSERT(node);
+  DCHECK(node);
   bool allowVisitedStyle = true;
   return CSSComputedStyleDeclaration::create(node, allowVisitedStyle);
 }
 
 ShadowRoot* Internals::createUserAgentShadowRoot(Element* host) {
-  ASSERT(host);
+  DCHECK(host);
   return &host->ensureUserAgentShadowRoot();
 }
 
 ShadowRoot* Internals::shadowRoot(Element* host) {
   // FIXME: Internals::shadowRoot() in tests should be converted to
   // youngestShadowRoot() or oldestShadowRoot().
   // https://bugs.webkit.org/show_bug.cgi?id=78465
   return youngestShadowRoot(host);
 }
 
 ShadowRoot* Internals::youngestShadowRoot(Element* host) {
-  ASSERT(host);
+  DCHECK(host);
   if (ElementShadow* shadow = host->shadow())
     return &shadow->youngestShadowRoot();
   return 0;
 }
 
 ShadowRoot* Internals::oldestShadowRoot(Element* host) {
-  ASSERT(host);
+  DCHECK(host);
   if (ElementShadow* shadow = host->shadow())
     return &shadow->oldestShadowRoot();
   return 0;
 }
 
 ShadowRoot* Internals::youngerShadowRoot(Node* shadow,
                                          ExceptionState& exceptionState) {
-  ASSERT(shadow);
+  DCHECK(shadow);
   if (!shadow->isShadowRoot()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The node provided is not a shadow root.");
     return 0;
   }
 
   return toShadowRoot(shadow)->youngerShadowRoot();
 }
 
 String Internals::shadowRootType(const Node* root,
                                  ExceptionState& exceptionState) const {
-  ASSERT(root);
+  DCHECK(root);
   if (!root->isShadowRoot()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The node provided is not a shadow root.");
     return String();
   }
 
   switch (toShadowRoot(root)->type()) {
     case ShadowRootType::UserAgent:
       return String("UserAgentShadowRoot");
     case ShadowRootType::V0:
       return String("V0ShadowRoot");
     case ShadowRootType::Open:
       return String("OpenShadowRoot");
     case ShadowRootType::Closed:
       return String("ClosedShadowRoot");
     default:
       ASSERT_NOT_REACHED();
       return String("Unknown");
   }
 }
 
 const AtomicString& Internals::shadowPseudoId(Element* element) {
-  ASSERT(element);
+  DCHECK(element);
   return element->shadowPseudoId();
 }
 
 String Internals::visiblePlaceholder(Element* element) {
   if (element && isTextControlElement(*element)) {
     const TextControlElement& textControlElement =
         toTextControlElement(*element);
     if (!textControlElement.isPlaceholderVisible())
       return String();
     if (HTMLElement* placeholderElement =
             textControlElement.placeholderElement())
       return placeholderElement->textContent();
   }
 
   return String();
 }
 
 void Internals::selectColorInColorChooser(Element* element,
                                           const String& colorValue) {
-  ASSERT(element);
+  DCHECK(element);
   if (!isHTMLInputElement(*element))
     return;
   Color color;
   if (!color.setFromString(colorValue))
     return;
   toHTMLInputElement(*element).selectColorInColorChooser(color);
 }
 
 void Internals::endColorChooser(Element* element) {
-  ASSERT(element);
+  DCHECK(element);
   if (!isHTMLInputElement(*element))
     return;
   toHTMLInputElement(*element).endColorChooser();
 }
 
 bool Internals::hasAutofocusRequest(Document* document) {
   if (!document)
     document = m_document;
   return document->autofocusElement();
 }
@@ skipping 43 matching lines @@
     exceptionState.throwDOMException(
         InvalidAccessError, "The document's frame cannot be retrieved.");
     return ClientRect::create();
   }
 
   m_document->updateStyleAndLayoutIgnorePendingStylesheets();
   return ClientRect::create(frame()->selection().absoluteCaretBounds());
 }
 
 ClientRect* Internals::boundingBox(Element* element) {
-  ASSERT(element);
+  DCHECK(element);
 
   element->document().updateStyleAndLayoutIgnorePendingStylesheets();
   LayoutObject* layoutObject = element->layoutObject();
   if (!layoutObject)
     return ClientRect::create();
   return ClientRect::create(
       layoutObject->absoluteBoundingBoxRectIgnoringTransforms());
 }
 
 void Internals::setMarker(Document* document,
@@ skipping 15 matching lines @@
   }
 
   document->updateStyleAndLayoutIgnorePendingStylesheets();
   document->markers().addMarker(range->startPosition(), range->endPosition(),
                                 type.value());
 }
 
 unsigned Internals::markerCountForNode(Node* node,
                                        const String& markerType,
                                        ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   WTF::Optional<DocumentMarker::MarkerTypes> markerTypes =
       markerTypesFrom(markerType);
   if (!markerTypes) {
     exceptionState.throwDOMException(
         SyntaxError,
         "The marker type provided ('" + markerType + "') is invalid.");
     return 0;
   }
 
   return node->document()
       .markers()
       .markersFor(node, markerTypes.value())
       .size();
 }
 
 unsigned Internals::activeMarkerCountForNode(Node* node) {
-  ASSERT(node);
+  DCHECK(node);
 
   // Only TextMatch markers can be active.
   DocumentMarker::MarkerType markerType = DocumentMarker::TextMatch;
   DocumentMarkerVector markers =
       node->document().markers().markersFor(node, markerType);
 
   unsigned activeMarkerCount = 0;
   for (const auto& marker : markers) {
     if (marker->activeMatch())
       activeMarkerCount++;
   }
 
   return activeMarkerCount;
 }
 
 DocumentMarker* Internals::markerAt(Node* node,
                                     const String& markerType,
                                     unsigned index,
                                     ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   WTF::Optional<DocumentMarker::MarkerTypes> markerTypes =
       markerTypesFrom(markerType);
   if (!markerTypes) {
     exceptionState.throwDOMException(
         SyntaxError,
         "The marker type provided ('" + markerType + "') is invalid.");
     return 0;
   }
 
   DocumentMarkerVector markers =
       node->document().markers().markersFor(node, markerTypes.value());
   if (markers.size() <= index)
     return 0;
   return markers[index];
 }
 
 Range* Internals::markerRangeForNode(Node* node,
                                      const String& markerType,
                                      unsigned index,
                                      ExceptionState& exceptionState) {
-  ASSERT(node);
+  DCHECK(node);
   DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
   if (!marker)
     return nullptr;
   return Range::create(node->document(), node, marker->startOffset(), node,
                        marker->endOffset());
 }
 
 String Internals::markerDescriptionForNode(Node* node,
                                            const String& markerType,
                                            unsigned index,
                                            ExceptionState& exceptionState) {
   DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
   if (!marker)
     return String();
   return marker->description();
 }
 
 void Internals::addTextMatchMarker(const Range* range, bool isActive) {
-  ASSERT(range);
+  DCHECK(range);
   range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();
   range->ownerDocument().markers().addTextMatchMarker(EphemeralRange(range),
                                                       isActive);
 
   // This simulates what the production code does after
   // DocumentMarkerController::addTextMatchMarker().
   range->ownerDocument().view()->invalidatePaintForTickmarks();
 }
 
 static bool parseColor(const String& value,
@@ skipping 24 matching lines @@
     range->ownerDocument().markers().addCompositionMarker(
         range->startPosition(), range->endPosition(), underlineColor, thick,
         backgroundColor);
   }
 }
 
 void Internals::setMarkersActive(Node* node,
                                  unsigned startOffset,
                                  unsigned endOffset,
                                  bool active) {
-  ASSERT(node);
+  DCHECK(node);
   node->document().markers().setMarkersActive(node, startOffset, endOffset,
                                               active);
 }
 
 void Internals::setMarkedTextMatchesAreHighlighted(Document* document,
                                                    bool highlight) {
   if (!document || !document->frame())
     return;
 
   document->frame()->editor().setMarkedTextMatchesAreHighlighted(highlight);
 }
 
 void Internals::setFrameViewPosition(Document* document,
                                      long x,
                                      long y,
                                      ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return;
   }
 
   FrameView* frameView = document->view();
   bool scrollbarsSuppressedOldValue = frameView->scrollbarsSuppressed();
 
   frameView->setScrollbarsSuppressed(false);
   frameView->updateScrollOffsetFromInternals(IntSize(x, y));
   frameView->setScrollbarsSuppressed(scrollbarsSuppressedOldValue);
 }
 
 String Internals::viewportAsText(Document* document,
                                  float,
                                  int availableWidth,
                                  int availableHeight,
                                  ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->page()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return String();
   }
 
   document->updateStyleAndLayoutIgnorePendingStylesheets();
 
   Page* page = document->page();
 
@@ skipping 25 matching lines @@
   builder.append(String::number(constraints.maximumScale));
 
   builder.append("] and userScalable ");
   builder.append(description.userZoom ? "true" : "false");
 
   return builder.toString();
 }
 
 bool Internals::elementShouldAutoComplete(Element* element,
                                           ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (isHTMLInputElement(*element))
     return toHTMLInputElement(*element).shouldAutocomplete();
 
   exceptionState.throwDOMException(InvalidNodeTypeError,
                                    "The element provided is not an INPUT.");
   return false;
 }
 
 String Internals::suggestedValue(Element* element,
                                  ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (!element->isFormControlElement()) {
     exceptionState.throwDOMException(
         InvalidNodeTypeError,
         "The element provided is not a form control element.");
     return String();
   }
 
   String suggestedValue;
   if (isHTMLInputElement(*element))
     suggestedValue = toHTMLInputElement(*element).suggestedValue();
 
   if (isHTMLTextAreaElement(*element))
     suggestedValue = toHTMLTextAreaElement(*element).suggestedValue();
 
   if (isHTMLSelectElement(*element))
     suggestedValue = toHTMLSelectElement(*element).suggestedValue();
 
   return suggestedValue;
 }
 
 void Internals::setSuggestedValue(Element* element,
                                   const String& value,
                                   ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (!element->isFormControlElement()) {
     exceptionState.throwDOMException(
         InvalidNodeTypeError,
         "The element provided is not a form control element.");
     return;
   }
 
   if (isHTMLInputElement(*element))
     toHTMLInputElement(*element).setSuggestedValue(value);
 
   if (isHTMLTextAreaElement(*element))
     toHTMLTextAreaElement(*element).setSuggestedValue(value);
 
   if (isHTMLSelectElement(*element))
     toHTMLSelectElement(*element).setSuggestedValue(value);
 }
 
 void Internals::setEditingValue(Element* element,
                                 const String& value,
                                 ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (!isHTMLInputElement(*element)) {
     exceptionState.throwDOMException(InvalidNodeTypeError,
                                      "The element provided is not an INPUT.");
     return;
   }
 
   toHTMLInputElement(*element).setEditingValue(value);
 }
 
 void Internals::setAutofilled(Element* element,
                               bool enabled,
                               ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (!element->isFormControlElement()) {
     exceptionState.throwDOMException(
         InvalidNodeTypeError,
         "The element provided is not a form control element.");
     return;
   }
   toHTMLFormControlElement(element)->setAutofilled(enabled);
 }
 
 Range* Internals::rangeFromLocationAndLength(Element* scope,
                                              int rangeLocation,
                                              int rangeLength) {
-  ASSERT(scope);
+  DCHECK(scope);
 
   // TextIterator depends on Layout information, make sure layout it up to date.
   scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return createRange(PlainTextRange(rangeLocation, rangeLocation + rangeLength)
                          .createRange(*scope));
 }
 
 unsigned Internals::locationFromRange(Element* scope, const Range* range) {
-  ASSERT(scope && range);
+  DCHECK(scope && range);
   // PlainTextRange depends on Layout information, make sure layout it up to
   // date.
   scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return PlainTextRange::create(*scope, *range).start();
 }
 
 unsigned Internals::lengthFromRange(Element* scope, const Range* range) {
-  ASSERT(scope && range);
+  DCHECK(scope && range);
   // PlainTextRange depends on Layout information, make sure layout it up to
   // date.
   scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return PlainTextRange::create(*scope, *range).length();
 }
 
 String Internals::rangeAsText(const Range* range) {
-  ASSERT(range);
+  DCHECK(range);
   // Clean layout is required by plain text extraction.
   range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return range->text();
 }
 
 // FIXME: The next four functions are very similar - combine them once
 // bestClickableNode/bestContextMenuNode have been combined..
 
 DOMPoint* Internals::touchPositionAdjustedToBestClickableNode(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return 0;
   }
 
   document->updateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.width(), y + radius.height());
@@ skipping 16 matching lines @@
   return 0;
 }
 
 Node* Internals::touchNodeAdjustedToBestClickableNode(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return 0;
   }
 
   document->updateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.width(), y + radius.height());
@@ skipping 12 matching lines @@
   return targetNode;
 }
 
 DOMPoint* Internals::touchPositionAdjustedToBestContextMenuNode(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return 0;
   }
 
   document->updateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.width(), y + radius.height());
@@ skipping 16 matching lines @@
   return DOMPoint::create(x, y);
 }
 
 Node* Internals::touchNodeAdjustedToBestContextMenuNode(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return 0;
   }
 
   document->updateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.width(), y + radius.height());
@@ skipping 12 matching lines @@
   return targetNode;
 }
 
 ClientRect* Internals::bestZoomableAreaForTouchPoint(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return nullptr;
   }
 
   document->updateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.width(), y + radius.height());
@@ skipping 44 matching lines @@
 // Optimally, the bindings generator would pass a Vector<AtomicString> here but
 // this is not supported yet.
 void Internals::setUserPreferredLanguages(const Vector<String>& languages) {
   Vector<AtomicString> atomicLanguages;
   for (size_t i = 0; i < languages.size(); ++i)
     atomicLanguages.append(AtomicString(languages[i]));
   overrideUserPreferredLanguages(atomicLanguages);
 }
 
 unsigned Internals::activeDOMObjectCount(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return document->activeDOMObjectCount();
 }
 
 static unsigned eventHandlerCount(
     Document& document,
     EventHandlerRegistry::EventHandlerClass handlerClass) {
   if (!document.frameHost())
     return 0;
   EventHandlerRegistry* registry =
       &document.frameHost()->eventHandlerRegistry();
   unsigned count = 0;
   const EventTargetSet* targets = registry->eventHandlerTargets(handlerClass);
   if (targets) {
     for (const auto& target : *targets)
       count += target.value;
   }
   return count;
 }
 
 unsigned Internals::wheelEventHandlerCount(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return eventHandlerCount(*document, EventHandlerRegistry::WheelEventBlocking);
 }
 
 unsigned Internals::scrollEventHandlerCount(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return eventHandlerCount(*document, EventHandlerRegistry::ScrollEvent);
 }
 
 unsigned Internals::touchStartOrMoveEventHandlerCount(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return eventHandlerCount(
              *document, EventHandlerRegistry::TouchStartOrMoveEventBlocking) +
          eventHandlerCount(*document,
                            EventHandlerRegistry::TouchStartOrMoveEventPassive);
 }
 
 unsigned Internals::touchEndOrCancelEventHandlerCount(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return eventHandlerCount(
              *document, EventHandlerRegistry::TouchEndOrCancelEventBlocking) +
          eventHandlerCount(*document,
                            EventHandlerRegistry::TouchEndOrCancelEventPassive);
 }
 
 static PaintLayer* findLayerForGraphicsLayer(PaintLayer* searchRoot,
                                              GraphicsLayer* graphicsLayer,
                                              IntSize* layerOffset,
                                              String* layerType) {
@@ skipping 166 matching lines @@
   }
 
   size_t numChildren = graphicsLayer->children().size();
   for (size_t i = 0; i < numChildren; ++i)
     accumulateLayerRectList(compositor, graphicsLayer->children()[i], rects);
 }
 
 LayerRectList* Internals::touchEventTargetLayerRects(
     Document* document,
     ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view() || !document->page() || document != m_document) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return nullptr;
   }
 
   if (ScrollingCoordinator* scrollingCoordinator =
           document->page()->scrollingCoordinator())
     scrollingCoordinator->updateAfterCompositingChangeIfNeeded();
 
   LayoutViewItem view = document->layoutViewItem();
   if (!view.isNull()) {
     if (PaintLayerCompositor* compositor = view.compositor()) {
       if (GraphicsLayer* rootLayer = compositor->rootGraphicsLayer()) {
         LayerRectList* rects = LayerRectList::create();
         accumulateLayerRectList(compositor, rootLayer, rects);
         return rects;
       }
     }
   }
 
   return nullptr;
 }
 
 bool Internals::executeCommand(Document* document,
                                const String& name,
                                const String& value,
                                ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return false;
   }
 
   LocalFrame* frame = document->frame();
   return frame->editor().executeCommand(name, value);
 }
 
@@ skipping 26 matching lines @@
 StaticNodeList* Internals::nodesFromRect(Document* document,
                                          int centerX,
                                          int centerY,
                                          unsigned topPadding,
                                          unsigned rightPadding,
                                          unsigned bottomPadding,
                                          unsigned leftPadding,
                                          bool ignoreClipping,
                                          bool allowChildFrameContent,
                                          ExceptionState& exceptionState) const {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame() || !document->frame()->view()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         "No view can be obtained from the provided document.");
     return nullptr;
   }
 
   LocalFrame* frame = document->frame();
   FrameView* frameView = document->view();
   LayoutViewItem layoutViewItem = document->layoutViewItem();
@@ skipping 78 matching lines @@
 bool Internals::canHyphenate(const AtomicString& locale) {
   return LayoutLocale::valueOrDefault(LayoutLocale::get(locale))
       .getHyphenation();
 }
 
 void Internals::setMockHyphenation(const AtomicString& locale) {
   LayoutLocale::setHyphenationForTesting(locale, adoptRef(new MockHyphenation));
 }
 
 bool Internals::isOverwriteModeEnabled(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame())
     return false;
 
   return document->frame()->editor().isOverwriteModeEnabled();
 }
 
 void Internals::toggleOverwriteModeEnabled(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame())
     return;
 
   document->frame()->editor().toggleOverwriteModeEnabled();
 }
 
 unsigned Internals::numberOfLiveNodes() const {
   return InstanceCounters::counterValue(InstanceCounters::NodeCounter);
 }
 
@@ skipping 15 matching lines @@
         "No frame can be obtained from the provided document.");
     return false;
   }
 
   document->updateStyleAndLayoutIgnorePendingStylesheets();
   return document->frame()->spellChecker().selectionStartHasMarkerFor(
       DocumentMarker::Grammar, from, length);
 }
 
 unsigned Internals::numberOfScrollableAreas(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame())
     return 0;
 
   unsigned count = 0;
   LocalFrame* frame = document->frame();
   if (frame->view()->scrollableAreas())
     count += frame->view()->scrollableAreas()->size();
 
   for (Frame* child = frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
     if (child->isLocalFrame() && toLocalFrame(child)->view() &&
         toLocalFrame(child)->view()->scrollableAreas())
       count += toLocalFrame(child)->view()->scrollableAreas()->size();
   }
 
   return count;
 }
 
 bool Internals::isPageBoxVisible(Document* document, int pageNumber) {
-  ASSERT(document);
+  DCHECK(document);
   return document->isPageBoxVisible(pageNumber);
 }
 
 String Internals::layerTreeAsText(Document* document,
                                   ExceptionState& exceptionState) const {
   return layerTreeAsText(document, 0, exceptionState);
 }
 
 String Internals::elementLayerTreeAsText(Element* element,
                                          ExceptionState& exceptionState) const {
-  ASSERT(element);
+  DCHECK(element);
   FrameView* frameView = element->document().view();
   frameView->updateAllLifecyclePhases();
 
   return elementLayerTreeAsText(element, 0, exceptionState);
 }
 
 bool Internals::scrollsWithRespectTo(Element* element1,
                                      Element* element2,
                                      ExceptionState& exceptionState) {
-  ASSERT(element1 && element2);
+  DCHECK(element1 && element2);
   element1->document().view()->updateAllLifecyclePhases();
 
   LayoutObject* layoutObject1 = element1->layoutObject();
   LayoutObject* layoutObject2 = element2->layoutObject();
   if (!layoutObject1 || !layoutObject1->isBox()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         layoutObject1
             ? "The first provided element's layoutObject is not a box."
             : "The first provided element has no layoutObject.");
@@ skipping 18 matching lines @@
             layer1 ? "second" : "first"));
     return false;
   }
 
   return layer1->scrollsWithRespectTo(layer2);
 }
 
 String Internals::layerTreeAsText(Document* document,
                                   unsigned flags,
                                   ExceptionState& exceptionState) const {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return String();
   }
 
   document->view()->updateAllLifecyclePhases();
 
   return document->frame()->layerTreeAsText(flags);
 }
 
 String Internals::elementLayerTreeAsText(Element* element,
                                          unsigned flags,
                                          ExceptionState& exceptionState) const {
-  ASSERT(element);
+  DCHECK(element);
   element->document().updateStyleAndLayout();
 
   LayoutObject* layoutObject = element->layoutObject();
   if (!layoutObject || !layoutObject->isBox()) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         layoutObject ? "The provided element's layoutObject is not a box."
                      : "The provided element has no layoutObject.");
     return String();
   }
 
   PaintLayer* layer = toLayoutBox(layoutObject)->layer();
   if (!layer || !layer->hasCompositedLayerMapping() ||
       !layer->compositedLayerMapping()->mainGraphicsLayer()) {
     // Don't raise exception in these cases which may be normally used in tests.
     return String();
   }
 
   return layer->compositedLayerMapping()->mainGraphicsLayer()->layerTreeAsText(
       flags);
 }
 
 String Internals::scrollingStateTreeAsText(Document*) const {
   return String();
 }
 
 String Internals::mainThreadScrollingReasons(
     Document* document,
     ExceptionState& exceptionState) const {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return String();
   }
 
   document->frame()->view()->updateAllLifecyclePhases();
 
   Page* page = document->page();
   if (!page)
     return String();
 
   return page->mainThreadScrollingReasonsAsText();
 }
 
 ClientRectList* Internals::nonFastScrollableRects(
     Document* document,
     ExceptionState& exceptionState) const {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->frame()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return nullptr;
   }
 
   Page* page = document->page();
   if (!page)
     return nullptr;
 
@@ skipping 135 matching lines @@
   if (!frame())
     return false;
 
   return frame()->host()->visualViewport().magnifyScaleAroundAnchor(
       scaleFactor, FloatPoint(x, y));
 }
 
 void Internals::setIsCursorVisible(Document* document,
                                    bool isVisible,
                                    ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->page()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "No context document can be obtained.");
     return;
   }
   document->page()->setIsCursorVisible(isVisible);
 }
 
 String Internals::effectivePreload(HTMLMediaElement* mediaElement) {
-  ASSERT(mediaElement);
+  DCHECK(mediaElement);
   return mediaElement->effectivePreload();
 }
 
 void Internals::mediaPlayerRemoteRouteAvailabilityChanged(
     HTMLMediaElement* mediaElement,
     bool available) {
-  ASSERT(mediaElement);
+  DCHECK(mediaElement);
   mediaElement->remoteRouteAvailabilityChanged(
       available ? WebRemotePlaybackAvailability::DeviceAvailable
                 : WebRemotePlaybackAvailability::SourceNotSupported);
 }
 
 void Internals::mediaPlayerPlayingRemotelyChanged(
     HTMLMediaElement* mediaElement,
     bool remote) {
-  ASSERT(mediaElement);
+  DCHECK(mediaElement);
   if (remote)
     mediaElement->connectedToRemoteDevice();
   else
     mediaElement->disconnectedFromRemoteDevice();
 }
 
 void Internals::registerURLSchemeAsBypassingContentSecurityPolicy(
     const String& scheme) {
   SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(scheme);
 }
@@ skipping 38 matching lines @@
   return CallbackFunctionTest::create();
 }
 
 Vector<String> Internals::getReferencedFilePaths() const {
   if (!frame())
     return Vector<String>();
 
   return frame()->loader().currentItem()->getReferencedFilePaths();
 }
 
+void Internals::startStoringCompositedLayerDebugInfo(
+    Document* document,
+    ExceptionState& exceptionState) {
+  DCHECK(document);
+  if (!document->view()) {
+    exceptionState.throwDOMException(InvalidAccessError,
+                                     "The document provided is invalid.");
+    return;
+  }
+
+  FrameView* frameView = document->view();
+  frameView->setIsStoringCompositedLayerDebugInfo(true);
+  frameView->updateAllLifecyclePhases();
+}
+
+void Internals::stopStoringCompositedLayerDebugInfo(
+    Document* document,
+    ExceptionState& exceptionState) {
+  DCHECK(document);
+  if (!document->view()) {
+    exceptionState.throwDOMException(InvalidAccessError,
+                                     "The document provided is invalid.");
+    return;
+  }
+
+  FrameView* frameView = document->view();
+  frameView->setIsStoringCompositedLayerDebugInfo(false);
+  frameView->updateAllLifecyclePhases();
+}
+
 void Internals::startTrackingRepaints(Document* document,
                                       ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return;
   }
 
   FrameView* frameView = document->view();
   frameView->updateAllLifecyclePhases();
   frameView->setTracksPaintInvalidations(true);
 }
 
 void Internals::stopTrackingRepaints(Document* document,
                                      ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return;
   }
 
   FrameView* frameView = document->view();
   frameView->updateAllLifecyclePhases();
   frameView->setTracksPaintInvalidations(false);
 }
@@ skipping 14 matching lines @@
     exceptionState.throwTypeError(
         "The node provided is neither a document nor an IFrame.");
     return;
   }
   document->updateStyleAndLayoutIgnorePendingStylesheets(
       Document::RunPostLayoutTasksSynchronously);
 }
 
 void Internals::forceFullRepaint(Document* document,
                                  ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return;
   }
 
   LayoutViewItem layoutViewItem = document->layoutViewItem();
   if (!layoutViewItem.isNull())
     layoutViewItem.invalidatePaintForViewAndCompositedLayers();
 }
 
 ClientRectList* Internals::draggableRegions(Document* document,
                                             ExceptionState& exceptionState) {
   return annotatedRegions(document, true, exceptionState);
 }
 
 ClientRectList* Internals::nonDraggableRegions(Document* document,
                                                ExceptionState& exceptionState) {
   return annotatedRegions(document, false, exceptionState);
 }
 
 ClientRectList* Internals::annotatedRegions(Document* document,
                                             bool draggable,
                                             ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (!document->view()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return ClientRectList::create();
   }
 
   document->updateStyleAndLayout();
   document->view()->updateDocumentAnnotatedRegions();
   Vector<AnnotatedRegionValue> regions = document->annotatedRegions();
 
@@ skipping 166 matching lines @@
   if (!frame()) {
     exceptionState.throwDOMException(
         InvalidAccessError, "The document's frame cannot be retrieved.");
     return nullptr;
   }
 
   return ClientRect::create(FloatRect(frame()->selection().bounds()));
 }
 
 String Internals::markerTextForListItem(Element* element) {
-  ASSERT(element);
+  DCHECK(element);
   return blink::markerTextForListItem(element);
 }
 
 String Internals::getImageSourceURL(Element* element) {
-  ASSERT(element);
+  DCHECK(element);
   return element->imageSourceURL();
 }
 
 String Internals::selectMenuListText(HTMLSelectElement* select) {
-  ASSERT(select);
+  DCHECK(select);
   LayoutObject* layoutObject = select->layoutObject();
   if (!layoutObject || !layoutObject->isMenuList())
     return String();
 
   LayoutMenuListItem menuListItem =
       LayoutMenuListItem(toLayoutMenuList(layoutObject));
   return menuListItem.text();
 }
 
 bool Internals::isSelectPopupVisible(Node* node) {
-  ASSERT(node);
+  DCHECK(node);
   if (!isHTMLSelectElement(*node))
     return false;
   return toHTMLSelectElement(*node).popupIsVisible();
 }
 
 bool Internals::selectPopupItemStyleIsRtl(Node* node, int itemIndex) {
   if (!node || !isHTMLSelectElement(*node))
     return false;
 
   HTMLSelectElement& select = toHTMLSelectElement(*node);
@@ skipping 18 matching lines @@
 
   if (itemStyle) {
     const SimpleFontData* fontData = itemStyle->font().primaryFont();
     DCHECK(fontData);
     return fontData ? fontData->getFontMetrics().height() : 0;
   }
   return 0;
 }
 
 void Internals::resetTypeAheadSession(HTMLSelectElement* select) {
-  ASSERT(select);
+  DCHECK(select);
   select->resetTypeAheadSessionForTesting();
 }
 
 bool Internals::loseSharedGraphicsContext3D() {
   std::unique_ptr<WebGraphicsContext3DProvider> sharedProvider =
       WTF::wrapUnique(Platform::current()
                           ->createSharedOffscreenGraphicsContext3DProvider());
   if (!sharedProvider)
     return false;
   gpu::gles2::GLES2Interface* sharedGL = sharedProvider->contextGL();
   sharedGL->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_EXT,
                                 GL_INNOCENT_CONTEXT_RESET_EXT);
   // To prevent tests that call loseSharedGraphicsContext3D from being
   // flaky, we call finish so that the context is guaranteed to be lost
   // synchronously (i.e. before returning).
   sharedGL->Finish();
   return true;
 }
 
 void Internals::forceCompositingUpdate(Document* document,
                                        ExceptionState& exceptionState) {
-  ASSERT(document);
+  DCHECK(document);
   if (document->layoutViewItem().isNull()) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The document provided is invalid.");
     return;
   }
 
   document->frame()->view()->updateAllLifecyclePhases();
 }
 
 void Internals::setZoomFactor(float factor) {
   if (!frame())
     return;
 
   frame()->setPageZoomFactor(factor);
 }
 
 void Internals::setShouldRevealPassword(Element* element,
                                         bool reveal,
                                         ExceptionState& exceptionState) {
-  ASSERT(element);
+  DCHECK(element);
   if (!isHTMLInputElement(element)) {
     exceptionState.throwDOMException(InvalidNodeTypeError,
                                      "The element provided is not an INPUT.");
     return;
   }
 
   return toHTMLInputElement(*element).setShouldRevealPassword(reveal);
 }
 
 namespace {
 
 class AddOneFunction : public ScriptFunction {
  public:
   static v8::Local<v8::Function> createFunction(ScriptState* scriptState) {
     AddOneFunction* self = new AddOneFunction(scriptState);
     return self->bindToV8Function();
   }
 
  private:
   explicit AddOneFunction(ScriptState* scriptState)
       : ScriptFunction(scriptState) {}
 
   ScriptValue call(ScriptValue value) override {
     v8::Local<v8::Value> v8Value = value.v8Value();
-    ASSERT(v8Value->IsNumber());
+    DCHECK(v8Value->IsNumber());
     int intValue = v8Value.As<v8::Integer>()->Value();
     return ScriptValue(
         getScriptState(),
         v8::Integer::New(getScriptState()->isolate(), intValue + 1));
   }
 };
 
 }  // namespace
 
 ScriptPromise Internals::createResolvedPromise(ScriptState* scriptState,
@@ skipping 111 matching lines @@
 void Internals::setInitialFocus(bool reverse) {
   if (!frame())
     return;
 
   frame()->document()->clearFocusedElement();
   frame()->page()->focusController().setInitialFocus(
       reverse ? WebFocusTypeBackward : WebFocusTypeForward);
 }
 
 bool Internals::ignoreLayoutWithPendingStylesheets(Document* document) {
-  ASSERT(document);
+  DCHECK(document);
   return document->ignoreLayoutWithPendingStylesheets();
 }
 
 void Internals::setNetworkConnectionInfoOverride(
     bool onLine,
     const String& type,
     double downlinkMaxMbps,
     ExceptionState& exceptionState) {
   WebConnectionType webtype;
   if (type == "cellular2g") {
@@ skipping 171 matching lines @@
 
 double Internals::monotonicTimeToZeroBasedDocumentTime(
     double platformTime,
     ExceptionState& exceptionState) {
   return m_document->loader()->timing().monotonicTimeToZeroBasedDocumentTime(
       platformTime);
 }
 
 void Internals::setMediaElementNetworkState(HTMLMediaElement* mediaElement,
                                             int state) {
-  ASSERT(mediaElement);
-  ASSERT(state >= WebMediaPlayer::NetworkState::NetworkStateEmpty);
-  ASSERT(state <= WebMediaPlayer::NetworkState::NetworkStateDecodeError);
+  DCHECK(mediaElement);
+  DCHECK(state >= WebMediaPlayer::NetworkState::NetworkStateEmpty);
+  DCHECK(state <= WebMediaPlayer::NetworkState::NetworkStateDecodeError);
   mediaElement->setNetworkState(
       static_cast<WebMediaPlayer::NetworkState>(state));
 }
 
 String Internals::getScrollAnimationState(Node* node) const {
   if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
     return scrollableArea->scrollAnimator().runStateAsText();
   return String();
 }
 
@@ skipping 12 matching lines @@
 
 void Internals::crash() {
   CHECK(false) << "Intentional crash";
 }
 
 void Internals::setIsLowEndDevice(bool isLowEndDevice) {
   MemoryCoordinator::setIsLowEndDeviceForTesting(isLowEndDevice);
 }
 
 }  // namespace blink