[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 {
+  STACK_ALLOCATED()
+  Persistent<Node> owning_node = nullptr;
+  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(
+        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