Add a new document lifecycle; CompositingInputsClean

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 166 matching lines @@
   fullscreen_element =
       Fullscreen::CurrentFullScreenElementFrom(*content_document);
   if (!isHTMLVideoElement(fullscreen_element))
     return nullptr;
   LayoutObject* layout_object = fullscreen_element->GetLayoutObject();
   if (!layout_object)
     return nullptr;
   return ToLayoutVideo(layout_object);
 }
 
-void PaintLayerCompositor::UpdateIfNeededRecursive() {
+void PaintLayerCompositor::UpdateIfNeededRecursive(
+    DocumentLifecycle::LifecycleState target_state) {
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Compositing.UpdateTime");
-  UpdateIfNeededRecursiveInternal();
+  UpdateIfNeededRecursiveInternal(target_state);
 }
 
-void PaintLayerCompositor::UpdateIfNeededRecursiveInternal() {
+void PaintLayerCompositor::UpdateIfNeededRecursiveInternal(
+    DocumentLifecycle::LifecycleState target_state) {
+  DCHECK(target_state >= DocumentLifecycle::kCompositingInputsClean);
+
   FrameView* view = layout_view_.GetFrameView();
   if (view->ShouldThrottleRendering())
     return;
 
   for (Frame* child =
            layout_view_.GetFrameView()->GetFrame().Tree().FirstChild();
        child; child = child->Tree().NextSibling()) {
     if (!child->IsLocalFrame())
       continue;
     LocalFrame* local_frame = 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.
     // TODO(bbudge) Remove this check when trusted Pepper plugins are gone.
     if (local_frame->GetDocument()->IsActive() &&
-        !local_frame->ContentLayoutItem().IsNull())
+        !local_frame->ContentLayoutItem().IsNull()) {
       local_frame->ContentLayoutItem()
           .Compositor()
-          ->UpdateIfNeededRecursiveInternal();
+          ->UpdateIfNeededRecursiveInternal(target_state);
+    }
   }
 
   TRACE_EVENT0("blink", "PaintLayerCompositor::updateIfNeededRecursive");
 
   DCHECK(!layout_view_.NeedsLayout());
 
   ScriptForbiddenScope forbid_script;
 
   // FIXME: enableCompositingModeIfNeeded can trigger a
   // CompositingUpdateRebuildTree, which asserts that it's not
   // InCompositingUpdate.
   EnableCompositingModeIfNeeded();
 
   RootLayer()->UpdateDescendantDependentFlags();
 
   layout_view_.CommitPendingSelection();
 
-  Lifecycle().AdvanceTo(DocumentLifecycle::kInCompositingUpdate);
-  UpdateIfNeeded();
-  Lifecycle().AdvanceTo(DocumentLifecycle::kCompositingClean);
+  UpdateIfNeeded(target_state);
+  DCHECK(Lifecycle().GetState() == DocumentLifecycle::kCompositingInputsClean ||
+         Lifecycle().GetState() == DocumentLifecycle::kCompositingClean);
+  if (target_state == DocumentLifecycle::kCompositingInputsClean)
+    return;
 
   Optional<CompositorElementIdSet> composited_element_ids;
   DocumentAnimations::UpdateAnimations(layout_view_.GetDocument(),
                                        DocumentLifecycle::kCompositingClean,
                                        composited_element_ids);
 
   layout_view_.GetFrameView()
       ->GetScrollableArea()
       ->UpdateCompositorScrollAnimations();
   if (const FrameView::ScrollableAreaSet* animating_scrollable_areas =
@@ skipping 122 matching lines @@
 GraphicsLayer* PaintLayerCompositor::ParentForContentLayers() const {
   if (root_content_layer_)
     return root_content_layer_.get();
 
   DCHECK(RuntimeEnabledFeatures::rootLayerScrollingEnabled());
   // Iframe content layers will be connected by the parent frame using
   // attachFrameContentLayersToIframeLayer.
   return IsMainFrame() ? GetVisualViewport().ScrollLayer() : nullptr;
 }
 
-void PaintLayerCompositor::UpdateIfNeeded() {
+void PaintLayerCompositor::UpdateIfNeeded(
+    DocumentLifecycle::LifecycleState target_state) {
+  DCHECK(target_state >= DocumentLifecycle::kCompositingInputsClean);
+
+  Lifecycle().AdvanceTo(DocumentLifecycle::kInCompositingUpdate);
+
   CompositingUpdateType update_type = pending_update_type_;
   pending_update_type_ = kCompositingUpdateNone;
 
   if (!HasAcceleratedCompositing()) {
     UpdateWithoutAcceleratedCompositing(update_type);
+    Lifecycle().AdvanceTo(
+        std::min(DocumentLifecycle::kCompositingClean, target_state));
     return;
   }
 
-  if (update_type == kCompositingUpdateNone)
+  if (update_type == kCompositingUpdateNone) {
+    Lifecycle().AdvanceTo(
+        std::min(DocumentLifecycle::kCompositingClean, target_state));
     return;
+  }
 
   PaintLayer* update_root = RootLayer();
 
   Vector<PaintLayer*> layers_needing_paint_invalidation;
 
   if (update_type >= kCompositingUpdateAfterCompositingInputChange) {
     CompositingInputsUpdater(update_root).Update();
 
 #if DCHECK_IS_ON()
     // FIXME: Move this check to the end of the compositing update.
     CompositingInputsUpdater::AssertNeedsCompositingInputsUpdateBitsCleared(
         update_root);
 #endif
 
+    // In the case where we only want to make compositing inputs clean, we
+    // early-exit here. Because we have not handled the other implications of
+    // |pending_update_type_| > kCompositingUpdateNone, we must restore the
+    // pending update type for a future call.
+    if (target_state == DocumentLifecycle::kCompositingInputsClean) {
+      pending_update_type_ = update_type;
+      Lifecycle().AdvanceTo(DocumentLifecycle::kCompositingInputsClean);
+      return;
+    }
+
     CompositingRequirementsUpdater(layout_view_, compositing_reason_finder_)
         .Update(update_root);
 
     CompositingLayerAssigner layer_assigner(this);
     layer_assigner.Assign(update_root, layers_needing_paint_invalidation);
 
     bool layers_changed = layer_assigner.LayersChanged();
 
     {
       TRACE_EVENT0("blink",
                    "PaintLayerCompositor::updateAfterCompositingChange");
       if (const FrameView::ScrollableAreaSet* scrollable_areas =
               layout_view_.GetFrameView()->ScrollableAreas()) {
         for (ScrollableArea* scrollable_area : *scrollable_areas)
           layers_changed |= scrollable_area->UpdateAfterCompositingChange();
       }
     }
 
     if (layers_changed) {
       update_type = std::max(update_type, kCompositingUpdateRebuildTree);
       if (ScrollingCoordinator* scrolling_coordinator =
               this->GetScrollingCoordinator())
         scrolling_coordinator->NotifyGeometryChanged();
     }
   }
 
+  // If we hit this check then we were asked to only make compositing inputs
+  // clean but they were already clean. Therefore the correct behavior is to
+  // just restore the pending state and exit.
+  if (target_state == DocumentLifecycle::kCompositingInputsClean) {

[flackr, 2017/04/12 15:50:15]

I think this early exit would be cleaner at the top of the function before we
replace the pending_update_type_, i.e. if update_type <
kCompositingUpdateAfterCompositingInputChange.

[smcgruer, 2017/04/12 17:18:44]

Done.

+    pending_update_type_ = update_type;
+    Lifecycle().AdvanceTo(DocumentLifecycle::kCompositingInputsClean);
+    return;
+  }
+
   if (RuntimeEnabledFeatures::compositorWorkerEnabled() && scroll_layer_) {
     // If rootLayerScrolls is enabled, these properties are applied in
     // CompositedLayerMapping::updateElementIdAndCompositorMutableProperties.
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       if (Element* scrolling_element =
               layout_view_.GetDocument().scrollingElement()) {
         uint32_t mutable_properties = CompositorMutableProperty::kNone;
         if (scrolling_element->HasCompositorProxy()) {
           mutable_properties = (CompositorMutableProperty::kScrollLeft |
                                 CompositorMutableProperty::kScrollTop) &
@@ skipping 46 matching lines @@
     if (Page* page = layout_view_.GetFrame()->GetPage()) {
       page->GetChromeClient().AttachRootGraphicsLayer(RootGraphicsLayer(),
                                                       layout_view_.GetFrame());
       root_layer_attachment_ = kRootLayerAttachedViaChromeClient;
     }
   }
 
   // Inform the inspector that the layer tree has changed.
   if (IsMainFrame())
     probe::layerTreeDidChange(layout_view_.GetFrame());
+
+  Lifecycle().AdvanceTo(DocumentLifecycle::kCompositingClean);
 }
 
 static void RestartAnimationOnCompositor(const LayoutObject& layout_object) {
   Node* node = layout_object.GetNode();
   ElementAnimations* element_animations =
       (node && node->IsElementNode()) ? ToElement(node)->GetElementAnimations()
                                       : nullptr;
   if (element_animations)
     element_animations->RestartAnimationOnCompositor();
 }
@@ skipping 832 matching lines @@
   } else if (graphics_layer == scroll_layer_.get()) {
     name = "Frame Scrolling Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink