Make GeometryMapper fully static

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 {
 
+const TransformationMatrix& GeometryMapper::identityMatrix() {
+  DEFINE_STATIC_LOCAL(TransformationMatrix, identity, (TransformationMatrix()));
+  return identity;
+}
+
+const FloatClipRect& GeometryMapper::infiniteClip() {
+  DEFINE_STATIC_LOCAL(FloatClipRect, infinite, (FloatClipRect()));
+  return infinite;
+}
+
+FloatClipRect& GeometryMapper::tempRect() {
+  DEFINE_STATIC_LOCAL(FloatClipRect, temp, (FloatClipRect()));
+  return temp;
+}
+
 void GeometryMapper::sourceToDestinationVisualRect(
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     FloatRect& rect) {
   bool success = false;
   sourceToDestinationVisualRectInternal(sourceState, destinationState, rect,
                                         success);
   DCHECK(success);
 }
 
@@ skipping 229 matching lines @@
       // 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 result2;
   }
   if (!result2.isInfinite()) {
     FloatRect rect = result2.rect();
     ancestorToLocalRect(lcaTransform, destinationState.transform(), rect);
-    m_tempRect.setRect(rect);
+    FloatClipRect& temp = tempRect();
+    temp.setRect(rect);
     if (result2.hasRadius())
-      m_tempRect.setHasRadius();
-    return m_tempRect;
+      temp.setHasRadius();
+    return temp;
   }
   return result2;
 }
 
 const FloatClipRect& GeometryMapper::localToAncestorClipRectInternal(
     const ClipPaintPropertyNode* descendant,
     const ClipPaintPropertyNode* ancestorClip,
     const TransformPaintPropertyNode* ancestorTransform,
     bool& success) {
   FloatClipRect clip;
   if (descendant == ancestorClip) {
     success = true;
-    return m_infiniteClip;
+    return infiniteClip();
   }
 
   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) {
     if (const FloatClipRect* cachedClip =
             clipNode->getClipCache().getCachedClip(clipAndTransform)) {
       clip = *cachedClip;
       break;
     }
 
     intermediateNodes.push_back(clipNode);
     clipNode = clipNode->parent();
   }
   if (!clipNode) {
     success = false;
-    return m_infiniteClip;
+    return 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 m_infiniteClip;
+      return infiniteClip();
     FloatRect mappedRect = transformMatrix.mapRect((*it)->clipRect().rect());
     clip.intersect(mappedRect);
     if ((*it)->clipRect().isRounded())
       clip.setHasRadius();
 
     (*it)->getClipCache().setCachedClip(clipAndTransform, clip);
   }
 
   success = true;
 
@@ skipping 13 matching lines @@
   DCHECK(success);
   return result;
 }
 
 const TransformationMatrix& GeometryMapper::localToAncestorMatrixInternal(
     const TransformPaintPropertyNode* localTransformNode,
     const TransformPaintPropertyNode* ancestorTransformNode,
     bool& success) {
   if (localTransformNode == ancestorTransformNode) {
     success = true;
-    return m_identity;
+    return identityMatrix();
   }
 
   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) {
     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;
+    return identityMatrix();
   }
 
   // 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());
 
     // Flattening Lemma: flatten(A * flatten(B)) = flatten(flatten(A) * B).
@@ skipping 71 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