[CC]: Reduce required precision for TransformNormal test.

cc/quads/draw_polygon_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "cc/output/bsp_compare_result.h"
 #include "cc/quads/draw_polygon.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 #define CREATE_NEW_DRAW_POLYGON(name, points_vector, normal, polygon_id) \
   DrawPolygon name(NULL, points_vector, normal, polygon_id)
 
+#define EXPECT_FLOAT_WITHIN_EPSILON_OF(a, b) \
+  EXPECT_TRUE(std::abs(a - b) < std::numeric_limits<float>::epsilon());

[Sami, 2014/08/06 17:09:24]

I think in general the epsilon should be scaled up like shown here:
http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon

However that wouldn't work with zero like we talked before, so maybe we should
just throw a std::max(1.f, ...) in there.

Alternatively we could rename this macro to only work with comparisons with <=
1.

+
 #define EXPECT_POINT_EQ(point_a, point_b)    \
   EXPECT_FLOAT_EQ(point_a.x(), point_b.x()); \
   EXPECT_FLOAT_EQ(point_a.y(), point_b.y()); \
   EXPECT_FLOAT_EQ(point_a.z(), point_b.z());
 
 static void ValidatePoints(const DrawPolygon& polygon,
                            const std::vector<gfx::Point3F>& points) {
   EXPECT_EQ(polygon.points().size(), points.size());
   for (size_t i = 0; i < points.size(); i++) {
     EXPECT_POINT_EQ(polygon.points()[i], points[i]);
@@ skipping 138 matching lines @@
   CREATE_NEW_DRAW_POLYGON(
       polygon_a, vertices_a, gfx::Vector3dF(0.707107f, 0.0f, -0.707107f), 0);
 
   gfx::Transform transform;
   transform.RotateAboutYAxis(45.0);
   // This would transform the vertices as well, but we are transforming a
   // DrawPolygon with 0 vertices just to make sure our normal transformation
   // using the inverse tranpose matrix gives us the right result.
   polygon_a.TransformToScreenSpace(transform);
 
-  EXPECT_FLOAT_EQ(polygon_a.normal().x(), 0);
-  EXPECT_FLOAT_EQ(polygon_a.normal().y(), 0);
-  EXPECT_FLOAT_EQ(polygon_a.normal().z(), -1);
+  // Note: We use EXPECT_FLOAT_WITHIN_EPSILON instead of EXPECT_FLOAT_EQUAL here
+  // because some architectures (e.g., Arm64) employ a fused multiply-add
+  // instruction which causes rounding asymmetry and reduces precision.
+  // http://crbug.com/401117.
+  EXPECT_FLOAT_WITHIN_EPSILON_OF(polygon_a.normal().x(), 0);
+  EXPECT_FLOAT_WITHIN_EPSILON_OF(polygon_a.normal().y(), 0);
+  EXPECT_FLOAT_WITHIN_EPSILON_OF(polygon_a.normal().z(), -1);
 }
 
 }  // namespace
 }  // namespace cc