Fix clip caching bug in GeometryMapper.

third_party/WebKit/Source/platform/graphics/paint/GeometryMapper.cpp

 // Copyright 2016 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/paint/GeometryMapper.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/LayoutRect.h"
 
 namespace blink {
@@ skipping 143 matching lines @@
 
   const auto& transformMatrix =
       localToAncestorMatrix(localTransformNode, ancestorTransformNode);
   DCHECK(transformMatrix.isInvertible());
 
   // TODO(chrishtr): Cache the inverse?
   return transformMatrix.inverse().mapRect(rect);
 }
 
 PrecomputedDataForAncestor& GeometryMapper::getPrecomputedDataForAncestor(
-    const TransformPaintPropertyNode* ancestorTransformNode) {
-  auto addResult = m_data.insert(ancestorTransformNode, nullptr);
+    const TransformPaintPropertyNode* transform) {
+  auto addResult = m_data.insert(transform, nullptr);
   if (addResult.isNewEntry)
     addResult.storedValue->value = PrecomputedDataForAncestor::create();
   return *addResult.storedValue->value;
 }
 
+TransformCache& GeometryMapper::getTransformCache(
+    const TransformPaintPropertyNode* node) {
+  return getPrecomputedDataForAncestor(node).toAncestorTransforms;
+}
+
+ClipCache& GeometryMapper::getClipCache(
+    const TransformPaintPropertyNode* transform,
+    const ClipPaintPropertyNode* clip) {
+  PrecomputedDataForAncestor& precomputedData =
+      getPrecomputedDataForAncestor(transform);
+
+  auto addResult = precomputedData.precomputedClips.insert(clip, nullptr);
+  if (addResult.isNewEntry)
+    addResult.storedValue->value = WTF::makeUnique<ClipCache>();
+  return *addResult.storedValue->value;
+}
+
 FloatRect GeometryMapper::localToAncestorClipRect(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState) {
   bool success = false;
   FloatRect result =
       localToAncestorClipRectInternal(localState, ancestorState, success);
   DCHECK(success);
   return result;
 }
 
 FloatRect GeometryMapper::localToAncestorClipRectInternal(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
   FloatRect clip(LayoutRect::infiniteIntRect());
   if (localState.clip() == ancestorState.clip()) {
     success = true;
     return clip;
   }
 
-  PrecomputedDataForAncestor& precomputedData =
-      getPrecomputedDataForAncestor(ancestorState.transform());
+  ClipCache& clipCache =
+      getClipCache(ancestorState.transform(), ancestorState.clip());
   const ClipPaintPropertyNode* clipNode = localState.clip();
   Vector<const ClipPaintPropertyNode*> intermediateNodes;
 
   // Iterate over the path from localState.clip to ancestorState.clip. Stop if
   // we've found a memoized (precomputed) clip for any particular node.
   while (clipNode && clipNode != ancestorState.clip()) {
-    auto it = precomputedData.toAncestorClipRects.find(clipNode);
-    if (it != precomputedData.toAncestorClipRects.end()) {
+    auto it = clipCache.find(clipNode);
+    if (it != clipCache.end()) {
       clip = it->value;
       break;
     }
     intermediateNodes.push_back(clipNode);
     clipNode = clipNode->parent();
   }
   if (!clipNode) {
     success = false;
     return clip;
   }
 
   // Iterate down from the top intermediate node found in the previous loop,
   // computing and memoizing clip rects as we go.
   for (auto it = intermediateNodes.rbegin(); it != intermediateNodes.rend();
        ++it) {
     success = false;
     const TransformationMatrix& transformMatrix = localToAncestorMatrixInternal(
         (*it)->localTransformSpace(), ancestorState.transform(), success);
     if (!success)
       return clip;
     FloatRect mappedRect = transformMatrix.mapRect((*it)->clipRect().rect());
     clip.intersect(mappedRect);
-    precomputedData.toAncestorClipRects.set(*it, clip);
+    clipCache.set(*it, clip);
   }
 
   success = true;
-  return precomputedData.toAncestorClipRects.find(localState.clip())->value;
+  return clipCache.find(localState.clip())->value;
 }
 
 const TransformationMatrix& GeometryMapper::localToAncestorMatrix(
     const TransformPaintPropertyNode* localTransformNode,
     const TransformPaintPropertyNode* ancestorTransformNode) {
   bool success = false;
   const auto& result = localToAncestorMatrixInternal(
       localTransformNode, ancestorTransformNode, success);
   DCHECK(success);
   return result;
 }
 
 const TransformationMatrix& GeometryMapper::localToAncestorMatrixInternal(
     const TransformPaintPropertyNode* localTransformNode,
     const TransformPaintPropertyNode* ancestorTransformNode,
     bool& success) {
   if (localTransformNode == ancestorTransformNode) {
     success = true;
     return m_identity;
   }
 
-  PrecomputedDataForAncestor& precomputedData =
-      getPrecomputedDataForAncestor(ancestorTransformNode);
+  TransformCache& transformCache = getTransformCache(ancestorTransformNode);
 
   const TransformPaintPropertyNode* transformNode = localTransformNode;
   Vector<const TransformPaintPropertyNode*> intermediateNodes;
   TransformationMatrix transformMatrix;
 
   // Iterate over the path from localTransformNode to ancestorState.transform.
   // Stop if we've found a memoized (precomputed) transform for any particular
   // node.
   while (transformNode && transformNode != ancestorTransformNode) {
-    auto it = precomputedData.toAncestorTransforms.find(transformNode);
-    if (it != precomputedData.toAncestorTransforms.end()) {
+    auto it = transformCache.find(transformNode);
+    if (it != transformCache.end()) {
       transformMatrix = it->value;
       break;
     }
     intermediateNodes.push_back(transformNode);
     transformNode = transformNode->parent();
   }
   if (!transformNode) {
     success = false;
     return m_identity;
   }
 
   // Iterate down from the top intermediate node found in the previous loop,
   // computing and memoizing transforms as we go.
   for (auto it = intermediateNodes.rbegin(); it != intermediateNodes.rend();
        it++) {
     TransformationMatrix localTransformMatrix = (*it)->matrix();
     localTransformMatrix.applyTransformOrigin((*it)->origin());
     transformMatrix = transformMatrix * localTransformMatrix;
-    precomputedData.toAncestorTransforms.set(*it, transformMatrix);
+    transformCache.set(*it, transformMatrix);
   }
   success = true;
-  return precomputedData.toAncestorTransforms.find(localTransformNode)->value;
+  return transformCache.find(localTransformNode)->value;
 }
 
 void GeometryMapper::clearCache() {
   m_data.clear();
 }
 
 namespace {
 
 template <typename NodeType>
 unsigned nodeDepth(const NodeType* node) {
@@ skipping 44 matching lines @@
     const TransformPaintPropertyNode*,
     const TransformPaintPropertyNode*);
 template const ClipPaintPropertyNode* GeometryMapper::lowestCommonAncestor(
     const ClipPaintPropertyNode*,
     const ClipPaintPropertyNode*);
 template const ScrollPaintPropertyNode* GeometryMapper::lowestCommonAncestor(
     const ScrollPaintPropertyNode*,
     const ScrollPaintPropertyNode*);
 
 }  // namespace blink