cc: Replace render surface layer list with a render surface list

cc/trees/occlusion_tracker_unittest.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/animation/animation_host.h"
 #include "cc/base/filter_operation.h"
@@ skipping 170 matching lines @@
                                              const gfx::Size& bounds,
                                              bool opaque) {
     TestContentLayerImpl* layer =
         CreateDrawingLayer(parent, transform, position, bounds, opaque);
     layer->test_properties()->force_render_surface = true;
     return layer;
   }
 
   void DestroyLayers() {
     host_->host_impl()->active_tree()->SetRootLayerForTesting(nullptr);
-    render_surface_layer_list_impl_.clear();
+    render_surface_list_impl_.clear();
     mask_layers_.clear();
     layer_iterator_.reset();
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
   void AddCopyRequest(Layer* layer) {
     layer->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&OcclusionTrackerTest::CopyOutputCallback,
                    base::Unretained(this))));
   }
 
   void AddCopyRequest(LayerImpl* layer) {
     layer->test_properties()->copy_requests.push_back(
         CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&OcclusionTrackerTest::CopyOutputCallback,
                        base::Unretained(this))));
   }
 
   void CalcDrawEtc(TestContentLayerImpl* root) {
     root->layer_tree_impl()->BuildLayerListForTesting();
     DCHECK(root == root->layer_tree_impl()->root_layer_for_testing());
 
     // These occlusion tests attach and detach layers in multiple
     // iterations, so rebuild property trees every time.
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), &render_surface_layer_list_impl_);
+        root, root->bounds(), &render_surface_list_impl_);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     layer_iterator_ = base::MakeUnique<EffectTreeLayerListIterator>(
         host_->host_impl()->active_tree());
   }
 
   void EnterLayer(LayerImpl* layer, OcclusionTracker* occlusion) {
     ASSERT_EQ(layer_iterator_->current_layer(), layer);
     ASSERT_TRUE(layer_iterator_->state() ==
@@ skipping 67 matching lines @@
   void SetMask(LayerImpl* owning_layer, std::unique_ptr<LayerImpl> layer) {
     owning_layer->test_properties()->SetMaskLayer(std::move(layer));
   }
 
   bool opaque_layers_;
   FakeLayerTreeHostClient client_;
   TestTaskGraphRunner task_graph_runner_;
   std::unique_ptr<AnimationHost> animation_host_;
   std::unique_ptr<FakeLayerTreeHost> host_;
   // These hold ownership of the layers for the duration of the test.
-  LayerImplList render_surface_layer_list_impl_;
+  RenderSurfaceList render_surface_list_impl_;
   std::unique_ptr<EffectTreeLayerListIterator> layer_iterator_;
   LayerList mask_layers_;
   int next_layer_impl_id_;
 };
 
 #define RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)          \
   class ClassName##ImplThreadOpaqueLayers : public ClassName { \
    public: /* NOLINT(whitespace/indent) */                     \
     ClassName##ImplThreadOpaqueLayers() : ClassName(true) {}   \
   };                                                           \
@@ skipping 2113 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc