Increment property tree sequence number when updating.

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include "cc/layers/content_layer_client.h"
@@ skipping 44 matching lines @@
 }
 
 template <typename T>
 static std::unique_ptr<JSONArray> sizeAsJSONArray(const T& size) {
   std::unique_ptr<JSONArray> array = JSONArray::create();
   array->pushDouble(size.width());
   array->pushDouble(size.height());
   return array;
 }
 
+// cc property trees make use of a sequence number to identify when tree
+// topology changes. For now we naively increment the sequence number each time
+// we update the property trees. We should explore optimizing our management of
+// the sequence number through the use of a dirty bit or similar. See
+// http://crbug.com/692842#c4.
+static int sPropertyTreeSequenceNumber = 1;
+
 class PaintArtifactCompositor::ContentLayerClientImpl
     : public cc::ContentLayerClient {
   WTF_MAKE_NONCOPYABLE(ContentLayerClientImpl);
   USING_FAST_MALLOC(ContentLayerClientImpl);
 
  public:
   ContentLayerClientImpl(DisplayItem::Id paintChunkId)
       : m_id(paintChunkId),
         m_debugName(paintChunkId.client.debugName()),
         m_ccPictureLayer(cc::PictureLayer::Create(this)) {}
@@ skipping 614 matching lines @@
 
   // The tree will be null after detaching and this update can be ignored.
   // See: WebViewImpl::detachPaintArtifactCompositor().
   if (!layerTreeHost)
     return;
 
   if (m_extraDataForTestingEnabled)
     m_extraDataForTesting = WTF::wrapUnique(new ExtraDataForTesting);
 
   m_rootLayer->RemoveAllChildren();
-  m_rootLayer->set_property_tree_sequence_number(
-      PropertyTreeManager::kPropertyTreeSequenceNumber);
+
+  m_rootLayer->set_property_tree_sequence_number(sPropertyTreeSequenceNumber);
 
   PropertyTreeManager propertyTreeManager(*layerTreeHost->property_trees(),
-                                          m_rootLayer.get());
+                                          m_rootLayer.get(),
+                                          sPropertyTreeSequenceNumber);
 
   Vector<PendingLayer, 0> pendingLayers;
   collectPendingLayers(paintArtifact, pendingLayers, geometryMapper);
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PendingLayer& pendingLayer : pendingLayers) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = compositedLayerForPendingLayer(
         paintArtifact, pendingLayer, layerOffset, newContentLayerClients,
         rasterChunkInvalidations, storeDebugInfo, geometryMapper);
 
     const auto* transform = pendingLayer.propertyTreeState.transform();
     int transformId =
         propertyTreeManager.ensureCompositorTransformNode(transform);
     int clipId = propertyTreeManager.ensureCompositorClipNode(
         pendingLayer.propertyTreeState.clip());
     int effectId = propertyTreeManager.switchToEffectNode(
         *pendingLayer.propertyTreeState.effect());
 
     layer->set_offset_to_transform_parent(layerOffset);
     layer->SetElementId(pendingLayer.propertyTreeState.compositorElementId());
 
     m_rootLayer->AddChild(layer);
-    layer->set_property_tree_sequence_number(
-        PropertyTreeManager::kPropertyTreeSequenceNumber);
+    layer->set_property_tree_sequence_number(sPropertyTreeSequenceNumber);
     layer->SetTransformTreeIndex(transformId);
     layer->SetClipTreeIndex(clipId);
     layer->SetEffectTreeIndex(effectId);
     propertyTreeManager.updateLayerScrollMapping(layer.get(), transform);
 
     layer->SetShouldCheckBackfaceVisibility(pendingLayer.backfaceHidden);
 
     if (m_extraDataForTestingEnabled)
       m_extraDataForTesting->contentLayers.push_back(layer);
   }
   m_contentLayerClients.clear();
   m_contentLayerClients.swap(newContentLayerClients);
 
   // Mark the property trees as having been rebuilt.
   layerTreeHost->property_trees()->sequence_number =
-      PropertyTreeManager::kPropertyTreeSequenceNumber;
+      sPropertyTreeSequenceNumber;
   layerTreeHost->property_trees()->needs_rebuild = false;
   layerTreeHost->property_trees()->ResetCachedData();
+
+  sPropertyTreeSequenceNumber++;
 }
 
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink