CC Animation: Erase cc::LayerSettings everywhere.

cc/tiles/tile_manager_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/playback/display_list_raster_source.h"
 #include "cc/playback/display_list_recording_source.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_display_list_raster_source.h"
 #include "cc/test/fake_display_list_recording_source.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/fake_tile_manager.h"
-#include "cc/test/layer_tree_settings_for_testing.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_tile_priorities.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace cc {
 namespace {
 
-class LowResTilingsSettings : public LayerTreeSettingsForTesting {
+class LowResTilingsSettings : public LayerTreeSettings {
  public:
   LowResTilingsSettings() {
     create_low_res_tiling = true;
   }
 };
 
 class TileManagerTilePriorityQueueTest : public testing::Test {
  public:
   TileManagerTilePriorityQueueTest()
       : memory_limit_policy_(ALLOW_ANYTHING),
@@ skipping 1074 matching lines @@
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(50, 50, 500, 500);
   gfx::Size layer_bounds(1600, 1600);
 
   float inset = PictureLayerTiling::CalculateSoonBorderDistance(viewport, 1.0f);
   gfx::Rect soon_rect = viewport;
   soon_rect.Inset(-inset, -inset);
 
   client.SetTileSize(gfx::Size(30, 30));
-  LayerTreeSettingsForTesting settings;
+  LayerTreeSettings settings;
 
   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
       ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
       settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_content_pixels);
 
   scoped_refptr<FakeDisplayListRasterSource> raster_source =
       FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
@@ skipping 88 matching lines @@
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueMovingViewport) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(50, 0, 100, 100);
   gfx::Rect moved_viewport(50, 0, 100, 500);
   gfx::Size layer_bounds(1000, 1000);
 
   client.SetTileSize(gfx::Size(30, 30));
-  LayerTreeSettingsForTesting settings;
+  LayerTreeSettings settings;
 
   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
       ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
       settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_content_pixels);
 
   scoped_refptr<FakeDisplayListRasterSource> raster_source =
       FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
@@ skipping 254 matching lines @@
 }
 
 // TODO(vmpstr): Merge TileManagerTest and TileManagerTilePriorityQueueTest.
 class TileManagerTest : public testing::Test {
  public:
   TileManagerTest()
       : output_surface_(FakeOutputSurface::CreateSoftware(
             make_scoped_ptr(new SoftwareOutputDevice))) {}
 
   void SetUp() override {
-    LayerTreeSettingsForTesting settings;
+    LayerTreeSettings settings;
     CustomizeSettings(&settings);
     host_impl_.reset(new MockLayerTreeHostImpl(settings, &task_runner_provider_,
                                                &shared_bitmap_manager_,
                                                &task_graph_runner_));
     host_impl_->SetVisible(true);
     host_impl_->InitializeRenderer(output_surface_.get());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
@@ skipping 44 matching lines @@
     // Add tilings/tiles for the layer.
     bool update_lcd_text = false;
     host_impl_->pending_tree()->BuildPropertyTreesForTesting();
     host_impl_->pending_tree()->UpdateDrawProperties(update_lcd_text);
   }
 
  protected:
   // MockLayerTreeHostImpl allows us to intercept tile manager callbacks.
   class MockLayerTreeHostImpl : public FakeLayerTreeHostImpl {
    public:
-    MockLayerTreeHostImpl(const LayerTreeSettingsForTesting& settings,
+    MockLayerTreeHostImpl(const LayerTreeSettings& settings,
                           TaskRunnerProvider* task_runner_provider,
                           SharedBitmapManager* manager,
                           TaskGraphRunner* task_graph_runner)
         : FakeLayerTreeHostImpl(settings,
                                 task_runner_provider,
                                 manager,
                                 task_graph_runner) {}
 
     MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
   };
 
   // By default do no customization.
-  virtual void CustomizeSettings(LayerTreeSettingsForTesting* settings) {}
+  virtual void CustomizeSettings(LayerTreeSettings* settings) {}
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeImplTaskRunnerProvider task_runner_provider_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<MockLayerTreeHostImpl> host_impl_;
 };
 
 // Test to ensure that we call NotifyAllTileTasksCompleted when PrepareTiles is
 // called.
@@ skipping 181 matching lines @@
     // Just call CompleteOnOriginThread on each item in the queue. As none of
     // these items have run yet, they will be treated as cancelled tasks.
     for (const auto& node : graph->nodes) {
       static_cast<TileTask*>(node.task)->CompleteOnOriginThread(this);
     }
   }
 };
 
 class PartialRasterTileManagerTest : public TileManagerTest {
  public:
-  void CustomizeSettings(LayerTreeSettingsForTesting* settings) override {
+  void CustomizeSettings(LayerTreeSettings* settings) override {
     settings->use_partial_raster = true;
   }
 };
 
 // Ensures that if a raster task is cancelled, it gets returned to the resource
 // pool with an invalid content ID, not with its invalidated content ID.
 TEST_F(PartialRasterTileManagerTest, CancelledTasksHaveNoContentId) {
   // Create a CancellingTaskRunner and set it on the tile manager so that all
   // scheduled work is immediately cancelled.
   CancellingTileTaskRunner cancelling_runner;
@@ skipping 142 matching lines @@
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(std::move(host_impl_),
                         false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc