[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 2189 matching lines @@
 //   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();
     }
   }
 
   if (RuntimeEnabledFeatures::compositorWorkerEnabled() && animating_style &&
       animating_style->HasCompositorProxy()) {
     uint32_t compositor_mutable_properties =
         animating_element->CompositorMutableProperties();
-    element_id = DOMNodeIds::IdForNode(owning_node);
     primary_mutable_properties = (CompositorMutableProperty::kOpacity |
                                   CompositorMutableProperty::kTransform) &
                                  compositor_mutable_properties;
     scroll_mutable_properties = (CompositorMutableProperty::kScrollLeft |
                                  CompositorMutableProperty::kScrollTop) &
                                 compositor_mutable_properties;
   }
 
-  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);
-  }
+  CompositorElementId compositor_element_id =
+      CompositorElementIdFromPaintLayerId(
+          owning_layer_.UniqueId(), CompositorElementIdNamespace::kPrimary);
 
   graphics_layer_->SetElementId(compositor_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 103 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));
-      }
+      scrolling_contents_layer_->SetElementId(
+          CompositorElementIdFromPaintLayerId(
+              owning_layer_.UniqueId(), CompositorElementIdNamespace::kScroll));
 
       scrolling_layer_->AddChild(scrolling_contents_layer_.get());
 
       layer_changed = true;
       if (scrolling_coordinator) {
         scrolling_coordinator->ScrollableAreaScrollLayerDidChange(
             owning_layer_.GetScrollableArea());
         scrolling_coordinator->ScrollableAreasDidChange();
       }
     }
@@ skipping 1235 matching lines @@
   } else if (graphics_layer == decoration_outline_layer_.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink