Enable compositing for opaque scrolling content on low DPI screens

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 152 matching lines @@
     , m_frameTimingRequestsDirty(true)
     , m_viewportIntersectionValid(false)
     , m_hiddenForThrottling(false)
     , m_crossOriginForThrottling(false)
     , m_subtreeThrottled(false)
     , m_currentUpdateLifecyclePhasesTargetState(DocumentLifecycle::Uninitialized)
     , m_needsScrollbarsUpdate(false)
     , m_suppressAdjustViewSize(false)
     , m_allowsLayoutInvalidationAfterLayoutClean(true)
 {
-    ASSERT(m_frame);
+    DCHECK(m_frame);
     init();
 }
 
 FrameView* FrameView::create(LocalFrame* frame)
 {
     FrameView* view = new FrameView(frame);
     view->show();
     return view;
 }
 
 FrameView* FrameView::create(LocalFrame* frame, const IntSize& initialSize)
 {
     FrameView* view = new FrameView(frame);
     view->Widget::setFrameRect(IntRect(view->location(), initialSize));
     view->setLayoutSizeInternal(initialSize);
 
     view->show();
     return view;
 }
 
 FrameView::~FrameView()
 {
-    ASSERT(m_hasBeenDisposed);
+#if ENABLE(ASSERT)
+    DCHECK(m_hasBeenDisposed);
+#endif
 }
 
 DEFINE_TRACE(FrameView)
 {
     visitor->trace(m_frame);
     visitor->trace(m_fragmentAnchor);
     visitor->trace(m_scrollableAreas);
     visitor->trace(m_animatingScrollableAreas);
     visitor->trace(m_autoSizeInfo);
     visitor->trace(m_horizontalScrollbar);
@@ skipping 52 matching lines @@
 
     m_size = LayoutSize();
 
     // Propagate the marginwidth/height and scrolling modes to the view.
     if (m_frame->owner() && m_frame->owner()->scrollingMode() == ScrollbarAlwaysOff)
         setCanHaveScrollbars(false);
 }
 
 void FrameView::dispose()
 {
-    RELEASE_ASSERT(!isInPerformLayout());
+    CHECK(!isInPerformLayout());
 
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->cancelAnimation();
     cancelProgrammaticScrollAnimation();
 
     detachScrollbars();
 
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->willDestroyScrollableArea(this);
 
@@ skipping 251 matching lines @@
 
 void FrameView::adjustViewSize()
 {
     if (m_suppressAdjustViewSize)
         return;
 
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (layoutViewItem.isNull())
         return;
 
-    ASSERT(m_frame->view() == this);
+    DCHECK(m_frame->view() == this);
 
     const IntRect rect = layoutViewItem.documentRect();
     const IntSize& size = rect.size();
 
     const IntPoint origin(-rect.x(), -rect.y());
     if (scrollOrigin() != origin) {
         ScrollableArea::setScrollOrigin(origin);
         // setContentSize (below) also calls updateScrollbars so we can avoid
         // updating scrollbars twice by skipping the call here when the content
         // size does not change.
@@ skipping 78 matching lines @@
 
 void FrameView::updateAcceleratedCompositingSettings()
 {
     if (LayoutViewItem layoutViewItem = this->layoutViewItem())
         layoutViewItem.compositor()->updateAcceleratedCompositingSettings();
 }
 
 void FrameView::recalcOverflowAfterStyleChange()
 {
     LayoutViewItem layoutViewItem = this->layoutViewItem();
-    RELEASE_ASSERT(!layoutViewItem.isNull());
+    CHECK(!layoutViewItem.isNull());
     if (!layoutViewItem.needsOverflowRecalcAfterStyleChange())
         return;
 
     layoutViewItem.recalcOverflowAfterStyleChange();
 
     // Changing overflow should notify scrolling coordinator to ensures that it
     // updates non-fast scroll rects even if there is no layout.
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->notifyOverflowUpdated();
 
@@ skipping 27 matching lines @@
 
     if (scrollOriginChanged())
         setNeedsLayout();
 }
 
 bool FrameView::usesCompositedScrolling() const
 {
     LayoutViewItem layoutView = this->layoutViewItem();
     if (layoutView.isNull())
         return false;
-    if (m_frame->settings() && m_frame->settings()->preferCompositingToLCDTextEnabled())
+    if (layoutView.layer()->needsCompositedScrolling())

[chrishtr, 2016/07/27 19:26:00]

I don't think this will work, because the view is special and doesn't have
overflow clipping.

[Stephen Chennney, 2016/07/28 13:55:38]

Done.

         return layoutView.compositor()->inCompositingMode();
     return false;
 }
 
 bool FrameView::shouldScrollOnMainThread() const
 {
     if (ScrollingCoordinator* sc = scrollingCoordinator()) {
         if (sc->shouldUpdateScrollLayerPositionOnMainThread())
             return true;
     }
@@ skipping 72 matching lines @@
     // bothering to lay out the SVG document, mark the ownerLayoutObject needing layout and ask its
     // FrameView for a layout. After that the LayoutEmbeddedObject (ownerLayoutObject) carries the
     // correct size, which LayoutSVGRoot::computeReplacedLogicalWidth/Height rely on, when laying
     // out for the first time, or when the LayoutSVGRoot size has changed dynamically (eg. via <script>).
     FrameView* frameView = ownerLayoutObject->frame()->view();
 
     // Mark the owner layoutObject as needing layout.
     ownerLayoutObject->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::Unknown);
 
     // Synchronously enter layout, to layout the view containing the host object/embed/iframe.
-    ASSERT(frameView);
+    DCHECK(frameView);
     frameView->layout();
 }
 
 void FrameView::performPreLayoutTasks()
 {
     TRACE_EVENT0("blink,benchmark", "FrameView::performPreLayoutTasks");
     lifecycle().advanceTo(DocumentLifecycle::InPreLayout);
 
     // Don't schedule more layouts, we're in one.
     AutoReset<bool> changeSchedulingEnabled(&m_layoutSchedulingEnabled, false);
@@ skipping 73 matching lines @@
     value->setInteger("contentsHeightAfterLayout", layoutViewItem().documentRect().height());
     value->setInteger("visibleHeight", visibleHeight());
     value->setInteger("approximateBlankCharacterCount", FontFaceSet::approximateBlankCharacterCount(*m_frame->document()));
     return value;
 }
 
 #define PERFORM_LAYOUT_TRACE_CATEGORIES "blink,benchmark," TRACE_DISABLED_BY_DEFAULT("blink.debug.layout")
 
 void FrameView::performLayout(bool inSubtreeLayout)
 {
-    ASSERT(inSubtreeLayout || m_layoutSubtreeRootList.isEmpty());
+    DCHECK(inSubtreeLayout || m_layoutSubtreeRootList.isEmpty());
 
     TRACE_EVENT_BEGIN1(PERFORM_LAYOUT_TRACE_CATEGORIES, "FrameView::performLayout",
         "contentsHeightBeforeLayout", layoutViewItem().documentRect().height());
     prepareLayoutAnalyzer();
 
     ScriptForbiddenScope forbidScript;
 
-    ASSERT(!isInPerformLayout());
+    DCHECK(!isInPerformLayout());
     lifecycle().advanceTo(DocumentLifecycle::InPerformLayout);
 
     // performLayout is the actual guts of layout().
     // FIXME: The 300 other lines in layout() probably belong in other helper functions
     // so that a single human could understand what layout() is actually doing.
 
     forceLayoutParentViewIfNeeded();
 
     if (hasOrthogonalWritingModeRoots())
         layoutOrthogonalWritingModeRoots();
@@ skipping 44 matching lines @@
         // we call it through the timer here.
         m_postLayoutTasksTimer.startOneShot(0, BLINK_FROM_HERE);
         if (needsLayout())
             layout();
     }
 }
 
 void FrameView::layout()
 {
     // We should never layout a Document which is not in a LocalFrame.
-    ASSERT(m_frame);
-    ASSERT(m_frame->view() == this);
-    ASSERT(m_frame->page());
+    DCHECK(m_frame);
+    DCHECK(m_frame->view() == this);
+    DCHECK(m_frame->page());
 
     ScriptForbiddenScope forbidScript;
 
     if (isInPerformLayout() || shouldThrottleRendering() || !m_frame->document()->isActive())
         return;
 
     TRACE_EVENT0("blink,benchmark", "FrameView::layout");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "Layout");
 
     if (m_autoSizeInfo)
@@ skipping 93 matching lines @@
         }
 
         TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink.debug.layout.trees"), "LayoutTree",
             this, TracedLayoutObject::create(*layoutView(), false));
 
         performLayout(inSubtreeLayout);
 
         if (!inSubtreeLayout && !document->printing())
             adjustViewSizeAndLayout();
 
-        ASSERT(m_layoutSubtreeRootList.isEmpty());
+        DCHECK(m_layoutSubtreeRootList.isEmpty());
     } // Reset m_layoutSchedulingEnabled to its previous value.
     checkDoesNotNeedLayout();
 
     m_frameTimingRequestsDirty = true;
 
     // FIXME: Could find the common ancestor layer of all dirty subtrees and mark from there. crbug.com/462719
     layoutViewItem().enclosingLayer()->updateLayerPositionsAfterLayout();
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink.debug.layout.trees"), "LayoutTree",
         this, TracedLayoutObject::create(*layoutView(), true));
@@ skipping 32 matching lines @@
 
 void FrameView::invalidateTreeIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
     if (shouldThrottleRendering())
         return;
 
     lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
 
-    RELEASE_ASSERT(!layoutViewItem().isNull());
+    CHECK(!layoutViewItem().isNull());
     LayoutViewItem rootForPaintInvalidation = layoutViewItem();
-    ASSERT(!rootForPaintInvalidation.needsLayout());
+    DCHECK(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
 
     rootForPaintInvalidation.invalidateTreeIfNeeded(paintInvalidationState);
     invalidatePaintIfNeeded(paintInvalidationState);
 
 #if ENABLE(ASSERT)
     layoutView()->assertSubtreeClearedPaintInvalidationFlags();
 #endif
 
     lifecycle().advanceTo(DocumentLifecycle::PaintInvalidationClean);
 }
 
 void FrameView::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
-    RELEASE_ASSERT(!layoutViewItem().isNull());
+    CHECK(!layoutViewItem().isNull());
     if (!m_frame->settings() || !m_frame->settings()->rootLayerScrolls())
         invalidatePaintOfScrollControlsIfNeeded(paintInvalidationState);
 
     if (m_frame->selection().isCaretBoundsDirty())
         m_frame->selection().invalidateCaretRect();
 
     // Temporary callback for crbug.com/487345,402044
     // TODO(ojan): Make this more general to be used by PositionObserver
     // and rAF throttling.
     IntRect visibleRect = rootFrameToContents(computeVisibleArea());
@@ skipping 104 matching lines @@
                     frameView->checkDoesNotNeedLayout();
             } else {
                 part->updateWidgetGeometry();
             }
         }
     }
 }
 
 void FrameView::addPartToUpdate(LayoutEmbeddedObject& object)
 {
-    ASSERT(isInPerformLayout());
+    DCHECK(isInPerformLayout());
     // Tell the DOM element that it needs a widget update.
     Node* node = object.node();
-    ASSERT(node);
+    DCHECK(node);
     if (isHTMLObjectElement(*node) || isHTMLEmbedElement(*node))
         toHTMLPlugInElement(node)->setNeedsWidgetUpdate(true);
 
     m_partUpdateSet.add(&object);
 }
 
 void FrameView::setDisplayMode(WebDisplayMode mode)
 {
     if (mode == m_displayMode)
         return;
 
     m_displayMode = mode;
 
     if (m_frame->document())
         m_frame->document()->mediaQueryAffectingValueChanged();
 }
 
 void FrameView::setMediaType(const AtomicString& mediaType)
 {
-    ASSERT(m_frame->document());
+    DCHECK(m_frame->document());
     m_frame->document()->mediaQueryAffectingValueChanged();
     m_mediaType = mediaType;
 }
 
 AtomicString FrameView::mediaType() const
 {
     // See if we have an override type.
     if (m_frame->settings() && !m_frame->settings()->mediaTypeOverride().isEmpty())
         return AtomicString(m_frame->settings()->mediaTypeOverride());
     return m_mediaType;
@@ skipping 13 matching lines @@
 }
 
 bool FrameView::contentsInCompositedLayer() const
 {
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     return !layoutViewItem.isNull() && layoutViewItem.compositingState() == PaintsIntoOwnBacking;
 }
 
 void FrameView::addBackgroundAttachmentFixedObject(LayoutObject* object)
 {
-    ASSERT(!m_backgroundAttachmentFixedObjects.contains(object));
+    DCHECK(!m_backgroundAttachmentFixedObjects.contains(object));
 
     m_backgroundAttachmentFixedObjects.add(object);
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->frameViewHasBackgroundAttachmentFixedObjectsDidChange(this);
 }
 
 void FrameView::removeBackgroundAttachmentFixedObject(LayoutObject* object)
 {
-    ASSERT(m_backgroundAttachmentFixedObjects.contains(object));
+    DCHECK(m_backgroundAttachmentFixedObjects.contains(object));
 
     m_backgroundAttachmentFixedObjects.remove(object);
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->frameViewHasBackgroundAttachmentFixedObjectsDidChange(this);
 }
 
 void FrameView::addViewportConstrainedObject(LayoutObject* object)
 {
     if (!m_viewportConstrainedObjects)
         m_viewportConstrainedObjects = wrapUnique(new ViewportConstrainedObjectSet);
@@ skipping 76 matching lines @@
     for (const auto& layoutObject : m_backgroundAttachmentFixedObjects)
         layoutObject->setShouldDoFullPaintInvalidation();
 }
 
 bool FrameView::invalidateViewportConstrainedObjects()
 {
     bool fastPathAllowed = true;
     for (const auto& viewportConstrainedObject : *m_viewportConstrainedObjects) {
         LayoutObject* layoutObject = viewportConstrainedObject;
         LayoutItem layoutItem = LayoutItem(layoutObject);
-        ASSERT(layoutItem.style()->hasViewportConstrainedPosition());
-        ASSERT(layoutItem.hasLayer());
+        DCHECK(layoutItem.style()->hasViewportConstrainedPosition());
+        DCHECK(layoutItem.hasLayer());
         PaintLayer* layer = LayoutBoxModel(layoutItem).layer();
 
         if (layer->isPaintInvalidationContainer())
             continue;
 
         if (layer->subtreeIsInvisible())
             continue;
 
         // invalidate even if there is an ancestor with a filter that moves pixels.
         layoutItem.setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
@@ skipping 31 matching lines @@
     InspectorInstrumentation::didUpdateLayout(m_frame.get());
     return true;
 }
 
 void FrameView::scrollContentsSlowPath(const IntRect& updateRect)
 {
     TRACE_EVENT0("blink", "FrameView::scrollContentsSlowPath");
     // We need full invalidation during slow scrolling. For slimming paint, full invalidation
     // of the LayoutView is not enough. We also need to invalidate all of the objects.
     // FIXME: Find out what are enough to invalidate in slow path scrolling. crbug.com/451090#9.
-    ASSERT(!layoutViewItem().isNull());
+    DCHECK(!layoutViewItem().isNull());
     if (contentsInCompositedLayer())
         layoutViewItem().layer()->compositedLayerMapping()->setContentsNeedDisplay();
     else
         layoutViewItem().setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
 
     if (contentsInCompositedLayer()) {
         IntRect updateRect = visibleContentRect();
-        ASSERT(!layoutViewItem().isNull());
+        DCHECK(!layoutViewItem().isNull());
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts disabler;
         layoutViewItem().invalidatePaintRectangle(LayoutRect(updateRect));
     }
     if (LayoutPart* frameLayoutObject = m_frame->ownerLayoutObject()) {
         if (isEnclosedInCompositingLayer()) {
             LayoutRect rect(frameLayoutObject->borderLeft() + frameLayoutObject->paddingLeft(),
                 frameLayoutObject->borderTop() + frameLayoutObject->paddingTop(),
                 LayoutUnit(visibleWidth()), LayoutUnit(visibleHeight()));
             // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
@@ skipping 27 matching lines @@
         return;
 
     // Try again after decoding the ref, based on the document's encoding.
     if (m_frame->document()->encoding().isValid())
         processUrlFragmentHelper(decodeURLEscapeSequences(fragmentIdentifier, m_frame->document()->encoding()), behavior);
 
 }
 
 bool FrameView::processUrlFragmentHelper(const String& name, UrlFragmentBehavior behavior)
 {
-    ASSERT(m_frame->document());
+    DCHECK(m_frame->document());
 
     if (behavior == UrlFragmentScroll && !m_frame->document()->isRenderingReady()) {
         m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(true);
         return false;
     }
 
     m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(false);
 
     Element* anchorNode = m_frame->document()->findAnchor(name);
 
@@ skipping 27 matching lines @@
             if (behavior == UrlFragmentScroll)
                 m_frame->document()->setSequentialFocusNavigationStartingPoint(anchorNode);
             m_frame->document()->clearFocusedElement();
         }
     }
     return true;
 }
 
 void FrameView::setFragmentAnchor(Node* anchorNode)
 {
-    ASSERT(anchorNode);
+    DCHECK(anchorNode);
     m_fragmentAnchor = anchorNode;
 
     // We need to update the layout tree before scrolling.
     m_frame->document()->updateStyleAndLayoutTree();
 
     // If layout is needed, we will scroll in performPostLayoutTasks. Otherwise, scroll immediately.
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull() && layoutViewItem.needsLayout())
         layout();
     else
@@ skipping 41 matching lines @@
     }
 }
 
 IntSize FrameView::layoutSize(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(m_layoutSize) : m_layoutSize;
 }
 
 void FrameView::setLayoutSize(const IntSize& size)
 {
-    ASSERT(!layoutSizeFixedToFrameSize());
+    DCHECK(!layoutSizeFixedToFrameSize());
 
     setLayoutSizeInternal(size);
 }
 
 void FrameView::didScrollTimerFired(Timer<FrameView>*)
 {
     if (m_frame->document() && !m_frame->document()->layoutViewItem().isNull())
         m_frame->document()->fetcher()->updateAllImageResourcePriorities();
 }
 
@@ skipping 65 matching lines @@
 }
 
 void FrameView::updateCompositedSelectionIfNeeded()
 {
     if (!RuntimeEnabledFeatures::compositedSelectionUpdateEnabled())
         return;
 
     TRACE_EVENT0("blink", "FrameView::updateCompositedSelectionIfNeeded");
 
     Page* page = frame().page();
-    ASSERT(page);
+    DCHECK(page);
 
     CompositedSelection selection;
     LocalFrame* focusedFrame = page->focusController().focusedFrame();
     LocalFrame* localFrame = (focusedFrame && (focusedFrame->localFrameRoot() == m_frame->localFrameRoot())) ? focusedFrame : nullptr;
     if (!localFrame || !computeCompositedSelection(*localFrame, selection)) {
         page->chromeClient().clearCompositedSelection();
         return;
     }
 
     page->chromeClient().updateCompositedSelection(selection);
@@ skipping 77 matching lines @@
 }
 
 bool FrameView::hasOrthogonalWritingModeRoots() const
 {
     return !m_orthogonalWritingModeRootList.isEmpty();
 }
 
 void FrameView::layoutOrthogonalWritingModeRoots()
 {
     for (auto& root : m_orthogonalWritingModeRootList.ordered()) {
-        ASSERT(root->isBox() && toLayoutBox(*root).isOrthogonalWritingModeRoot());
+        DCHECK(root->isBox() && toLayoutBox(*root).isOrthogonalWritingModeRoot());
         if (!root->needsLayout()
             || root->isOutOfFlowPositioned()
             || root->isColumnSpanAll()
             || !root->styleRef().logicalHeight().isIntrinsicOrAuto()) {
             continue;
         }
         LayoutState layoutState(*root);
         root->layout();
     }
 }
@@ skipping 189 matching lines @@
     // The fragment anchor should only be maintained while the frame is still loading.
     // If the frame is done loading, clear the anchor now. Otherwise, restore it
     // since it may have been cleared during scrollRectToVisible.
     m_fragmentAnchor = m_frame->document()->isLoadCompleted() ? nullptr : anchorNode;
 }
 
 bool FrameView::updateWidgets()
 {
     // This is always called from updateWidgetsTimerFired.
     // m_updateWidgetsTimer should only be scheduled if we have widgets to update.
-    // Thus I believe we can stop checking isEmpty here, and just ASSERT isEmpty:
+    // Thus I believe we can stop checking isEmpty here, and just DCHECK isEmpty:
     // FIXME: This assert has been temporarily removed due to https://crbug.com/430344
     if (m_nestedLayoutCount > 1 || m_partUpdateSet.isEmpty())
         return true;
 
     // Need to swap because script will run inside the below loop and invalidate the iterator.
     EmbeddedObjectSet objects;
     objects.swap(m_partUpdateSet);
 
     for (const auto& embeddedObject : objects) {
         LayoutEmbeddedObject& object = *embeddedObject;
@@ skipping 15 matching lines @@
         // Prevent plugins from causing infinite updates of themselves.
         // FIXME: Do we really need to prevent this?
         m_partUpdateSet.remove(&object);
     }
 
     return m_partUpdateSet.isEmpty();
 }
 
 void FrameView::updateWidgetsTimerFired(Timer<FrameView>*)
 {
-    ASSERT(!isInPerformLayout());
+    DCHECK(!isInPerformLayout());
     m_updateWidgetsTimer.stop();
     for (unsigned i = 0; i < maxUpdateWidgetsIterations; ++i) {
         if (updateWidgets())
             return;
     }
 }
 
 void FrameView::flushAnyPendingPostLayoutTasks()
 {
-    ASSERT(!isInPerformLayout());
+    DCHECK(!isInPerformLayout());
     if (m_postLayoutTasksTimer.isActive())
         performPostLayoutTasks();
     if (m_updateWidgetsTimer.isActive())
         updateWidgetsTimerFired(0);
 }
 
 void FrameView::scheduleUpdateWidgetsIfNecessary()
 {
-    ASSERT(!isInPerformLayout());
+    DCHECK(!isInPerformLayout());
     if (m_updateWidgetsTimer.isActive() || m_partUpdateSet.isEmpty())
         return;
     m_updateWidgetsTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void FrameView::performPostLayoutTasks()
 {
     // FIXME: We can reach here, even when the page is not active!
     // http/tests/inspector/elements/html-link-import.html and many other
     // tests hit that case.
-    // We should ASSERT(isActive()); or at least return early if we can!
-    ASSERT(!isInPerformLayout()); // Always before or after performLayout(), part of the highest-level layout() call.
+    // We should DCHECK(isActive()); or at least return early if we can!
+    DCHECK(!isInPerformLayout()); // Always before or after performLayout(), part of the highest-level layout() call.
     TRACE_EVENT0("blink,benchmark", "FrameView::performPostLayoutTasks");
 
     m_postLayoutTasksTimer.stop();
 
     m_frame->selection().setCaretRectNeedsUpdate();
     m_frame->selection().updateAppearance();
 
-    ASSERT(m_frame->document());
+    DCHECK(m_frame->document());
 
     FontFaceSet::didLayout(*m_frame->document());
     // Cursor update scheduling is done by the local root, which is the main frame if there
     // are no RemoteFrame ancestors in the frame tree. Use of localFrameRoot() is
     // discouraged but will change when cursor update scheduling is moved from EventHandler
     // to PageEventHandler.
     frame().localFrameRoot()->eventHandler().scheduleCursorUpdate();
 
     updateWidgetGeometries();
 
     // Plugins could have torn down the page inside updateWidgetGeometries().
     if (layoutViewItem().isNull())
         return;
 
     scheduleUpdateWidgetsIfNecessary();
 
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->notifyGeometryChanged();
 
     scrollToFragmentAnchor();
     // TODO(skobes): Figure out interactions between scroll anchor, fragment anchor, and history restoration.
     if (shouldPerformScrollAnchoring())
         m_scrollAnchor.restore();
 
     sendResizeEventIfNeeded();
 }
 
 bool FrameView::wasViewportResized()
 {
-    ASSERT(m_frame);
+    DCHECK(m_frame);
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (layoutViewItem.isNull())
         return false;
-    ASSERT(layoutViewItem.style());
+    DCHECK(layoutViewItem.style());
     return (layoutSize(IncludeScrollbars) != m_lastViewportSize || layoutViewItem.style()->zoom() != m_lastZoomFactor);
 }
 
 void FrameView::sendResizeEventIfNeeded()
 {
-    ASSERT(m_frame);
+    DCHECK(m_frame);
 
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (layoutViewItem.isNull() || layoutViewItem.document().printing())
         return;
 
     if (!wasViewportResized())
         return;
 
     m_lastViewportSize = layoutSize(IncludeScrollbars);
     m_lastZoomFactor = layoutViewItem.style()->zoom();
@@ skipping 18 matching lines @@
     for (LayoutObject* layoutObject = view; layoutObject; layoutObject = layoutObject->nextInPreOrder()) {
         if (!layoutObject->isCounter())
             continue;
 
         toLayoutCounter(layoutObject)->updateCounter();
     }
 }
 
 IntRect FrameView::windowClipRect(IncludeScrollbarsInRect scrollbarInclusion) const
 {
-    ASSERT(m_frame->view() == this);
+    DCHECK(m_frame->view() == this);
 
     LayoutRect clipRect(LayoutPoint(), LayoutSize(visibleContentSize(scrollbarInclusion)));
     layoutViewItem().mapToVisualRectInAncestorSpace(&layoutView()->containerForPaintInvalidation(), clipRect);
     return enclosingIntRect(clipRect);
 }
 
 bool FrameView::shouldUseIntegerScrollOffset() const
 {
-    if (m_frame->settings() && !m_frame->settings()->preferCompositingToLCDTextEnabled())
+    LayoutViewItem layoutView = this->layoutViewItem();

[chrishtr, 2016/07/27 19:26:00]

Ditto.

I think you should just write:

 if (m_frame->settings() &&
(!m_frame->settings()->preferCompositingToLCDTextEnabled() ||
RuntimeEnabledFeatures::compositeOpaqueScrollersEnabled()))

[Stephen Chennney, 2016/07/28 13:55:38]

We don't need anything at all. The logic works such that we can only be trying
to use high DPI when the preferCompositingToLCDTextEnabled is false, so the
existing check catches it.

+    if (layoutView.isNull())
+        return false;
+    if (layoutView.layer()->needsCompositedScrolling())
         return true;
 
     return ScrollableArea::shouldUseIntegerScrollOffset();
 }
 
 bool FrameView::isActive() const
 {
     Page* page = frame().page();
     return page && page->focusController().isActive();
 }
@@ skipping 386 matching lines @@
         });
     }
 
     updateViewportIntersectionsForSubtree(targetState);
 }
 
 void FrameView::updatePaintProperties()
 {
     TRACE_EVENT0("blink", "FrameView::updatePaintProperties");
 
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InPrePaint); });
     PrePaintTreeWalk().walk(*this);
     forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::PrePaintClean); });
 }
 
 void FrameView::synchronizedPaint()
 {
     TRACE_EVENT0("blink", "FrameView::synchronizedPaint");
     SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Paint.UpdateTime");
 
-    ASSERT(frame() == page()->mainFrame() || (!frame().tree().parent()->isLocalFrame()));
+    DCHECK(frame() == page()->mainFrame() || (!frame().tree().parent()->isLocalFrame()));
 
     LayoutViewItem view = layoutViewItem();
-    ASSERT(!view.isNull());
+    DCHECK(!view.isNull());
     forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InPaint); });
 
     // A null graphics layer can occur for painting of SVG images that are not parented into the main frame tree,
     // or when the FrameView is the main frame view of a page overlay. The page overlay is in the layer tree of
     // the host page and will be painted during synchronized painting of the host page.
     if (GraphicsLayer* rootGraphicsLayer = view.compositor()->rootGraphicsLayer()) {
         synchronizedPaintRecursively(rootGraphicsLayer);
     }
     if (GraphicsLayer* layerForHorizontalScrollbar = view.compositor()->layerForHorizontalScrollbar()) {
         synchronizedPaintRecursively(layerForHorizontalScrollbar);
@@ skipping 28 matching lines @@
     }
 
     for (auto& child : graphicsLayer->children())
         synchronizedPaintRecursively(child);
 }
 
 void FrameView::pushPaintArtifactToCompositor()
 {
     TRACE_EVENT0("blink", "FrameView::pushPaintArtifactToCompositor");
 
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     LayoutViewItem viewItem = layoutViewItem();
-    ASSERT(!viewItem.isNull());
+    DCHECK(!viewItem.isNull());
 
     // TODO(jbroman): Simplify the path to PaintController.
     PaintLayer* layer = viewItem.layer();
-    ASSERT(layer);
+    DCHECK(layer);
     if (!layer->hasCompositedLayerMapping())
         return;
     GraphicsLayer* rootGraphicsLayer = layer->compositedLayerMapping()->mainGraphicsLayer();
     if (!rootGraphicsLayer->drawsContent())
         return;
     const PaintArtifact& paintArtifact = rootGraphicsLayer->getPaintController().paintArtifact();
 
     Page* page = frame().page();
     if (!page)
         return;
@@ skipping 65 matching lines @@
     // extra style recalc. See PaintLayer::filterNeedsPaintInvalidation().
     if (m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate()) {
         m_frame->document()->updateStyleAndLayoutTree();
 
         if (needsLayout())
             layout();
     }
 
     // These asserts ensure that parent frames are clean, when child frames finished updating layout and style.
     checkDoesNotNeedLayout();
-    ASSERT(!m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate());
+    DCHECK(!m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate());
 #if ENABLE(ASSERT)
     m_frame->document()->layoutView()->assertLaidOut();
 #endif
 
     updateWidgetGeometriesIfNeeded();
 
     if (lifecycle().state() < DocumentLifecycle::LayoutClean)
         lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 
     // Ensure that we become visually non-empty eventually.
@@ skipping 308 matching lines @@
     if (!m_resizerAreas)
         return;
 
     ResizerAreaSet::iterator it = m_resizerAreas->find(&resizerBox);
     if (it != m_resizerAreas->end())
         m_resizerAreas->remove(it);
 }
 
 void FrameView::addScrollableArea(ScrollableArea* scrollableArea)
 {
-    ASSERT(scrollableArea);
+    DCHECK(scrollableArea);
     if (!m_scrollableAreas)
         m_scrollableAreas = new ScrollableAreaSet;
     m_scrollableAreas->add(scrollableArea);
 
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->scrollableAreasDidChange();
 }
 
 void FrameView::removeScrollableArea(ScrollableArea* scrollableArea)
 {
     if (!m_scrollableAreas)
         return;
     m_scrollableAreas->remove(scrollableArea);
 
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         scrollingCoordinator->scrollableAreasDidChange();
 }
 
 void FrameView::addAnimatingScrollableArea(ScrollableArea* scrollableArea)
 {
-    ASSERT(scrollableArea);
+    DCHECK(scrollableArea);
     if (!m_animatingScrollableAreas)
         m_animatingScrollableAreas = new ScrollableAreaSet;
     m_animatingScrollableAreas->add(scrollableArea);
 }
 
 void FrameView::removeAnimatingScrollableArea(ScrollableArea* scrollableArea)
 {
     if (!m_animatingScrollableAreas)
         return;
     m_animatingScrollableAreas->remove(scrollableArea);
@@ skipping 11 matching lines @@
 
     if (m_scrollbarsAvoidingResizer && parent())
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(m_scrollbarsAvoidingResizer);
 
     updateScrollableAreaSet();
     setNeedsUpdateViewportIntersection();
 }
 
 void FrameView::removeChild(Widget* child)
 {
-    ASSERT(child->parent() == this);
+    DCHECK(child->parent() == this);
 
     if (child->isFrameView())
         removeScrollableArea(toFrameView(child));
 
     child->setParent(0);
     m_children.remove(child);
 }
 
 bool FrameView::visualViewportSuppliesScrollbars() const
 {
@@ skipping 50 matching lines @@
     // Make the same calculation as in CC's LayerImpl::MaxScrollOffset()
     // FIXME: We probably shouldn't be storing the bounds in a float. crbug.com/422331.
     IntSize visibleSize = visibleContentSize(ExcludeScrollbars) + topControlsSize();
     IntSize contentBounds = contentsSize();
     IntPoint maximumPosition = -scrollOrigin() + (contentBounds - visibleSize);
     return maximumPosition.expandedTo(minimumScrollPosition());
 }
 
 void FrameView::addChild(Widget* child)
 {
-    ASSERT(child != this && !child->parent());
+    DCHECK(child != this && !child->parent());
     child->setParent(this);
     m_children.add(child);
 }
 
 void FrameView::setHasHorizontalScrollbar(bool hasBar)
 {
     if (hasBar == !!m_horizontalScrollbar)
         return;
 
     if (hasBar) {
@@ skipping 135 matching lines @@
     // ScrollableArea::scrollPositionChanged to only pass clamped offsets.
     DoublePoint newPosition = clampScrollPosition(offset);
 
     DoublePoint oldPosition = m_scrollPosition;
     DoubleSize scrollDelta = newPosition - oldPosition;
     if (scrollDelta.isZero())
         return;
 
     if (m_frame->settings() && m_frame->settings()->rootLayerScrolls()) {
         // Don't scroll the FrameView!
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 
     m_scrollPosition = newPosition;
 
     if (!scrollbarsSuppressed())
         m_pendingScrollDelta += scrollDelta;
 
     clearFragmentAnchor();
     updateLayersAndCompositingAfterScrollIfNeeded(scrollDelta);
 
@@ skipping 154 matching lines @@
     }
     if (overlapsResizer != scrollbar.overlapsResizer()) {
         scrollbar.setOverlapsResizer(overlapsResizer);
         adjustScrollbarsAvoidingResizerCount(overlapsResizer ? 1 : -1);
     }
     return adjustedRect;
 }
 
 bool FrameView::adjustScrollbarExistence(ComputeScrollbarExistenceOption option)
 {
-    ASSERT(m_inUpdateScrollbars);
+    DCHECK(m_inUpdateScrollbars);
 
     // If we came in here with the view already needing a layout, then go ahead and do that
     // first.  (This will be the common case, e.g., when the page changes due to window resizing for example).
     // This layout will not re-enter updateScrollbars and does not count towards our max layout pass total.
     if (!m_scrollbarsSuppressed)
         scrollbarExistenceDidChange();
 
     bool hasHorizontalScrollbar = m_horizontalScrollbar;
     bool hasVerticalScrollbar = m_verticalScrollbar;
 
@@ skipping 580 matching lines @@
 {
     if (!m_needsUpdateViewportIntersection)
         return;
     m_needsUpdateViewportIntersection = false;
     m_viewportIntersectionValid = true;
     FrameView* parent = parentFrameView();
     if (!parent) {
         m_viewportIntersection = frameRect();
         return;
     }
-    ASSERT(!parent->m_needsUpdateViewportIntersection);
+    DCHECK(!parent->m_needsUpdateViewportIntersection);
 
     // If our parent is hidden, then we are too.
     if (parent->m_viewportIntersection.isEmpty()) {
         m_viewportIntersection = parent->m_viewportIntersection;
         return;
     }
 
     // Transform our bounds into the root frame's content coordinate space,
     // making sure we have valid layout data in our parent document. If our
     // parent is throttled, we'll use possible stale layout information and
     // rely on the fact that another lifecycle update will be scheduled once
     // our parent becomes unthrottled.
-    ASSERT(parent->lifecycle().state() >= DocumentLifecycle::LayoutClean || parent->shouldThrottleRendering());
+    DCHECK(parent->lifecycle().state() >= DocumentLifecycle::LayoutClean || parent->shouldThrottleRendering());
     m_viewportIntersection = parent->contentsToRootFrame(frameRect());
 
     // TODO(skyostil): Expand the viewport to make it less likely to see stale content while scrolling.
     IntRect viewport = parent->m_viewportIntersection;
     m_viewportIntersection.intersect(viewport);
 }
 
 void FrameView::updateViewportIntersectionsForSubtree(DocumentLifecycle::LifecycleState targetState)
 {
     bool hadValidIntersection = m_viewportIntersectionValid;
@@ skipping 110 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const
 {
     if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
         return false;
     return m_subtreeThrottled || (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 } // namespace blink