Update from https://crrev.com/304715

cc/layers/picture_layer_impl_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/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 2265 matching lines @@
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
   // Contrived unit test of a real crash. A layer is transparent during a
   // context loss, and later becomes opaque, causing active layer SyncTiling to
   // be called.
   float new_scale = 1.f;
   active_layer_->ReleaseResources();
   pending_layer_->ReleaseResources();
-  EXPECT_FALSE(active_layer_->tilings()->TilingAtScale(new_scale));
+  EXPECT_FALSE(active_layer_->tilings()->FindTilingWithScale(new_scale));
   pending_layer_->AddTiling(new_scale);
-  EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(new_scale));
+  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(new_scale));
 
   // UpdateDrawProperties early-outs if the tree doesn't need it.  It is also
   // responsible for calling ManageTilings.  These checks verify that
   // ReleaseResources has set needs update draw properties so that the
   // new tiling gets the appropriate resolution set in ManageTilings.
   EXPECT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
   host_impl_.active_tree()->UpdateDrawProperties();
   PictureLayerTiling* high_res =
-      active_layer_->tilings()->TilingAtScale(new_scale);
+      active_layer_->tilings()->FindTilingWithScale(new_scale);
   ASSERT_TRUE(!!high_res);
   EXPECT_EQ(HIGH_RESOLUTION, high_res->resolution());
 }
 
 TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
   const float kScale = 1.f;
   pending_layer_->AddTiling(kScale);
-  EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
-  EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
+  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
 
   // Gpu rasterization is disabled by default.
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   // Toggling the gpu rasterization clears all tilings on both trees.
   host_impl_.SetUseGpuRasterization(true);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   // Make sure that we can still add tiling to the pending layer,
   // that gets synced to the active layer.
   pending_layer_->AddTiling(kScale);
-  EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
-  EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
+  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
 
   // Toggling the gpu rasterization clears all tilings on both trees.
   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
   host_impl_.SetUseGpuRasterization(false);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
   SetupPendingTree(active_pile);
   ActivateTree();
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
   SetupDrawPropertiesAndUpdateTiles(
       active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
   active_layer_->tilings()->RemoveAllTilings();
   PictureLayerTiling* tiling = active_layer_->AddTiling(0.5f);
   active_layer_->AddTiling(1.5f);
   active_layer_->AddTiling(0.25f);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   // Sanity checks.
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
-  ASSERT_EQ(tiling, active_layer_->tilings()->TilingAtScale(0.5f));
+  ASSERT_EQ(tiling, active_layer_->tilings()->FindTilingWithScale(0.5f));
 
   // Now, set the bounds to be 1x1 (so that minimum contents scale becomes
   // 1.0f). Note that we should also ensure that the pending layer needs post
   // commit initialization, since this is what would happen during commit. In
   // other words we want the pending layer to sync from the active layer.
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1, 1));
   SetupPendingTree(pending_pile);
 
   // Update the draw properties: sync from active tree should happen here.
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_FALSE(pending_layer_->needs_post_commit_initialization());
 
   // Another sanity check.
   ASSERT_EQ(1.f, pending_layer_->MinimumContentsScale());
 
   // Now we should've synced 1.5f tiling, since that's the only one that doesn't
   // violate minimum contents scale. At the same time, we should've created a
   // new high res tiling at scale 1.0f.
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
-  ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.0f));
+  ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.0f));
   EXPECT_EQ(HIGH_RESOLUTION,
-            pending_layer_->tilings()->TilingAtScale(1.0f)->resolution());
-  ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.5f));
+            pending_layer_->tilings()->FindTilingWithScale(1.0f)->resolution());
+  ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.5f));
   EXPECT_EQ(NON_IDEAL_RESOLUTION,
-            pending_layer_->tilings()->TilingAtScale(1.5f)->resolution());
+            pending_layer_->tilings()->FindTilingWithScale(1.5f)->resolution());
 }
 
 TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
 
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
@@ skipping 2110 matching lines @@
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(!test_for_solid);
 
   Region invalidation(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation, layer_bounds, layer_rect, frame_number++,
+      &client, &invalidation, false, layer_bounds, layer_rect, frame_number++,
       Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> pending_raster_source =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(pending_raster_source);
   ActivateTree();
 
   active_layer_->set_fixed_tile_size(tile_size);
   host_impl_.active_tree()->UpdateDrawProperties();
@@ skipping 46 matching lines @@
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(true);
 
   Region invalidation1(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation1, layer_bounds, layer_rect, frame_number++,
+      &client, &invalidation1, false, layer_bounds, layer_rect, frame_number++,
       Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> raster_source1 =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(raster_source1);
   ActivateTree();
   host_impl_.active_tree()->UpdateDrawProperties();
 
   // We've started with a solid layer that contains some tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_NE(0u, active_layer_->tilings()->num_tilings());
 
   client.set_fill_with_nonsolid_color(false);
 
   Region invalidation2(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation2, layer_bounds, layer_rect, frame_number++,
+      &client, &invalidation2, false, layer_bounds, layer_rect, frame_number++,
       Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> raster_source2 =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(raster_source2);
   ActivateTree();
 
   // We've switched to a solid color, so we should end up with no tilings.
   ASSERT_TRUE(active_layer_->tilings());
@@ skipping 119 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc