[SPv1] Always set a CompositorElementId on main graphics layers; use PaintLayer id.

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

 /*
  * Copyright (C) 2009, 2010, 2011 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 2181 matching lines @@
   // Regardless, mark the graphics layer, scrolling layer and scrolling block
   // selection layer (if they exist) as not flattening. Having them flatten
   // causes unclipped render surfaces which cause bugs.
   // http://crbug.com/521768
   if (HasScrollingLayer()) {
     graphics_layer_->SetShouldFlattenTransform(false);
     scrolling_layer_->SetShouldFlattenTransform(false);
   }
 }
 
+struct AnimatingData {
+  Persistent<Node> owning_node = nullptr;

[wkorman, 2017/05/18 21:31:57]

add STACK_ALLOCATED()? seems to be MO.

[chrishtr, 2017/05/18 22:15:31]

Done.

+  Persistent<Element> animating_element = nullptr;
+  const ComputedStyle* animating_style = nullptr;
+};
+
+void GetAnimatingData(PaintLayer& paint_layer, AnimatingData& data) {
+  if (!RuntimeEnabledFeatures::compositorWorkerEnabled())
+    return;
+
+  data.owning_node = paint_layer.GetLayoutObject().GetNode();
+
+  if (!data.owning_node)
+    return;
+
+  Document& document = data.owning_node->GetDocument();
+  Element* scrolling_element = document.ScrollingElementNoLayout();
+  if (data.owning_node->IsElementNode() &&
+      (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() ||
+       data.owning_node != scrolling_element)) {
+    data.animating_element = ToElement(data.owning_node);
+    data.animating_style = paint_layer.GetLayoutObject().Style();
+  } else if (data.owning_node->IsDocumentNode() &&
+             RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    data.owning_node = data.animating_element = scrolling_element;
+    if (scrolling_element && scrolling_element->GetLayoutObject())
+      data.animating_style = scrolling_element->GetLayoutObject()->Style();
+  }
+}
+
 // Some background on when you receive an element id or mutable properties.
 //
 // element id:
 //   If you have a compositor proxy, an animation, or you're a scroller (and
 //   might impl animate).
 //
 // mutable properties:
 //   Only if you have a compositor proxy.
 //
 // The element id for the scroll layers is assigned when they're constructed,
 // since this is unconditional. However, the element id for the primary layer as
 // well as the mutable properties for all layers may change according to the
 // rules above so we update those values here.
 void CompositedLayerMapping::UpdateElementIdAndCompositorMutableProperties() {
-  int element_id = 0;
   uint32_t primary_mutable_properties = CompositorMutableProperty::kNone;
   uint32_t scroll_mutable_properties = CompositorMutableProperty::kNone;
 
-  Node* owning_node = owning_layer_.GetLayoutObject().GetNode();
-  Element* animating_element = nullptr;
-  const ComputedStyle* animating_style = nullptr;
-  if (owning_node) {
-    Document& document = owning_node->GetDocument();
-    Element* scrolling_element = document.ScrollingElementNoLayout();
-    if (owning_node->IsElementNode() &&
-        (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() ||
-         owning_node != scrolling_element)) {
-      animating_element = ToElement(owning_node);
-      animating_style = owning_layer_.GetLayoutObject().Style();
-    } else if (owning_node->IsDocumentNode() &&
-               RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-      owning_node = animating_element = scrolling_element;
-      if (scrolling_element && scrolling_element->GetLayoutObject())
-        animating_style = scrolling_element->GetLayoutObject()->Style();
-    }
-  }
+  AnimatingData data;
+  GetAnimatingData(owning_layer_, data);
 
-  if (RuntimeEnabledFeatures::compositorWorkerEnabled() && animating_style &&
-      animating_style->HasCompositorProxy()) {
+  CompositorElementId element_id;
+  if (data.animating_style && data.animating_style->HasCompositorProxy()) {
+    // Compositor proxy element ids cannot be based on PaintLayers, since
+    // those are not kept alive by script across frames.
+    element_id = CompositorElementIdFromDOMNodeId(
+        DOMNodeIds::IdForNode(data.owning_node),
+        CompositorElementIdNamespace::kPrimaryCompositorProxy);
+
     uint32_t compositor_mutable_properties =
-        animating_element->CompositorMutableProperties();
-    element_id = DOMNodeIds::IdForNode(owning_node);
+        data.animating_element->CompositorMutableProperties();
     primary_mutable_properties = (CompositorMutableProperty::kOpacity |
                                   CompositorMutableProperty::kTransform) &
                                  compositor_mutable_properties;
     scroll_mutable_properties = (CompositorMutableProperty::kScrollLeft |
                                  CompositorMutableProperty::kScrollTop) &
                                 compositor_mutable_properties;
+  } else {
+    element_id = CompositorElementIdFromPaintLayerId(

[wkorman, 2017/05/18 21:31:57]

Perhaps worth adding a comment here re: why we prefer using paint layer ids.
Could mention (1) fragmentation, (2) desire to avoid dom id map overhead.

Or could add the comment to where we define CompositorElementIdFromPaintLayerId
since we have another callsite below. You have the inverse on the dom node id
method definition (noting it should be used only in exceptional situations).

[chrishtr, 2017/05/18 22:15:31]

Done.

+        owning_layer_.UniqueId(), CompositorElementIdNamespace::kPrimary);
   }
 
-  if (animating_style && animating_style->ShouldCompositeForCurrentAnimations())
-    element_id = DOMNodeIds::IdForNode(owning_node);
-
-  CompositorElementId compositor_element_id;
-  if (element_id) {
-    compositor_element_id = CompositorElementIdFromDOMNodeId(
-        element_id, CompositorElementIdNamespace::kPrimary);
-  }
-
-  graphics_layer_->SetElementId(compositor_element_id);
+  graphics_layer_->SetElementId(element_id);
   graphics_layer_->SetCompositorMutableProperties(primary_mutable_properties);
 
   // We always set the elementId for m_scrollingContentsLayer since it can be
   // animated for smooth scrolling, so we don't need to set it conditionally
   // here.
   if (scrolling_contents_layer_.get())
     scrolling_contents_layer_->SetCompositorMutableProperties(
         scroll_mutable_properties);
 }
 
@@ skipping 101 matching lines @@
       // Outer layer which corresponds with the scroll view.
       scrolling_layer_ =
           CreateGraphicsLayer(kCompositingReasonLayerForScrollingContainer);
       scrolling_layer_->SetDrawsContent(false);
       scrolling_layer_->SetMasksToBounds(true);
 
       // Inner layer which renders the content that scrolls.
       scrolling_contents_layer_ =
           CreateGraphicsLayer(kCompositingReasonLayerForScrollingContents);
 
-      if (Node* owning_node = owning_layer_.GetLayoutObject().GetNode()) {
-        scrolling_contents_layer_->SetElementId(
-            CompositorElementIdFromDOMNodeId(
-                DOMNodeIds::IdForNode(owning_node),
-                CompositorElementIdNamespace::kScroll));
+      AnimatingData data;
+      GetAnimatingData(owning_layer_, data);
+
+      CompositorElementId element_id;
+      if (data.animating_style && data.animating_style->HasCompositorProxy()) {
+        element_id = CompositorElementIdFromDOMNodeId(
+            DOMNodeIds::IdForNode(data.owning_node),
+            CompositorElementIdNamespace::kScrollCompositorProxy);
+      } else {
+        element_id = CompositorElementIdFromPaintLayerId(
+            owning_layer_.UniqueId(), CompositorElementIdNamespace::kScroll);
       }
 
+      scrolling_contents_layer_->SetElementId(element_id);
+
       scrolling_layer_->AddChild(scrolling_contents_layer_.get());
 
       layer_changed = true;
       if (scrolling_coordinator) {
         scrolling_coordinator->ScrollableAreaScrollLayerDidChange(
             owning_layer_.GetScrollableArea());
         scrolling_coordinator->ScrollableAreasDidChange();
       }
     }
   } else if (scrolling_layer_) {
@@ skipping 1234 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink