Make a bunch of structs anonymous ...

cc/animation/transform_operations_unittest.cc

 // Copyright 2013 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 <limits>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/geometry_test_utils.h"
@@ skipping 909 matching lines @@
   operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
 
   gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
   gfx::BoxF bounds;
 
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, 0.f, 1.f, &bounds));
   EXPECT_EQ(box.ToString(), bounds.ToString());
 }
 
-// This would have been best as anonymous structs, but |arraysize| does not get
-// along with anonymous structs (and using ARRAYSIZE_UNSAFE seemed like a worse
-// option).
-struct ProblematicAxisTest {
-  float x;
-  float y;
-  float z;
-  gfx::BoxF expected;
-};
-
 TEST(TransformOperationTest, BlendedBoundsForRotationProblematicAxes) {
   // Zeros in the components of the axis of rotation turned out to be tricky to
   // deal with in practice. This function tests some potentially problematic
   // axes to ensure sane behavior.
 
   // Some common values used in the expected boxes.
   float dim1 = 0.292893f;
   float dim2 = sqrt(2.f);
   float dim3 = 2.f * dim2;
 
-  ProblematicAxisTest tests[] = {
-    { 0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f) },
-    { 1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3) },
-    { 0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3) },
-    { 0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f) },
-    { 1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f) },
-    { 0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2) },
-    { 1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2) }
-  };
+  struct {
+    float x;
+    float y;
+    float z;
+    gfx::BoxF expected;
+  } tests[] = {{0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f)},
+               {1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3)},
+               {0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3)},
+               {0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f)},
+               {1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f)},
+               {0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2)},
+               {1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2)}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     float x = tests[i].x;
     float y = tests[i].y;
     float z = tests[i].z;
     TransformOperations operations_from;
     operations_from.AppendRotate(x, y, z, 0.f);
     TransformOperations operations_to;
     operations_to.AppendRotate(x, y, z, 360.f);
     gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
     gfx::BoxF bounds;
 
     EXPECT_TRUE(operations_to.BlendedBoundsForBox(
         box, operations_from, 0.f, 1.f, &bounds));
     EXPECT_EQ(tests[i].expected.ToString(), bounds.ToString());
   }
 }
 
-// These would have been best as anonymous structs, but |arraysize| does not get
-// along with anonymous structs (and using ARRAYSIZE_UNSAFE seemed like a worse
-// option).
-struct TestAxis {
-  float x;
-  float y;
-  float z;
-};
-
-struct TestAngles {
-  float theta_from;
-  float theta_to;
-};
-
-struct TestProgress {
-  float min_progress;
-  float max_progress;
-};
-
 static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
                                           const gfx::BoxF& rhs,
                                           float tolerance) {
   EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
   EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
   EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
   EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
   EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
   EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
 }
@@ skipping 58 matching lines @@
                                              SkMScalar min_progress,
                                              SkMScalar max_progress) {
   EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
 }
 
 TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
   // Sets up various axis angle combinations, computes the bounding box and
   // empirically tests that the transformed bounds are indeed contained by the
   // computed bounding box.
 
-  TestAxis axes[] = {
-    { 1.f, 1.f, 1.f },
-    { -1.f, -1.f, -1.f },
-    { -1.f, 2.f, 3.f },
-    { 1.f, -2.f, 3.f },
-    { 1.f, 2.f, -3.f },
-    { 0.f, 0.f, 0.f },
-    { 1.f, 0.f, 0.f },
-    { 0.f, 1.f, 0.f },
-    { 0.f, 0.f, 1.f },
-    { 1.f, 1.f, 0.f },
-    { 0.f, 1.f, 1.f },
-    { 1.f, 0.f, 1.f },
-    { -1.f, 0.f, 0.f },
-    { 0.f, -1.f, 0.f },
-    { 0.f, 0.f, -1.f },
-    { -1.f, -1.f, 0.f },
-    { 0.f, -1.f, -1.f },
-    { -1.f, 0.f, -1.f }
-  };
+  struct {
+    float x;
+    float y;
+    float z;
+  } axes[] = {{1.f, 1.f, 1.f},
+              {-1.f, -1.f, -1.f},
+              {-1.f, 2.f, 3.f},
+              {1.f, -2.f, 3.f},
+              {1.f, 2.f, -3.f},
+              {0.f, 0.f, 0.f},
+              {1.f, 0.f, 0.f},
+              {0.f, 1.f, 0.f},
+              {0.f, 0.f, 1.f},
+              {1.f, 1.f, 0.f},
+              {0.f, 1.f, 1.f},
+              {1.f, 0.f, 1.f},
+              {-1.f, 0.f, 0.f},
+              {0.f, -1.f, 0.f},
+              {0.f, 0.f, -1.f},
+              {-1.f, -1.f, 0.f},
+              {0.f, -1.f, -1.f},
+              {-1.f, 0.f, -1.f}};
 
-  TestAngles angles[] = {
-    { 5.f, 10.f },
-    { 10.f, 5.f },
-    { 0.f, 360.f },
-    { 20.f, 180.f },
-    { -20.f, -180.f },
-    { 180.f, -220.f },
-    { 220.f, 320.f }
-  };
+  struct {
+    float theta_from;
+    float theta_to;
+  } angles[] = {{5.f, 10.f},
+                {10.f, 5.f},
+                {0.f, 360.f},
+                {20.f, 180.f},
+                {-20.f, -180.f},
+                {180.f, -220.f},
+                {220.f, 320.f}};
 
   // We can go beyond the range [0, 1] (the bezier might slide out of this range
   // at either end), but since the first and last knots are at (0, 0) and (1, 1)
   // we will never go within it, so these tests are sufficient.
-  TestProgress progress[] = {
-    { 0.f, 1.f },
-    { -.25f, 1.25f },
-  };
+  struct {
+    float min_progress;
+    float max_progress;
+  } progress[] = {
+        {0.f, 1.f}, {-.25f, 1.25f},
+    };
 
   for (size_t i = 0; i < arraysize(axes); ++i) {
     for (size_t j = 0; j < arraysize(angles); ++j) {
       for (size_t k = 0; k < arraysize(progress); ++k) {
         float x = axes[i].x;
         float y = axes[i].y;
         float z = axes[i].z;
         TransformOperations operations_from;
         operations_from.AppendRotate(x, y, z, angles[j].theta_from);
         TransformOperations operations_to;
@@ skipping 27 matching lines @@
       gfx::Transform blended_matrix = to_transform;
       EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
 
       gfx::Transform blended_transform =
           to_operations.Blend(from_operations, progress);
 
       EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
     }
 }
 
-struct TestPerspectiveDepths {
-  float from_depth;
-  float to_depth;
-};
+TEST(TransformOperationTest, BlendedBoundsForPerspective) {
+  struct {
+    float from_depth;
+    float to_depth;
+  } perspective_depths[] = {
+        {600.f, 400.f},
+        {800.f, 1000.f},
+        {800.f, std::numeric_limits<float>::infinity()},
+    };
 
-TEST(TransformOperationTest, BlendedBoundsForPerspective) {
-  TestPerspectiveDepths perspective_depths[] = {
-    { 600.f, 400.f },
-    { 800.f, 1000.f },
-    { 800.f, std::numeric_limits<float>::infinity() },
-  };
-
-  TestProgress progress[] = {
-    { 0.f, 1.f },
-    { -0.1f, 1.1f },
-  };
+  struct {
+    float min_progress;
+    float max_progress;
+  } progress[] = {
+        {0.f, 1.f}, {-0.1f, 1.1f},
+    };
 
   for (size_t i = 0; i < arraysize(perspective_depths); ++i) {
     for (size_t j = 0; j < arraysize(progress); ++j) {
       TransformOperations operations_from;
       operations_from.AppendPerspective(perspective_depths[i].from_depth);
       TransformOperations operations_to;
       operations_to.AppendPerspective(perspective_depths[i].to_depth);
       EmpiricallyTestBoundsEquality(operations_from,
                                     operations_to,
                                     progress[j].min_progress,
                                     progress[j].max_progress);
     }
   }
 }
 
-struct TestSkews {
-  float from_x;
-  float from_y;
-  float to_x;
-  float to_y;
-};
+TEST(TransformOperationTest, BlendedBoundsForSkew) {
+  struct {
+    float from_x;
+    float from_y;
+    float to_x;
+    float to_y;
+  } skews[] = {
+        {1.f, 0.5f, 0.5f, 1.f}, {2.f, 1.f, 0.5f, 0.5f},
+    };

[danakj, 2014/10/16 20:08:02]

this is super weird, mind filing a clang-format bug about this ali?

[jamesr, 2014/10/16 20:43:09]

I don't see the issue.  The declaration here starts on column 5

skews[] ...

and the }; matches the start of the declaration.

[danakj, 2014/10/16 20:50:27]

i expect the } to be at the level of indent of the block it returns to i guess

like

} else {
}

not 

} else {
  }

 
-TEST(TransformOperationTest, BlendedBoundsForSkew) {
-  TestSkews skews[] = {
-    { 1.f, 0.5f, 0.5f, 1.f },
-    { 2.f, 1.f, 0.5f, 0.5f },
-  };
-
-  TestProgress progress[] = {
-    { 0.f, 1.f },
-    { -0.1f, 1.1f },
-  };
+  struct {
+    float min_progress;
+    float max_progress;
+  } progress[] = {
+        {0.f, 1.f}, {-0.1f, 1.1f},
+    };
 
   for (size_t i = 0; i < arraysize(skews); ++i) {
     for (size_t j = 0; j < arraysize(progress); ++j) {
       TransformOperations operations_from;
       operations_from.AppendSkew(skews[i].from_x, skews[i].from_y);
       TransformOperations operations_to;
       operations_to.AppendSkew(skews[i].to_x, skews[i].to_y);
       EmpiricallyTestBoundsEquality(operations_from,
                                     operations_to,
                                     progress[j].min_progress,
@@ skipping 259 matching lines @@
 
   // Scale + Perspective can't.
   TransformOperations operations11;
   operations11.AppendScale(2.f, 2.f, 2.f);
   operations11.AppendPerspective(1.f);
   EXPECT_FALSE(operations11.ScaleComponent(&scale));
 }
 
 }  // namespace
 }  // namespace cc