Tidy up ComputedStyle::applyTransform

third_party/WebKit/Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 1243 matching lines @@
       default:
         break;
     }
   }
   return false;
 }
 
 bool ComputedStyle::requireTransformOrigin(
     ApplyTransformOrigin applyOrigin,
     ApplyMotionPath applyMotionPath) const {
-  const Vector<RefPtr<TransformOperation>>& transformOperations =
-      transform().operations();
-
   // transform-origin brackets the transform with translate operations.
   // Optimize for the case where the only transform is a translation, since the
   // transform-origin is irrelevant in that case.
   if (applyOrigin != IncludeTransformOrigin)
     return false;
 
   if (applyMotionPath == IncludeMotionPath)
     return true;
 
-  unsigned size = transformOperations.size();
-  for (unsigned i = 0; i < size; ++i) {
-    TransformOperation::OperationType type = transformOperations[i]->type();
+  for (const auto& operation : transform().operations()) {
+    TransformOperation::OperationType type = operation->type();
     if (type != TransformOperation::TranslateX &&
         type != TransformOperation::TranslateY &&
         type != TransformOperation::Translate &&
         type != TransformOperation::TranslateZ &&
         type != TransformOperation::Translate3D)
       return true;
   }
 
   return scale() || rotate();
 }
@@ skipping 15 matching lines @@
     const FloatRect& boundingBox,
     ApplyTransformOrigin applyOrigin,
     ApplyMotionPath applyMotionPath,
     ApplyIndependentTransformProperties applyIndependentTransformProperties)
     const {
   if (!hasOffset())
     applyMotionPath = ExcludeMotionPath;
   bool applyTransformOrigin =
       requireTransformOrigin(applyOrigin, applyMotionPath);
 
-  float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;
-  float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;
-
   float originX = 0;
   float originY = 0;
   float originZ = 0;
 
+  const FloatSize& boxSize = boundingBox.size();
   if (applyTransformOrigin ||
       // We need to calculate originX and originY for applying motion path.
-      applyMotionPath == ComputedStyle::IncludeMotionPath) {
+      applyMotionPath == IncludeMotionPath) {
+    float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;
     originX =
-        floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX;
+        floatValueForLength(transformOriginX(), boxSize.width()) + offsetX;
+    float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;
     originY =
-        floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY;
+        floatValueForLength(transformOriginY(), boxSize.height()) + offsetY;
     if (applyTransformOrigin) {
       originZ = transformOriginZ();
       result.translate3d(originX, originY, originZ);
     }
   }
 
   if (applyIndependentTransformProperties ==
       IncludeIndependentTransformProperties) {
     if (translate())
-      translate()->apply(result, boundingBox.size());
+      translate()->apply(result, boxSize);
 
     if (rotate())
-      rotate()->apply(result, boundingBox.size());
+      rotate()->apply(result, boxSize);
 
     if (scale())
-      scale()->apply(result, boundingBox.size());
+      scale()->apply(result, boxSize);
   }
 
-  if (applyMotionPath == ComputedStyle::IncludeMotionPath)
+  if (applyMotionPath == IncludeMotionPath)
     applyMotionPathTransform(originX, originY, result);
 
-  const Vector<RefPtr<TransformOperation>>& transformOperations =
-      transform().operations();
-  unsigned size = transformOperations.size();
-  for (unsigned i = 0; i < size; ++i)
-    transformOperations[i]->apply(result, boundingBox.size());
+  for (const auto& operation : transform().operations())
+    operation->apply(result, boxSize);
 
   if (applyTransformOrigin) {
     result.translate3d(-originX, -originY, -originZ);
   }
 }
 
 void ComputedStyle::applyMotionPathTransform(
     float originX,
     float originY,
     TransformationMatrix& transform) const {
@@ skipping 1036 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 }  // namespace blink