reflow comments in core/layout/compositing,core/observer

third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 112 matching lines @@
 
 void PaintLayerCompositor::enableCompositingModeIfNeeded() {
   if (!m_rootShouldAlwaysCompositeDirty)
     return;
 
   m_rootShouldAlwaysCompositeDirty = false;
   if (m_compositing)
     return;
 
   if (rootShouldAlwaysComposite()) {
-    // FIXME: Is this needed? It was added in https://bugs.webkit.org/show_bug.cgi?id=26651.
+    // FIXME: Is this needed? It was added in
+    // https://bugs.webkit.org/show_bug.cgi?id=26651.
     // No tests fail if it's deleted.
     setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
     setCompositingModeEnabled(true);
   }
 }
 
 bool PaintLayerCompositor::rootShouldAlwaysComposite() const {
   if (!m_hasAcceleratedCompositing)
     return false;
   return m_layoutView.frame()->isLocalRoot() ||
@@ skipping 33 matching lines @@
       Fullscreen::currentFullScreenElementFrom(*contentDocument);
   if (!isHTMLVideoElement(fullscreenElement))
     return nullptr;
   LayoutObject* layoutObject = fullscreenElement->layoutObject();
   if (!layoutObject)
     return nullptr;
   return toLayoutVideo(layoutObject);
 }
 
 // The descendant-dependent flags system is badly broken because we clean dirty
-// bits in upward tree walks, which means we need to call updateDescendantDependentFlags
-// at every node in the tree to fully clean all the dirty bits. While we'll in
-// the process of fixing this issue, updateDescendantDependentFlagsForEntireSubtree
-// provides a big hammer for actually cleaning all the dirty bits in a subtree.
+// bits in upward tree walks, which means we need to call
+// updateDescendantDependentFlags at every node in the tree to fully clean all
+// the dirty bits. While we'll in the process of fixing this issue,
+// updateDescendantDependentFlagsForEntireSubtree provides a big hammer for
+// actually cleaning all the dirty bits in a subtree.
 //
 // FIXME: Remove this function once the descendant-dependent flags system keeps
 // its dirty bits scoped to subtrees.
 void updateDescendantDependentFlagsForEntireSubtree(PaintLayer& layer) {
   layer.updateDescendantDependentFlags();
 
   for (PaintLayer* child = layer.firstChild(); child;
        child = child->nextSibling())
     updateDescendantDependentFlagsForEntireSubtree(*child);
 }
 
 void PaintLayerCompositor::updateIfNeededRecursive() {
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Compositing.UpdateTime");
   updateIfNeededRecursiveInternal();
 }
 
 void PaintLayerCompositor::updateIfNeededRecursiveInternal() {
   FrameView* view = m_layoutView.frameView();
   if (view->shouldThrottleRendering())
     return;
 
   for (Frame* child = m_layoutView.frameView()->frame().tree().firstChild();
        child; child = child->tree().nextSibling()) {
     if (!child->isLocalFrame())
       continue;
     LocalFrame* localFrame = toLocalFrame(child);
-    // It's possible for trusted Pepper plugins to force hit testing in situations where
-    // the frame tree is in an inconsistent state, such as in the middle of frame detach.
+    // It's possible for trusted Pepper plugins to force hit testing in
+    // situations where the frame tree is in an inconsistent state, such as in
+    // the middle of frame detach.
     // TODO(bbudge) Remove this check when trusted Pepper plugins are gone.
     if (localFrame->document()->isActive() &&
         !localFrame->contentLayoutItem().isNull())
       localFrame->contentLayoutItem()
           .compositor()
           ->updateIfNeededRecursiveInternal();
   }
 
   TRACE_EVENT0("blink", "PaintLayerCompositor::updateIfNeededRecursive");
 
   ASSERT(!m_layoutView.needsLayout());
 
   ScriptForbiddenScope forbidScript;
 
-  // FIXME: enableCompositingModeIfNeeded can trigger a CompositingUpdateRebuildTree,
-  // which asserts that it's not InCompositingUpdate.
+  // FIXME: enableCompositingModeIfNeeded can trigger a
+  // CompositingUpdateRebuildTree, which asserts that it's not
+  // InCompositingUpdate.
   enableCompositingModeIfNeeded();
 
   if (m_needsUpdateDescendantDependentFlags) {
     updateDescendantDependentFlagsForEntireSubtree(*rootLayer());
     m_needsUpdateDescendantDependentFlags = false;
   }
 
   m_layoutView.commitPendingSelection();
 
   lifecycle().advanceTo(DocumentLifecycle::InCompositingUpdate);
@@ skipping 70 matching lines @@
       GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer();
       if (backgroundLayer && !backgroundLayer->parent())
         rootFixedBackgroundsChanged();
     }
     return;
   }
 
   GraphicsLayer* videoLayer =
       video->layer()->compositedLayerMapping()->mainGraphicsLayer();
 
-  // The fullscreen video has layer position equal to its enclosing frame's scroll position because fullscreen container is fixed-positioned.
-  // We should reset layer position here since we are going to reattach the layer at the very top level.
+  // The fullscreen video has layer position equal to its enclosing frame's
+  // scroll position because fullscreen container is fixed-positioned.
+  // We should reset layer position here since we are going to reattach the
+  // layer at the very top level.
   videoLayer->setPosition(IntPoint());
 
-  // Only steal fullscreen video layer and clear all other layers if we are the main frame.
+  // Only steal fullscreen video layer and clear all other layers if we are the
+  // main frame.
   if (!isLocalRoot)
     return;
 
   m_rootContentLayer->removeAllChildren();
   m_overflowControlsHostLayer->addChild(videoLayer);
   if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
     backgroundLayer->removeFromParent();
   m_inOverlayFullscreenVideo = true;
 }
 
 void PaintLayerCompositor::updateWithoutAcceleratedCompositing(
     CompositingUpdateType updateType) {
   ASSERT(!hasAcceleratedCompositing());
 
   if (updateType >= CompositingUpdateAfterCompositingInputChange)
     CompositingInputsUpdater(rootLayer()).update();
 
 #if ENABLE(ASSERT)
   CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(
       rootLayer());
 #endif
 }
 
 static void
 forceRecomputePaintInvalidationRectsIncludingNonCompositingDescendants(
     LayoutObject* layoutObject) {
-  // We clear the previous paint invalidation rect as it's wrong (paint invalidation container
-  // changed, ...). Forcing a full invalidation will make us recompute it. Also we are not
-  // changing the previous position from our paint invalidation container, which is fine as
-  // we want a full paint invalidation anyway.
+  // We clear the previous paint invalidation rect as it's wrong (paint
+  // invalidation container changed, ...). Forcing a full invalidation will make
+  // us recompute it. Also we are not changing the previous position from our
+  // paint invalidation container, which is fine as we want a full paint
+  // invalidation anyway.
   layoutObject->clearPreviousPaintInvalidationRects();
 
   for (LayoutObject* child = layoutObject->slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isPaintInvalidationContainer())
       forceRecomputePaintInvalidationRectsIncludingNonCompositingDescendants(
           child);
   }
 }
 
@@ skipping 148 matching lines @@
   if (elementAnimations)
     elementAnimations->restartAnimationOnCompositor();
 }
 
 bool PaintLayerCompositor::allocateOrClearCompositedLayerMapping(
     PaintLayer* layer,
     const CompositingStateTransitionType compositedLayerUpdate) {
   bool compositedLayerMappingChanged = false;
 
   // FIXME: It would be nice to directly use the layer's compositing reason,
-  // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
-  // requirements fully.
+  // but allocateOrClearCompositedLayerMapping also gets called without having
+  // updated compositing requirements fully.
   switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
       ASSERT(!layer->hasCompositedLayerMapping());
       setCompositingModeEnabled(true);
 
-      // If we need to issue paint invalidations, do so before allocating the compositedLayerMapping and clearing out the groupedMapping.
+      // If we need to issue paint invalidations, do so before allocating the
+      // compositedLayerMapping and clearing out the groupedMapping.
       paintInvalidationOnCompositingChange(layer);
 
-      // If this layer was previously squashed, we need to remove its reference to a groupedMapping right away, so
-      // that computing paint invalidation rects will know the layer's correct compositingState.
-      // FIXME: do we need to also remove the layer from it's location in the squashing list of its groupedMapping?
-      // Need to create a test where a squashed layer pops into compositing. And also to cover all other
-      // sorts of compositingState transitions.
+      // If this layer was previously squashed, we need to remove its reference
+      // to a groupedMapping right away, so that computing paint invalidation
+      // rects will know the layer's correct compositingState.
+      // FIXME: do we need to also remove the layer from it's location in the
+      // squashing list of its groupedMapping?  Need to create a test where a
+      // squashed layer pops into compositing. And also to cover all other sorts
+      // of compositingState transitions.
       layer->setLostGroupedMapping(false);
       layer->setGroupedMapping(nullptr,
                                PaintLayer::InvalidateLayerAndRemoveFromMapping);
 
       layer->ensureCompositedLayerMapping();
       compositedLayerMappingChanged = true;
 
       restartAnimationOnCompositor(*layer->layoutObject());
 
-      // At this time, the ScrollingCoordinator only supports the top-level frame.
+      // At this time, the ScrollingCoordinator only supports the top-level
+      // frame.
       if (layer->isRootLayer() && m_layoutView.frame()->isLocalRoot()) {
         if (ScrollingCoordinator* scrollingCoordinator =
                 this->scrollingCoordinator())
           scrollingCoordinator->frameViewRootLayerDidChange(
               m_layoutView.frameView());
       }
       break;
     case RemoveOwnCompositedLayerMapping:
-    // PutInSquashingLayer means you might have to remove the composited layer mapping first.
+    // PutInSquashingLayer means you might have to remove the composited layer
+    // mapping first.
     case PutInSquashingLayer:
       if (layer->hasCompositedLayerMapping()) {
         layer->clearCompositedLayerMapping();
         compositedLayerMappingChanged = true;
       }
 
       break;
     case RemoveFromSquashingLayer:
     case NoCompositingStateChange:
       // Do nothing.
       break;
   }
 
   if (compositedLayerMappingChanged && layer->layoutObject()->isLayoutPart()) {
     PaintLayerCompositor* innerCompositor =
         frameContentsCompositor(toLayoutPart(layer->layoutObject()));
     if (innerCompositor && innerCompositor->staleInCompositingMode())
       innerCompositor->updateRootLayerAttachment();
   }
 
   if (compositedLayerMappingChanged)
     layer->clipper().clearClipRectsIncludingDescendants(PaintingClipRects);
 
-  // If a fixed position layer gained/lost a compositedLayerMapping or the reason not compositing it changed,
-  // the scrolling coordinator needs to recalculate whether it can do fast scrolling.
+  // If a fixed position layer gained/lost a compositedLayerMapping or the
+  // reason not compositing it changed, the scrolling coordinator needs to
+  // recalculate whether it can do fast scrolling.
   if (compositedLayerMappingChanged) {
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->frameViewFixedObjectsDidChange(
           m_layoutView.frameView());
   }
 
   return compositedLayerMappingChanged;
 }
 
 void PaintLayerCompositor::paintInvalidationOnCompositingChange(
     PaintLayer* layer) {
-  // If the layoutObject is not attached yet, no need to issue paint invalidations.
+  // If the layoutObject is not attached yet, no need to issue paint
+  // invalidations.
   if (layer->layoutObject() != &m_layoutView &&
       !layer->layoutObject()->parent())
     return;
 
   // For querying Layer::compositingState()
-  // Eager invalidation here is correct, since we are invalidating with respect to the previous frame's
-  // compositing state when changing the compositing backing of the layer.
+  // Eager invalidation here is correct, since we are invalidating with respect
+  // to the previous frame's compositing state when changing the compositing
+  // backing of the layer.
   DisableCompositingQueryAsserts disabler;
-  // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
+  // FIXME: We should not allow paint invalidation out of paint invalidation
+  // state. crbug.com/457415
   DisablePaintInvalidationStateAsserts paintInvalidationAssertisabler;
 
   ObjectPaintInvalidator(*layer->layoutObject())
       .invalidatePaintIncludingNonCompositingDescendants();
 }
 
 void PaintLayerCompositor::frameViewDidChangeLocation(
     const IntPoint& contentsOffset) {
   if (m_overflowControlsHostLayer)
     m_overflowControlsHostLayer->setPosition(contentsOffset);
@@ skipping 59 matching lines @@
   // stay put, we position it in the layer tree as follows:
   //
   // + Overflow controls host
   //   + LocalFrame clip
   //     + (Fixed root background) <-- Here.
   //     + LocalFrame scroll
   //       + Root content layer
   //   + Scrollbars
   //
   // That is, it needs to be the first child of the frame clip, the sibling of
-  // the frame scroll layer. The compositor does not own the background layer, it
-  // just positions it (like the foreground layer).
+  // the frame scroll layer. The compositor does not own the background layer,
+  // it just positions it (like the foreground layer).
   if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
     m_containerLayer->addChildBelow(backgroundLayer, m_scrollLayer.get());
 }
 
 bool PaintLayerCompositor::scrollingLayerDidChange(PaintLayer* layer) {
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     return scrollingCoordinator->scrollableAreaScrollLayerDidChange(
         layer->getScrollableArea());
   return false;
 }
@@ skipping 135 matching lines @@
           layer->layoutObject()));
 }
 
 void PaintLayerCompositor::updateDirectCompositingReasons(PaintLayer* layer) {
   layer->setCompositingReasons(m_compositingReasonFinder.directReasons(layer),
                                CompositingReasonComboAllDirectReasons);
 }
 
 bool PaintLayerCompositor::canBeComposited(const PaintLayer* layer) const {
   FrameView* frameView = layer->layoutObject()->frameView();
-  // Elements within an invisible frame must not be composited because they are not drawn.
+  // Elements within an invisible frame must not be composited because they are
+  // not drawn.
   if (frameView && !frameView->isVisible())
     return false;
 
   const bool hasCompositorAnimation =
       m_compositingReasonFinder.requiresCompositingForAnimation(
           *layer->layoutObject()->style());
   return m_hasAcceleratedCompositing &&
          (hasCompositorAnimation || !layer->subtreeIsInvisible()) &&
          layer->isSelfPaintingLayer() &&
          !layer->layoutObject()->isLayoutFlowThread();
 }
 
-// Return true if the given layer is a stacking context and has compositing child
-// layers that it needs to clip. In this case we insert a clipping GraphicsLayer
-// into the hierarchy between this layer and its children in the z-order hierarchy.
+// Return true if the given layer is a stacking context and has compositing
+// child layers that it needs to clip. In this case we insert a clipping
+// GraphicsLayer into the hierarchy between this layer and its children in the
+// z-order hierarchy.
 bool PaintLayerCompositor::clipsCompositingDescendants(
     const PaintLayer* layer) const {
   return layer->hasCompositingDescendant() &&
          layer->layoutObject()->hasClipRelatedProperty();
 }
 
-// If an element has composited negative z-index children, those children paint in front of the
-// layer background, so we need an extra 'contents' layer for the foreground of the layer
-// object.
+// If an element has composited negative z-index children, those children paint
+// in front of the layer background, so we need an extra 'contents' layer for
+// the foreground of the layer object.
 bool PaintLayerCompositor::needsContentsCompositingLayer(
     const PaintLayer* layer) const {
   if (!layer->hasCompositingDescendant())
     return false;
   return layer->stackingNode()->hasNegativeZOrderList();
 }
 
 static void paintScrollbar(const GraphicsLayer* graphicsLayer,
                            const Scrollbar* scrollbar,
                            GraphicsContext& context,
                            const IntRect& clip) {
-  // Frame scrollbars are painted in the space of the containing frame, not the local space of the scrollbar.
+  // Frame scrollbars are painted in the space of the containing frame, not the
+  // local space of the scrollbar.
   const IntPoint& paintOffset = scrollbar->frameRect().location();
   IntRect transformedClip = clip;
   transformedClip.moveBy(paintOffset);
 
   AffineTransform translation;
   translation.translate(-paintOffset.x(), -paintOffset.y());
   TransformRecorder transformRecorder(context, *scrollbar, translation);
   scrollbar->paint(context, CullRect(transformedClip));
 }
 
 IntRect PaintLayerCompositor::computeInterestRect(
     const GraphicsLayer* graphicsLayer,
     const IntRect&) const {
   return enclosingIntRect(FloatRect(FloatPoint(), graphicsLayer->size()));
 }
 
 void PaintLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer,
                                          GraphicsContext& context,
                                          GraphicsLayerPaintingPhase,
                                          const IntRect& interestRect) const {
-  // Note the composited scrollable area painted below is always associated with a frame. For
-  // painting non-frame ScrollableAreas, see CompositedLayerMapping::paintScrollableArea.
+  // Note the composited scrollable area painted below is always associated with
+  // a frame. For painting non-frame ScrollableAreas, see
+  // CompositedLayerMapping::paintScrollableArea.
 
   const Scrollbar* scrollbar = graphicsLayerToScrollbar(graphicsLayer);
   if (!scrollbar && graphicsLayer != layerForScrollCorner())
     return;
 
   if (DrawingRecorder::useCachedDrawingIfPossible(
           context, *graphicsLayer, DisplayItem::kScrollbarCompositedScrollbar))
     return;
 
   FloatRect layerBounds(FloatPoint(), graphicsLayer->size());
   SkPictureBuilder pictureBuilder(layerBounds, nullptr, &context);
 
   if (scrollbar)
     paintScrollbar(graphicsLayer, scrollbar, pictureBuilder.context(),
                    interestRect);
   else
     FramePainter(*m_layoutView.frameView())
         .paintScrollCorner(pictureBuilder.context(), interestRect);
 
-  // Replay the painted scrollbar content with the GraphicsLayer backing as the DisplayItemClient
-  // in order for the resulting DrawingDisplayItem to produce the correct visualRect (i.e., the
-  // bounds of the involved GraphicsLayer).
+  // Replay the painted scrollbar content with the GraphicsLayer backing as the
+  // DisplayItemClient in order for the resulting DrawingDisplayItem to produce
+  // the correct visualRect (i.e., the bounds of the involved GraphicsLayer).
   DrawingRecorder drawingRecorder(context, *graphicsLayer,
                                   DisplayItem::kScrollbarCompositedScrollbar,
                                   layerBounds);
   pictureBuilder.endRecording()->playback(context.canvas());
 }
 
 Scrollbar* PaintLayerCompositor::graphicsLayerToScrollbar(
     const GraphicsLayer* graphicsLayer) const {
   if (graphicsLayer == layerForHorizontalScrollbar()) {
     return m_layoutView.frameView()->horizontalScrollbar();
@@ skipping 13 matching lines @@
 bool PaintLayerCompositor::needsFixedRootBackgroundLayer(
     const PaintLayer* layer) const {
   if (layer != m_layoutView.layer())
     return false;
 
   return supportsFixedRootBackgroundCompositing() &&
          m_layoutView.rootBackgroundIsEntirelyFixed();
 }
 
 GraphicsLayer* PaintLayerCompositor::fixedRootBackgroundLayer() const {
-  // Get the fixed root background from the LayoutView layer's compositedLayerMapping.
+  // Get the fixed root background from the LayoutView layer's
+  // compositedLayerMapping.
   PaintLayer* viewLayer = m_layoutView.layer();
   if (!viewLayer)
     return nullptr;
 
   if (viewLayer->compositingState() == PaintsIntoOwnBacking &&
       viewLayer->compositedLayerMapping()
           ->backgroundLayerPaintsFixedRootBackground())
     return viewLayer->compositedLayerMapping()->backgroundLayer();
 
   return nullptr;
@@ skipping 46 matching lines @@
 bool PaintLayerCompositor::requiresVerticalScrollbarLayer() const {
   return m_layoutView.frameView()->verticalScrollbar();
 }
 
 bool PaintLayerCompositor::requiresScrollCornerLayer() const {
   return m_layoutView.frameView()->isScrollCornerVisible();
 }
 
 void PaintLayerCompositor::updateOverflowControlsLayers() {
   GraphicsLayer* controlsParent = m_overflowControlsHostLayer.get();
-  // Main frame scrollbars should always be stuck to the sides of the screen (in overscroll and in pinch-zoom), so
-  // make the parent for the scrollbars be the viewport container layer.
+  // Main frame scrollbars should always be stuck to the sides of the screen (in
+  // overscroll and in pinch-zoom), so make the parent for the scrollbars be the
+  // viewport container layer.
   if (m_layoutView.frame()->isMainFrame()) {
     VisualViewport& visualViewport =
         m_layoutView.frameView()->page()->frameHost().visualViewport();
     controlsParent = visualViewport.containerLayer();
   }
 
   if (requiresHorizontalScrollbarLayer()) {
     if (!m_layerForHorizontalScrollbar) {
       m_layerForHorizontalScrollbar = GraphicsLayer::create(this);
     }
@@ skipping 168 matching lines @@
       Page* page = frame.page();
       if (!page)
         return;
       page->chromeClient().attachRootGraphicsLayer(rootGraphicsLayer(), &frame);
       break;
     }
     case RootLayerAttachedViaEnclosingFrame: {
       HTMLFrameOwnerElement* ownerElement =
           m_layoutView.document().localOwner();
       ASSERT(ownerElement);
-      // The layer will get hooked up via CompositedLayerMapping::updateGraphicsLayerConfiguration()
-      // for the frame's layoutObject in the parent document.
+      // The layer will get hooked up via
+      // CompositedLayerMapping::updateGraphicsLayerConfiguration() for the
+      // frame's layoutObject in the parent document.
       ownerElement->setNeedsCompositingUpdate();
       break;
     }
   }
 
   m_rootLayerAttachment = attachment;
 }
 
 void PaintLayerCompositor::detachRootLayer() {
   if (!m_rootContentLayer || m_rootLayerAttachment == RootLayerUnattached)
     return;
 
   switch (m_rootLayerAttachment) {
     case RootLayerAttachedViaEnclosingFrame: {
-      // The layer will get unhooked up via CompositedLayerMapping::updateGraphicsLayerConfiguration()
-      // for the frame's layoutObject in the parent document.
+      // The layer will get unhooked up via
+      // CompositedLayerMapping::updateGraphicsLayerConfiguration() for the
+      // frame's layoutObject in the parent document.
       if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->removeFromParent();
       else
         m_rootContentLayer->removeFromParent();
 
       if (HTMLFrameOwnerElement* ownerElement =
               m_layoutView.document().localOwner())
         ownerElement->setNeedsCompositingUpdate();
       break;
     }
@@ skipping 77 matching lines @@
   } else if (graphicsLayer == m_scrollLayer.get()) {
     name = "Frame Scrolling Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink