Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/trees/layer_sorter_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_sorter.h"
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 19 matching lines @@
   gfx::Transform neg4_translate;
   neg4_translate.Translate3d(0.0, 0.0, -4.0);
   LayerShape front(2.f, 2.f, neg4_translate);
 
   gfx::Transform neg5_translate;
   neg5_translate.Translate3d(0.0, 0.0, -5.0);
   LayerShape back(2.f, 2.f, neg5_translate);
 
   overlap_result =
       LayerSorter::CheckOverlap(&front, &back, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result);
+  EXPECT_EQ(LayerSorter::BBeforeA, overlap_result);
   EXPECT_EQ(1.f, weight);
 
   overlap_result =
       LayerSorter::CheckOverlap(&back, &front, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
+  EXPECT_EQ(LayerSorter::ABeforeB, overlap_result);
   EXPECT_EQ(1.f, weight);
 
   // One layer translated off to the right. No overlap should be detected.
   gfx::Transform right_translate;
   right_translate.Translate3d(10.0, 0.0, -5.0);
   LayerShape back_right(2.f, 2.f, right_translate);
   overlap_result =
       LayerSorter::CheckOverlap(&front, &back_right, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::NONE, overlap_result);
+  EXPECT_EQ(LayerSorter::None, overlap_result);
 
   // When comparing a layer with itself, z difference is always 0.
   overlap_result =
       LayerSorter::CheckOverlap(&front, &front, z_threshold, &weight);
   EXPECT_EQ(0.f, weight);
 }
 
 TEST(LayerSorterTest, RightAngleOverlap) {
   LayerSorter::ABCompareResult overlap_result;
   const float z_threshold = 0.1f;
   float weight = 0.f;
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(1000.0);
 
   // Two layers forming a right angle with a perspective viewing transform.
   gfx::Transform left_face_matrix;
   left_face_matrix.Translate3d(-1.0, 0.0, -5.0);
   left_face_matrix.RotateAboutYAxis(-90.0);
   left_face_matrix.Translate(-1.0, -1.0);
   LayerShape left_face(2.f, 2.f, perspective_matrix * left_face_matrix);
   gfx::Transform front_face_matrix;
   front_face_matrix.Translate3d(0.0, 0.0, -4.0);
   front_face_matrix.Translate(-1.0, -1.0);
   LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix);
 
   overlap_result =
       LayerSorter::CheckOverlap(&front_face, &left_face, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result);
+  EXPECT_EQ(LayerSorter::BBeforeA, overlap_result);
 }
 
 TEST(LayerSorterTest, IntersectingLayerOverlap) {
   LayerSorter::ABCompareResult overlap_result;
   const float z_threshold = 0.1f;
   float weight = 0.f;
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(1000.0);
 
   // Intersecting layers. An explicit order will be returned based on relative z
   // values at the overlapping features but the weight returned should be zero.
   gfx::Transform front_face_matrix;
   front_face_matrix.Translate3d(0.0, 0.0, -4.0);
   front_face_matrix.Translate(-1.0, -1.0);
   LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix);
 
   gfx::Transform through_matrix;
   through_matrix.Translate3d(0.0, 0.0, -4.0);
   through_matrix.RotateAboutYAxis(45.0);
   through_matrix.Translate(-1.0, -1.0);
   LayerShape rotated_face(2.f, 2.f, perspective_matrix * through_matrix);
   overlap_result = LayerSorter::CheckOverlap(&front_face,
                                              &rotated_face,
                                              z_threshold,
                                              &weight);
-  EXPECT_NE(LayerSorter::NONE, overlap_result);
+  EXPECT_NE(LayerSorter::None, overlap_result);
   EXPECT_EQ(0.f, weight);
 }
 
 TEST(LayerSorterTest, LayersAtAngleOverlap) {
   LayerSorter::ABCompareResult overlap_result;
   const float z_threshold = 0.1f;
   float weight = 0.f;
 
   // Trickier test with layers at an angle.
   //
@@ skipping 17 matching lines @@
   transform_b.Translate(-4.0, -10.0);
   LayerShape layer_b(8.f, 20.f, transform_b);
 
   gfx::Transform transform_c;
   transform_c.RotateAboutYAxis(40.0);
   transform_c.Translate(-4.0, -10.0);
   LayerShape layer_c(8.f, 20.f, transform_c);
 
   overlap_result =
       LayerSorter::CheckOverlap(&layer_a, &layer_c, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
+  EXPECT_EQ(LayerSorter::ABeforeB, overlap_result);
   overlap_result =
       LayerSorter::CheckOverlap(&layer_c, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
+  EXPECT_EQ(LayerSorter::ABeforeB, overlap_result);
   overlap_result =
       LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::NONE, overlap_result);
+  EXPECT_EQ(LayerSorter::None, overlap_result);
 }
 
 TEST(LayerSorterTest, LayersUnderPathologicalPerspectiveTransform) {
   LayerSorter::ABCompareResult overlap_result;
   const float z_threshold = 0.1f;
   float weight = 0.f;
 
   // On perspective projection, if w becomes negative, the re-projected point
   // will be invalid and un-usable. Correct code needs to clip away portions of
   // the geometry where w < 0. If the code uses the invalid value, it will think
@@ skipping 20 matching lines @@
 
   // Sanity check that the test case actually covers the intended scenario,
   // where part of layer B go behind the w = 0 plane.
   gfx::QuadF test_quad = gfx::QuadF(gfx::RectF(-0.5f, -0.5f, 1.f, 1.f));
   bool clipped = false;
   MathUtil::MapQuad(perspective_matrix * transform_b, test_quad, &clipped);
   ASSERT_TRUE(clipped);
 
   overlap_result =
       LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
+  EXPECT_EQ(LayerSorter::ABeforeB, overlap_result);
 }
 
 TEST(LayerSorterTest, VerifyExistingOrderingPreservedWhenNoZDiff) {
   // If there is no reason to re-sort the layers (i.e. no 3d z difference), then
   // the existing ordering provided on input should be retained. This test
   // covers the fix in https://bugs.webkit.org/show_bug.cgi?id=75046. Before
   // this fix, ordering was accidentally reversed, causing bugs in z-index
   // ordering on websites when preserves3D triggered the LayerSorter.
 
   // Input list of layers: [1, 2, 3, 4, 5].
@@ skipping 114 matching lines @@
   layer_sorter.Sort(layer_list.begin(), layer_list.end());
 
   ASSERT_EQ(2u, layer_list.size());
   EXPECT_EQ(1, layer_list[0]->id());
   EXPECT_EQ(2, layer_list[1]->id());
 }
 
 }  // namespace
 }  // namespace cc