Rendering context information added to SharedQuadState

cc/layers/layer_position_constraint_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 "cc/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 void SetLayerPropertiesForTesting(LayerImpl* layer,
                                   const gfx::Transform& transform,
                                   const gfx::Point3F& transform_origin,
                                   const gfx::PointF& position,
                                   const gfx::Size& bounds,
-                                  bool flatten_transform,
-                                  bool is_3d_sorted) {
+                                  bool flatten_transform) {
   layer->SetTransform(transform);
   layer->SetTransformOrigin(transform_origin);
   layer->SetPosition(position);
   layer->SetBounds(bounds);
   layer->SetShouldFlattenTransform(flatten_transform);
-  layer->SetIs3dSorted(is_3d_sorted);
   layer->SetContentBounds(bounds);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     LayerImpl* page_scale_application_layer,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
   std::vector<LayerImpl*> dummy_render_surface_layer_list;
@@ skipping 46 matching lines @@
     gfx::Transform IdentityMatrix;
     gfx::Point3F transform_origin;
     gfx::PointF position;
     gfx::Size bounds(200, 200);
     gfx::Size clip_bounds(100, 100);
     SetLayerPropertiesForTesting(scroll_layer.get(),
                                  IdentityMatrix,
                                  transform_origin,
                                  position,
                                  bounds,
-                                 true,
-                                 false);
-    SetLayerPropertiesForTesting(child.get(),
-                                 IdentityMatrix,
-                                 transform_origin,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
+                                 true);
+    SetLayerPropertiesForTesting(
+        child.get(), IdentityMatrix, transform_origin, position, bounds, true);
     SetLayerPropertiesForTesting(grand_child.get(),
                                  IdentityMatrix,
                                  transform_origin,
                                  position,
                                  bounds,
-                                 true,
-                                 false);
+                                 true);
     SetLayerPropertiesForTesting(great_grand_child.get(),
                                  IdentityMatrix,
                                  transform_origin,
                                  position,
                                  bounds,
-                                 true,
-                                 false);
+                                 true);
 
     root->SetBounds(clip_bounds);
     scroll_layer->SetScrollClipLayer(root->id());
     child->SetScrollClipLayer(root->id());
     grand_child->SetScrollClipLayer(root->id());
 
     grand_child->AddChild(great_grand_child.Pass());
     child->AddChild(grand_child.Pass());
     scroll_layer->AddChild(child.Pass());
     root->AddChild(scroll_layer.Pass());
@@ skipping 605 matching lines @@
   // Add one more layer to the test tree for this scenario.
   {
     gfx::Transform identity;
     scoped_ptr<LayerImpl> fixed_position_child =
         LayerImpl::Create(host_impl_.active_tree(), 5);
     SetLayerPropertiesForTesting(fixed_position_child.get(),
                                  identity,
                                  gfx::Point3F(),
                                  gfx::PointF(),
                                  gfx::Size(100, 100),
-                                 true,
-                                 false);
+                                 true);
     great_grand_child->AddChild(fixed_position_child.Pass());
   }
   LayerImpl* fixed_position_child = great_grand_child->children()[0];
 
   // Actually set up the scenario here.
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child->SetForceRenderSurface(true);
   great_grand_child->SetPosition(gfx::PointF(40.f, 60.f));
   great_grand_child->SetForceRenderSurface(true);
@@ skipping 404 matching lines @@
                                   fixed_to_container1->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
                                   container2->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
                                   fixed_to_container2->draw_transform());
 }
 }  // namespace
 }  // namespace cc