Improve performance of GeometryMapper cache.

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 196 matching lines @@
     return rect;
 
   const auto& transformMatrix =
       localToAncestorMatrix(localTransformNode, ancestorTransformNode);
   DCHECK(transformMatrix.isInvertible());
 
   // TODO(chrishtr): Cache the inverse?
   return transformMatrix.inverse().mapRect(rect);
 }
 
-GeometryMapper::TransformCache& GeometryMapper::getTransformCache(
-    const TransformPaintPropertyNode* ancestor) {
-  auto addResult = m_transformCache.insert(ancestor, nullptr);
-  if (addResult.isNewEntry)
-    addResult.storedValue->value = WTF::wrapUnique(new TransformCache);
-  return *addResult.storedValue->value;
-}
-
-GeometryMapper::ClipCache& GeometryMapper::getClipCache(
-    const ClipPaintPropertyNode* ancestorClip,
-    const TransformPaintPropertyNode* ancestorTransform) {
-  auto addResultTransform = m_clipCache.insert(ancestorClip, nullptr);
-  if (addResultTransform.isNewEntry) {
-    addResultTransform.storedValue->value =
-        WTF::wrapUnique(new TransformToClip);
-  }
-
-  auto addResultClip =
-      addResultTransform.storedValue->value->insert(ancestorTransform, nullptr);
-  if (addResultClip.isNewEntry)
-    addResultClip.storedValue->value = WTF::wrapUnique(new ClipCache);
-
-  return *addResultClip.storedValue->value;
-}
-
 FloatClipRect GeometryMapper::localToAncestorClipRect(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState) {
   bool success = false;
   FloatClipRect result =
       localToAncestorClipRectInternal(localState.clip(), ancestorState.clip(),
                                       ancestorState.transform(), success);
 
   DCHECK(success);
 
@@ skipping 15 matching lines @@
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success) {
   FloatClipRect result = localToAncestorClipRectInternal(
       sourceState.clip(), destinationState.clip(), destinationState.transform(),
       success);
   // Success if destinationState is an ancestor state.
   if (success)
     return result;
 
-  // Otherwise first map to the lowest common ancestor, then map to destination.
+  // Otherwise first map to the lowest common ancestor, then map to
+  // destination.
   const TransformPaintPropertyNode* lcaTransform = lowestCommonAncestor(
       sourceState.transform(), destinationState.transform());
   DCHECK(lcaTransform);
 
   // Assume that the clip of destinationState is an ancestor of the clip of
   // sourceState and is under the space of lcaTransform. Otherwise
   // localToAncestorClipRectInternal() will fail.
   PropertyTreeState lcaState = destinationState;
   lcaState.setTransform(lcaTransform);
 
   result = localToAncestorClipRectInternal(sourceState.clip(), lcaState.clip(),
                                            lcaState.transform(), success);
   if (!success) {
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       // On SPv1 we may fail when the paint invalidation container creates an
       // overflow clip (in ancestorState) which is not in localState of an
-      // out-of-flow positioned descendant. See crbug.com/513108 and layout test
-      // compositing/overflow/handle-non-ancestor-clip-parent.html (run with
-      // --enable-prefer-compositing-to-lcd-text) for details.
+      // out-of-flow positioned descendant. See crbug.com/513108 and layout
+      // test compositing/overflow/handle-non-ancestor-clip-parent.html (run
+      // with --enable-prefer-compositing-to-lcd-text) for details.
       // Ignore it for SPv1 for now.
       success = true;
     }
     return result;
   }
   if (!result.isInfinite()) {
     FloatRect final = ancestorToLocalRect(result.rect(), lcaTransform,
                                           destinationState.transform());
     result.setRect(final);
   }
   return result;
 }
 
-FloatClipRect GeometryMapper::localToAncestorClipRectInternal(
+const FloatClipRect& GeometryMapper::localToAncestorClipRectInternal(
     const ClipPaintPropertyNode* descendant,
     const ClipPaintPropertyNode* ancestorClip,
     const TransformPaintPropertyNode* ancestorTransform,
     bool& success) {
   FloatClipRect clip;
   if (descendant == ancestorClip) {
     success = true;
-    // Return an infinite clip.
-    return clip;
+    return m_infiniteClip;
   }
 
-  ClipCache& clipCache = getClipCache(ancestorClip, ancestorTransform);
   const ClipPaintPropertyNode* clipNode = descendant;
   Vector<const ClipPaintPropertyNode*> intermediateNodes;
 
+  GeometryMapperClipCache::ClipAndTransform clipAndTransform(ancestorClip,
+                                                             ancestorTransform);
   // 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 != ancestorClip) {
-    auto it = clipCache.find(clipNode);
-    if (it != clipCache.end()) {
-      clip = it->value;
+    if (const FloatClipRect* cachedClip =
+            clipNode->getClipCache().getCachedClip(clipAndTransform)) {
+      clip = *cachedClip;
       break;
     }
+
     intermediateNodes.push_back(clipNode);
     clipNode = clipNode->parent();
   }
   if (!clipNode) {
     success = false;
-    return clip;
+    return m_infiniteClip;
   }
 
   // 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(), ancestorTransform, success);
     if (!success)
-      return clip;
+      return m_infiniteClip;
     FloatRect mappedRect = transformMatrix.mapRect((*it)->clipRect().rect());
     clip.intersect(mappedRect);
     if ((*it)->clipRect().isRounded())
       clip.setHasRadius();
-    clipCache.set(*it, clip);
+    (*it)->getClipCache().setCachedClip(clipAndTransform, clip);
   }
 
   success = true;
-  return clipCache.find(descendant)->value;
+
+  const FloatClipRect* cachedClip =
+      descendant->getClipCache().getCachedClip(clipAndTransform);
+  DCHECK(cachedClip);
+  return *cachedClip;
 }
 
 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;
   }
 
-  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 = transformCache.find(transformNode);
-    if (it != transformCache.end()) {
-      transformMatrix = it->value;
+    if (const TransformationMatrix* cachedMatrix =
+            transformNode->getTransformCache().getCachedTransform(
+                ancestorTransformNode)) {
+      transformMatrix = *cachedMatrix;
       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;
-    transformCache.set(*it, transformMatrix);
+    (*it)->getTransformCache().setCachedTransform(ancestorTransformNode,
+                                                  transformMatrix);
   }
   success = true;
-  return transformCache.find(localTransformNode)->value;
+  const TransformationMatrix* cachedMatrix =
+      localTransformNode->getTransformCache().getCachedTransform(
+          ancestorTransformNode);
+  DCHECK(cachedMatrix);
+  return *cachedMatrix;
 }
 
 void GeometryMapper::clearCache() {
-  m_transformCache.clear();
-  m_clipCache.clear();
+  GeometryMapperTransformCache::clearCache();
+  GeometryMapperClipCache::clearCache();
 }
 
 namespace {
 
 template <typename NodeType>
 unsigned nodeDepth(const NodeType* node) {
   unsigned depth = 0;
   while (node) {
     depth++;
     node = node->parent();
@@ skipping 40 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