More early returns in GeometryMapper methods

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 {
 
 FloatRect GeometryMapper::mapToVisualRectInDestinationSpace(
     const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success) {
-  if (sourceState == destinationState) {
-    success = true;
-    return rect;
-  }
   FloatRect result = localToVisualRectInAncestorSpace(
       rect, sourceState, destinationState, success);
   if (success)
     return result;
   return slowMapToVisualRectInDestinationSpace(rect, sourceState,
                                                destinationState, success);
 }
 
 FloatRect GeometryMapper::mapRectToDestinationSpace(
     const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success) {
-  if (sourceState == destinationState) {
-    success = true;
-    return rect;
-  }
   FloatRect result =
       localToAncestorRect(rect, sourceState, destinationState, success);
   if (success)
     return result;
   return slowMapRectToDestinationSpace(rect, sourceState, destinationState,
                                        success);
 }
 
 FloatRect GeometryMapper::slowMapToVisualRectInDestinationSpace(
     const FloatRect& rect,
@@ skipping 11 matching lines @@
   lcaState.setTransform(lcaTransform);
 
   const auto clipRect = localToAncestorClipRect(sourceState, lcaState, success);
   if (!success)
     return rect;
 
   FloatRect result = localToAncestorRect(rect, sourceState, lcaState, success);
   DCHECK(success);
   result.intersect(clipRect);
 
-  const TransformationMatrix& destinationToLca =
-      localToAncestorMatrix(destinationState.transform(), lcaState, success);
-  DCHECK(success);
-  if (destinationToLca.isInvertible()) {
-    success = true;
-    return destinationToLca.inverse().mapRect(result);
-  }
-  success = false;
-  return rect;
+  return ancestorToLocalRect(result, destinationState, lcaState, success);
 }
 
 FloatRect GeometryMapper::slowMapRectToDestinationSpace(
     const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success) {
   const TransformPaintPropertyNode* lcaTransform = leastCommonAncestor(
       sourceState.transform(), destinationState.transform());
   DCHECK(lcaTransform);
   PropertyTreeState lcaState = sourceState;
   lcaState.setTransform(lcaTransform);
 
   FloatRect result = localToAncestorRect(rect, sourceState, lcaState, success);
   DCHECK(success);
 
-  const TransformationMatrix& destinationToLca =
-      localToAncestorMatrix(destinationState.transform(), lcaState, success);
-  DCHECK(success);
-  if (destinationToLca.isInvertible()) {
-    success = true;
-    return destinationToLca.inverse().mapRect(result);
-  }
-  success = false;
-  return rect;
+  return ancestorToLocalRect(result, destinationState, lcaState, success);
 }
 
 FloatRect GeometryMapper::localToVisualRectInAncestorSpace(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
+  if (localState == ancestorState) {
+    success = true;
+    return rect;
+  }
+
   const auto& transformMatrix =
       localToAncestorMatrix(localState.transform(), ancestorState, success);
   if (!success)
     return rect;
 
   FloatRect mappedRect = transformMatrix.mapRect(rect);
 
   const auto clipRect =
       localToAncestorClipRect(localState, ancestorState, success);
 
@@ skipping 12 matching lines @@
   }
 
   return mappedRect;
 }
 
 FloatRect GeometryMapper::localToAncestorRect(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
+  if (localState.transform() == ancestorState.transform()) {
+    success = true;
+    return rect;
+  }
+
   const auto& transformMatrix =
       localToAncestorMatrix(localState.transform(), ancestorState, success);
   if (!success)
     return rect;
   return transformMatrix.mapRect(rect);
 }
 
 FloatRect GeometryMapper::ancestorToLocalRect(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
+  if (localState.transform() == ancestorState.transform()) {
+    success = true;
+    return rect;
+  }
+
   const auto& transformMatrix =
       localToAncestorMatrix(localState.transform(), ancestorState, success);
   if (!success)
     return rect;
 
   if (!transformMatrix.isInvertible()) {
     success = false;
     return rect;
   }
   success = true;
 
   // TODO(chrishtr): Cache the inverse?
   return transformMatrix.inverse().mapRect(rect);
 }
 
 PrecomputedDataForAncestor& GeometryMapper::getPrecomputedDataForAncestor(
     const PropertyTreeState& ancestorState) {
   auto addResult = m_data.add(ancestorState.transform(), nullptr);
   if (addResult.isNewEntry)
     addResult.storedValue->value = PrecomputedDataForAncestor::create();
   return *addResult.storedValue->value;
 }
 
 FloatRect GeometryMapper::localToAncestorClipRect(
     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);
   const ClipPaintPropertyNode* clipNode = localState.clip();
   Vector<const ClipPaintPropertyNode*> intermediateNodes;
-  FloatRect clip(LayoutRect::infiniteIntRect());
 
   bool found = false;
   // 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) {
     auto it = precomputedData.toAncestorClipRects.find(clipNode);
     if (it != precomputedData.toAncestorClipRects.end()) {
       clip = it->value;
       found = true;
       break;
@@ skipping 28 matching lines @@
   }
 
   success = true;
   return precomputedData.toAncestorClipRects.find(localState.clip())->value;
 }
 
 const TransformationMatrix& GeometryMapper::localToAncestorMatrix(
     const TransformPaintPropertyNode* localTransformNode,
     const PropertyTreeState& ancestorState,
     bool& success) {
+  if (localTransformNode == ancestorState.transform()) {
+    success = true;
+    return m_identity;
+  }
+
   PrecomputedDataForAncestor& precomputedData =
       getPrecomputedDataForAncestor(ancestorState);
 
   const TransformPaintPropertyNode* transformNode = localTransformNode;
   Vector<const TransformPaintPropertyNode*> intermediateNodes;
   TransformationMatrix transformMatrix;
 
-  bool found = false;
   // Iterate over the path from localTransformNode to ancestorState.transform.
   // Stop if we've found a memoized (precomputed) transform for any particular
   // node.
   while (transformNode) {
     auto it = precomputedData.toAncestorTransforms.find(transformNode);
     if (it != precomputedData.toAncestorTransforms.end()) {
       transformMatrix = it->value;
-      found = true;
       break;
     }
 
-    intermediateNodes.push_back(transformNode);
-
     if (transformNode == ancestorState.transform())
       break;
 
+    intermediateNodes.push_back(transformNode);
     transformNode = transformNode->parent();
   }
-  if (!found && transformNode != ancestorState.transform()) {
+  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++) {
-    if ((*it) != ancestorState.transform()) {
-      TransformationMatrix localTransformMatrix = (*it)->matrix();
-      localTransformMatrix.applyTransformOrigin((*it)->origin());
-      transformMatrix = transformMatrix * localTransformMatrix;
-    }
-
+    TransformationMatrix localTransformMatrix = (*it)->matrix();
+    localTransformMatrix.applyTransformOrigin((*it)->origin());
+    transformMatrix = transformMatrix * localTransformMatrix;
     precomputedData.toAncestorTransforms.set(*it, transformMatrix);
   }
   success = true;
   return precomputedData.toAncestorTransforms.find(localTransformNode)->value;
 }
 
 namespace {
 
 unsigned transformPropertyTreeNodeDepth(
     const TransformPaintPropertyNode* node) {
@@ skipping 27 matching lines @@
 
   // Walk up until we find the ancestor.
   while (a != b) {
     a = a->parent();
     b = b->parent();
   }
   return a;
 }
 
 }  // namespace blink