Use range-based for in toCompositorTransformOperations

third_party/WebKit/Source/platform/animation/AnimationTranslationUtil.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 25 matching lines @@
 #include "platform/transforms/TransformationMatrix.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 
 namespace blink {
 
 void toCompositorTransformOperations(
     const TransformOperations& transformOperations,
     CompositorTransformOperations* outTransformOperations) {
   // We need to do a deep copy the transformOperations may contain ref pointers
   // to TransformOperation objects.
-  for (size_t j = 0; j < transformOperations.size(); ++j) {
-    switch (transformOperations.operations()[j]->type()) {
+  for (const auto& operation : transformOperations.operations()) {
+    switch (operation->type()) {
       case TransformOperation::ScaleX:
       case TransformOperation::ScaleY:
       case TransformOperation::ScaleZ:
       case TransformOperation::Scale3D:
       case TransformOperation::Scale: {
-        ScaleTransformOperation* transform =
-            static_cast<ScaleTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const ScaleTransformOperation*>(operation.get());
         outTransformOperations->appendScale(transform->x(), transform->y(),
                                             transform->z());
         break;
       }
       case TransformOperation::TranslateX:
       case TransformOperation::TranslateY:
       case TransformOperation::TranslateZ:
       case TransformOperation::Translate3D:
       case TransformOperation::Translate: {
-        TranslateTransformOperation* transform =
-            static_cast<TranslateTransformOperation*>(
-                transformOperations.operations()[j].get());
-        ASSERT(transform->x().isFixed() && transform->y().isFixed());
+        auto transform =
+            static_cast<const TranslateTransformOperation*>(operation.get());
+        DCHECK(transform->x().isFixed() && transform->y().isFixed());
         outTransformOperations->appendTranslate(
             transform->x().value(), transform->y().value(), transform->z());
         break;
       }
       case TransformOperation::RotateX:
       case TransformOperation::RotateY:
       case TransformOperation::Rotate3D:
       case TransformOperation::Rotate: {
-        RotateTransformOperation* transform =
-            static_cast<RotateTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const RotateTransformOperation*>(operation.get());
         outTransformOperations->appendRotate(
             transform->x(), transform->y(), transform->z(), transform->angle());
         break;
       }
       case TransformOperation::SkewX:
       case TransformOperation::SkewY:
       case TransformOperation::Skew: {
-        SkewTransformOperation* transform =
-            static_cast<SkewTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const SkewTransformOperation*>(operation.get());
         outTransformOperations->appendSkew(transform->angleX(),
                                            transform->angleY());
         break;
       }
       case TransformOperation::Matrix: {
-        MatrixTransformOperation* transform =
-            static_cast<MatrixTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const MatrixTransformOperation*>(operation.get());
         TransformationMatrix m = transform->matrix();
         outTransformOperations->appendMatrix(
             TransformationMatrix::toSkMatrix44(m));
         break;
       }
       case TransformOperation::Matrix3D: {
-        Matrix3DTransformOperation* transform =
-            static_cast<Matrix3DTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const Matrix3DTransformOperation*>(operation.get());
         TransformationMatrix m = transform->matrix();
         outTransformOperations->appendMatrix(
             TransformationMatrix::toSkMatrix44(m));
         break;
       }
       case TransformOperation::Perspective: {
-        PerspectiveTransformOperation* transform =
-            static_cast<PerspectiveTransformOperation*>(
-                transformOperations.operations()[j].get());
+        auto transform =
+            static_cast<const PerspectiveTransformOperation*>(operation.get());
         outTransformOperations->appendPerspective(transform->perspective());
         break;
       }
       case TransformOperation::Interpolated: {
         TransformationMatrix m;
-        transformOperations.operations()[j]->apply(m, FloatSize());
+        operation->apply(m, FloatSize());
         outTransformOperations->appendMatrix(
             TransformationMatrix::toSkMatrix44(m));
         break;
       }
       case TransformOperation::Identity:
         outTransformOperations->appendIdentity();
         break;
       case TransformOperation::None:
         // Do nothing.
         break;
     }  // switch
   }    // for each operation
 }
 
 }  // namespace blink