Update from https://crrev.com/309415

cc/resources/tile_manager_perftest.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 "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_impl_proxy.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_pile_impl.h"
 #include "cc/test/fake_tile_manager.h"
 #include "cc/test/fake_tile_manager_client.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_tile_priorities.h"
 #include "cc/trees/layer_tree_impl.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
-
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
 class FakeTileTaskRunnerImpl : public TileTaskRunner, public TileTaskClient {
  public:
   // Overridden from TileTaskRunner:
   void SetClient(TileTaskRunnerClient* client) override {}
@@ skipping 118 matching lines @@
 
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_root_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
   }
 
-  void CreateHighLowResAndSetAllTilesVisible() {
-    // Active layer must get updated first so pending layer can share from it.
-    active_root_layer_->CreateDefaultTilingsAndTiles();
-    active_root_layer_->SetAllTilesVisible();
-    pending_root_layer_->CreateDefaultTilingsAndTiles();
-    pending_root_layer_->SetAllTilesVisible();
-  }
-
   void RunRasterQueueConstructTest(const std::string& test_name,
                                    int layer_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
     int priority_count = 0;
 
-    std::vector<LayerImpl*> layers = CreateLayers(layer_count, 10);
+    std::vector<FakePictureLayerImpl*> layers = CreateLayers(layer_count, 10);
     bool resourceless_software_draw = false;
-    for (unsigned i = 0; i < layers.size(); ++i) {
-      layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
-    }
+    for (const auto& layer : layers)
+      layer->UpdateTiles(Occlusion(), resourceless_software_draw);
 
     timer_.Reset();
     do {
       RasterTilePriorityQueue queue;
       host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tile_manager_raster_tile_queue_construct",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
   void RunRasterQueueConstructAndIterateTest(const std::string& test_name,
                                              int layer_count,
-                                             unsigned tile_count) {
+                                             int tile_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
 
-    std::vector<LayerImpl*> layers = CreateLayers(layer_count, 100);
+    std::vector<FakePictureLayerImpl*> layers = CreateLayers(layer_count, 100);
     bool resourceless_software_draw = false;
-    for (unsigned i = 0; i < layers.size(); ++i) {
-      layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
-    }
+    for (const auto& layer : layers)
+      layer->UpdateTiles(Occlusion(), resourceless_software_draw);
 
     int priority_count = 0;
     timer_.Reset();
     do {
       int count = tile_count;
       RasterTilePriorityQueue queue;
       host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
       while (count--) {
         ASSERT_FALSE(queue.IsEmpty());
         ASSERT_TRUE(queue.Top() != NULL);
@@ skipping 12 matching lines @@
         true);
   }
 
   void RunEvictionQueueConstructTest(const std::string& test_name,
                                      int layer_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
     int priority_count = 0;
 
-    std::vector<LayerImpl*> layers = CreateLayers(layer_count, 10);
+    std::vector<FakePictureLayerImpl*> layers = CreateLayers(layer_count, 10);
     bool resourceless_software_draw = false;
-    for (unsigned i = 0; i < layers.size(); ++i) {
-      FakePictureLayerImpl* layer =
-          static_cast<FakePictureLayerImpl*>(layers[i]);
+    for (const auto& layer : layers) {
       layer->UpdateTiles(Occlusion(), resourceless_software_draw);
-      for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
+      for (size_t i = 0; i < layer->num_tilings(); ++i) {
         tile_manager()->InitializeTilesWithResourcesForTesting(
-            layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
+            layer->tilings()->tiling_at(i)->AllTilesForTesting());
       }
     }
 
     timer_.Reset();
     do {
       EvictionTilePriorityQueue queue;
       host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tile_manager_eviction_tile_queue_construct",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
   void RunEvictionQueueConstructAndIterateTest(const std::string& test_name,
                                                int layer_count,
-                                               unsigned tile_count) {
+                                               int tile_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
     int priority_count = 0;
 
-    std::vector<LayerImpl*> layers = CreateLayers(layer_count, tile_count);
+    std::vector<FakePictureLayerImpl*> layers =
+        CreateLayers(layer_count, tile_count);
     bool resourceless_software_draw = false;
-    for (unsigned i = 0; i < layers.size(); ++i) {
-      FakePictureLayerImpl* layer =
-          static_cast<FakePictureLayerImpl*>(layers[i]);
+    for (const auto& layer : layers) {
       layer->UpdateTiles(Occlusion(), resourceless_software_draw);
-      for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
+      for (size_t i = 0; i < layer->num_tilings(); ++i) {
         tile_manager()->InitializeTilesWithResourcesForTesting(
-            layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
+            layer->tilings()->tiling_at(i)->AllTilesForTesting());
       }
     }
 
     timer_.Reset();
     do {
       int count = tile_count;
       EvictionTilePriorityQueue queue;
       host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
       while (count--) {
         ASSERT_FALSE(queue.IsEmpty());
         ASSERT_TRUE(queue.Top() != NULL);
         queue.Pop();
       }
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult(
         "tile_manager_eviction_tile_queue_construct_and_iterate",
         "",
         test_name,
         timer_.LapsPerSecond(),
         "runs/s",
         true);
   }
 
-  std::vector<LayerImpl*> CreateLayers(int layer_count,
-                                       int tiles_per_layer_count) {
+  std::vector<FakePictureLayerImpl*> CreateLayers(int layer_count,
+                                                  int tiles_per_layer_count) {
     // Compute the width/height required for high res to get
     // tiles_per_layer_count tiles.
     float width = std::sqrt(static_cast<float>(tiles_per_layer_count));
     float height = tiles_per_layer_count / width;
 
     // Adjust the width and height to account for the fact that tiles
     // are bigger than 1x1. Also, account for the fact that that we
     // will be creating one high res and one low res tiling. That is,
     // width and height should be smaller by sqrt(1 + low_res_scale).
     // This gives us _approximately_ correct counts.
     width *= settings_.default_tile_size.width() /
              std::sqrt(1 + settings_.low_res_contents_scale_factor);
     height *= settings_.default_tile_size.height() /
               std::sqrt(1 + settings_.low_res_contents_scale_factor);
 
     // Ensure that we start with blank trees and no tiles.
     host_impl_.ResetTreesForTesting();
     tile_manager()->FreeResourcesAndCleanUpReleasedTilesForTesting();
 
     gfx::Size layer_bounds(width, height);
     gfx::Size viewport(width / 5, height / 5);
     host_impl_.SetViewportSize(viewport);
     SetupDefaultTreesWithFixedTileSize(layer_bounds,
                                        settings_.default_tile_size);
 
-    active_root_layer_->CreateDefaultTilingsAndTiles();
-    pending_root_layer_->CreateDefaultTilingsAndTiles();
-
-    std::vector<LayerImpl*> layers;
+    std::vector<FakePictureLayerImpl*> layers;
 
     // Pending layer counts as one layer.
     layers.push_back(pending_root_layer_);
     int next_id = id_ + 1;
 
     // Create the rest of the layers as children of the root layer.
     scoped_refptr<FakePicturePileImpl> pile =
         FakePicturePileImpl::CreateFilledPile(kDefaultTileSize, layer_bounds);
     while (static_cast<int>(layers.size()) < layer_count) {
       scoped_ptr<FakePictureLayerImpl> layer =
           FakePictureLayerImpl::CreateWithRasterSource(
               host_impl_.pending_tree(), next_id, pile);
       layer->SetBounds(layer_bounds);
+      layer->SetDrawsContent(true);
       layers.push_back(layer.get());
       pending_root_layer_->AddChild(layer.Pass());
-
-      FakePictureLayerImpl* fake_layer =
-          static_cast<FakePictureLayerImpl*>(layers.back());
-
-      fake_layer->SetDrawsContent(true);
-      fake_layer->CreateDefaultTilingsAndTiles();
       ++next_id;
     }
 
+    host_impl_.pending_tree()->UpdateDrawProperties();
+    for (FakePictureLayerImpl* layer : layers)
+      layer->CreateAllTiles();
+
     return layers;
   }
 
   GlobalStateThatImpactsTilePriority GlobalStateForTest() {
     GlobalStateThatImpactsTilePriority state;
     gfx::Size tile_size = settings_.default_tile_size;
     state.soft_memory_limit_in_bytes =
         10000u * 4u *
         static_cast<size_t>(tile_size.width() * tile_size.height());
     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
     state.num_resources_limit = 10000;
     state.memory_limit_policy = ALLOW_ANYTHING;
     state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
     return state;
   }
 
   void RunPrepareTilesTest(const std::string& test_name,
                            int layer_count,
                            int approximate_tile_count_per_layer) {
-    std::vector<LayerImpl*> layers =
+    std::vector<FakePictureLayerImpl*> layers =
         CreateLayers(layer_count, approximate_tile_count_per_layer);
     timer_.Reset();
     bool resourceless_software_draw = false;
     do {
       BeginFrameArgs args =
           CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
       host_impl_.UpdateCurrentBeginFrameArgs(args);
-      for (unsigned i = 0; i < layers.size(); ++i) {
-        layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
-      }
+      for (const auto& layer : layers)
+        layer->UpdateTiles(Occlusion(), resourceless_software_draw);
 
       GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
       tile_manager()->PrepareTiles(global_state);
       tile_manager()->UpdateVisibleTiles();
       timer_.NextLap();
       host_impl_.ResetCurrentBeginFrameArgsForNextFrame();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("prepare_tiles", "", test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
@@ skipping 68 matching lines @@
   RunEvictionQueueConstructAndIterateTest("10_32", 10, 32);
   RunEvictionQueueConstructAndIterateTest("10_64", 10, 64);
   RunEvictionQueueConstructAndIterateTest("10_128", 10, 128);
   RunEvictionQueueConstructAndIterateTest("50_16", 50, 16);
   RunEvictionQueueConstructAndIterateTest("50_32", 50, 32);
   RunEvictionQueueConstructAndIterateTest("50_64", 50, 64);
   RunEvictionQueueConstructAndIterateTest("50_128", 50, 128);
 }
 
 }  // namespace
-
 }  // namespace cc