cc: Replace recorded region with direct map lookup

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 <utility>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
@@ skipping 471 matching lines @@
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 
     for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
-      gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
-          iter.full_tile_geometry_rect(), 1.f / tiling->contents_scale());
-      layer_rect.Intersect(gfx::Rect(layer_bounds));
-
-      bool in_pending = pending_pile->recorded_region().Contains(layer_rect);
-      bool in_active = active_pile->recorded_region().Contains(layer_rect);
+      bool in_pending = pending_pile->CanRaster(tiling->contents_scale(),
+                                                iter.full_tile_geometry_rect());
+      bool in_active = active_pile->CanRaster(tiling->contents_scale(),
+                                              iter.full_tile_geometry_rect());
 
       if (in_pending && !in_active)
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else if (in_active)
         EXPECT_EQ(active_pile, iter->picture_pile());
       else
         EXPECT_FALSE(*iter);
     }
   }
 }
@@ skipping 119 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> empty_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 0));
+      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float high_res_scale = 1.3f;
   float low_res_scale = high_res_scale * low_res_factor;
   float device_scale = 1.7f;
   float page_scale = 3.2f;
@@ skipping 666 matching lines @@
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  // An arbitrary bogus outside the layer recording.  Enough for the layer to
-  // think it can create tiles, but not in bounds so all tiles are null.
-  Region active_recorded_region;
-  active_recorded_region.Union(gfx::Rect(1000, 1000, 1, 1));
+  // This pile will create tilings, but has no recordings so will not create any
+  // tiles.  This is attempting to simulate scrolling past the end of recorded
+  // content on the active layer, where the recordings are so far away that
+  // no tiles are created.
   scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreatePileWithRecordedRegion(
-          tile_size, layer_bounds, active_recorded_region);
+      FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
+          tile_size, layer_bounds);
   SetupTrees(pending_pile, active_pile);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
-  // need content in order to activate.  This is attempting to simulate
-  // scrolling past the end of recorded content on the active layer.
+  // need content in order to activate.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 253 matching lines @@
   // Should still have the high-res tiling.
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
   pending_layer_->CalculateContentsScale(
       1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
   // Should still only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc