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();
 
+  // TODO(smcgruer): This function should be refactored, but for now just place
+  // this here to make the target behavioral change clear.
+  if (target_state == DocumentLifecycle::kCompositingInputsClean) {
+    // Restore the update type.
+    pending_update_type_ = update_type;
+    if (pending_update_type_ >= kCompositingUpdateAfterCompositingInputChange) {
+      CompositingInputsUpdater(update_root).Update();
+    }
+    Lifecycle().AdvanceTo(DocumentLifecycle::kCompositingInputsClean);
+    return;
+  }
+
   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(

[flackr, 2017/04/11 20:46:28]

We should have this assert for CompositingInputsClean. In fact, if compositing
inputs are dirty the pending update type should be at least
kCompositingUpdateAfterCompositingInputChange (which seems to be the case in
UpdateWithoutAcceleratedCompositing) in which case you can use this code to
update the inputs and have the early exit here.

[smcgruer, 2017/04/12 15:33:04]

Done.

         update_root);
 #endif
 
     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();
@@ skipping 75 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