c:: Give the raster source to the PictureLayerTilings.

cc/resources/picture_layer_tiling_set_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/resources/picture_layer_tiling_set.h"
 
 #include <map>
 #include <vector>
 
 #include "cc/resources/resource_provider.h"
@@ skipping 16 matching lines @@
       defaults.skewport_target_time_in_seconds,
       defaults.skewport_extrapolation_limit_in_content_pixels);
 }
 
 TEST(PictureLayerTilingSetTest, NoResources) {
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(1000, 800);
   auto set = CreateTilingSet(&client);
   client.SetTileSize(gfx::Size(256, 256));
 
-  set->AddTiling(1.0, layer_bounds);
-  set->AddTiling(1.5, layer_bounds);
-  set->AddTiling(2.0, layer_bounds);
+  auto pile =

[tfarina, 2014/12/19 17:18:11]

I know auto is allowed now that we are using C++11, but I fear it makes code
harder to read. Without looking at CreateEmptyPileWithDefaultTileSize(), I have
no idea what it returns. A pointer, a reference, a value? To what type?

That is what I don't like in languages like Python and Javascript, the like of
type safety.

[danakj, 2014/12/19 17:22:07]

FWIW Foo::Create() methods always return smart pointers in cc/ at least.
This doesn't change type safety, auto will pick a fixed type.

[enne (OOO), 2014/12/19 18:02:55]

+1 to auto

[tfarina, 2014/12/19 18:11:34]

Ouch :(

[danakj, 2014/12/19 18:26:11]

Sorry :/ Thank you for bringing it up, we need to be careful to not go overboard
on auto. I think here the return type is in the function call since it's a
Create() method. A general GetFooBar() seems much less so, it could be a raw
pointer or not, for example.

+      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(layer_bounds);
+
+  set->AddTiling(1.0, pile);
+  set->AddTiling(1.5, pile);
+  set->AddTiling(2.0, pile);
 
   float contents_scale = 2.0;
   gfx::Size content_bounds(
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
   gfx::Rect content_rect(content_bounds);
 
   Region remaining(content_rect);
   PictureLayerTilingSet::CoverageIterator iter(set.get(), contents_scale,
                                                content_rect, contents_scale);
   for (; iter; ++iter) {
@@ skipping 12 matching lines @@
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(10, 10);
   PictureLayerTilingSet::TilingRange higher_than_high_res_range(0, 0);
   PictureLayerTilingSet::TilingRange high_res_range(0, 0);
   PictureLayerTilingSet::TilingRange between_high_and_low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange lower_than_low_res_range(0, 0);
   PictureLayerTiling* high_res_tiling;
   PictureLayerTiling* low_res_tiling;
 
+  auto pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+
   auto set = CreateTilingSet(&client);
-  set->AddTiling(2.0, layer_bounds);
-  high_res_tiling = set->AddTiling(1.0, layer_bounds);
+  set->AddTiling(2.0, pile);
+  high_res_tiling = set->AddTiling(1.0, pile);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set->AddTiling(0.5, layer_bounds);
-  low_res_tiling = set->AddTiling(0.25, layer_bounds);
+  set->AddTiling(0.5, pile);
+  low_res_tiling = set->AddTiling(0.25, pile);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
-  set->AddTiling(0.125, layer_bounds);
+  set->AddTiling(0.125, pile);
 
   higher_than_high_res_range =
       set->GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
   high_res_range = set->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
   between_high_and_low_res_range =
       set->GetTilingRange(PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(3u, between_high_and_low_res_range.end);
 
   low_res_range = set->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(3u, low_res_range.start);
   EXPECT_EQ(4u, low_res_range.end);
 
   lower_than_low_res_range =
       set->GetTilingRange(PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(4u, lower_than_low_res_range.start);
   EXPECT_EQ(5u, lower_than_low_res_range.end);
 
   auto set_without_low_res = CreateTilingSet(&client);
-  set_without_low_res->AddTiling(2.0, layer_bounds);
-  high_res_tiling = set_without_low_res->AddTiling(1.0, layer_bounds);
+  set_without_low_res->AddTiling(2.0, pile);
+  high_res_tiling = set_without_low_res->AddTiling(1.0, pile);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set_without_low_res->AddTiling(0.5, layer_bounds);
-  set_without_low_res->AddTiling(0.25, layer_bounds);
+  set_without_low_res->AddTiling(0.5, pile);
+  set_without_low_res->AddTiling(0.25, pile);
 
   higher_than_high_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
   high_res_range =
       set_without_low_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
   between_high_and_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(4u, between_high_and_low_res_range.end);
 
   low_res_range =
       set_without_low_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 
   lower_than_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
   auto set_with_only_high_and_low_res = CreateTilingSet(&client);
-  high_res_tiling =
-      set_with_only_high_and_low_res->AddTiling(1.0, layer_bounds);
+  high_res_tiling = set_with_only_high_and_low_res->AddTiling(1.0, pile);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  low_res_tiling = set_with_only_high_and_low_res->AddTiling(0.5, layer_bounds);
+  low_res_tiling = set_with_only_high_and_low_res->AddTiling(0.5, pile);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
 
   higher_than_high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
   high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
   EXPECT_EQ(1u, high_res_range.end);
 
   between_high_and_low_res_range =
       set_with_only_high_and_low_res->GetTilingRange(
           PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(0u, between_high_and_low_res_range.end -
                     between_high_and_low_res_range.start);
 
   low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(1u, low_res_range.start);
   EXPECT_EQ(2u, low_res_range.end);
 
   lower_than_low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
   auto set_with_only_high_res = CreateTilingSet(&client);
-  high_res_tiling = set_with_only_high_res->AddTiling(1.0, layer_bounds);
+  high_res_tiling = set_with_only_high_res->AddTiling(1.0, pile);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 
   higher_than_high_res_range = set_with_only_high_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
   high_res_range =
       set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
@@ skipping 35 matching lines @@
                                  NULL,
                                  0,
                                  false,
                                  1);
 
     FakePictureLayerTilingClient client(resource_provider.get());
     client.SetTileSize(gfx::Size(256, 256));
     client.set_tree(PENDING_TREE);
     gfx::Size layer_bounds(1000, 800);
     auto set = CreateTilingSet(&client);
+    auto pile =
+        FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
 
     float scale = min_scale;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
-      PictureLayerTiling* tiling = set->AddTiling(scale, layer_bounds);
+      PictureLayerTiling* tiling = set->AddTiling(scale, pile);
       tiling->CreateAllTilesForTesting();
       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
       client.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
     }
 
     float max_contents_scale = scale;
     gfx::Size content_bounds(
         gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, max_contents_scale)));
     gfx::Rect content_rect(content_bounds);
 
@@ skipping 54 matching lines @@
 TEST(PictureLayerTilingSetTest, TileSizeChange) {
   FakePictureLayerTilingClient pending_client;
   FakePictureLayerTilingClient active_client;
   auto pending_set =
       PictureLayerTilingSet::Create(&pending_client, 1000, 1.f, 1000);
   auto active_set =
       PictureLayerTilingSet::Create(&active_client, 1000, 1.f, 1000);
 
   gfx::Size layer_bounds(100, 100);
   auto pile =
-      FakePicturePileImpl::CreateEmptyPile(gfx::Size(77, 77), layer_bounds);
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
 
   gfx::Size tile_size1(10, 10);
   gfx::Size tile_size2(30, 30);
   gfx::Size tile_size3(20, 20);
 
   pending_client.SetTileSize(tile_size1);
-  pending_set->AddTiling(1.f, layer_bounds);
+  pending_set->AddTiling(1.f, pile);
   // New tilings get the correct tile size.
   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 
   // Set some expected things for the tiling set to function.
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 1.0,
                                     Occlusion(), false);
@@ skipping 73 matching lines @@
 TEST(PictureLayerTilingSetTest, MaxContentScale) {
   FakePictureLayerTilingClient pending_client;
   FakePictureLayerTilingClient active_client;
   auto pending_set =
       PictureLayerTilingSet::Create(&pending_client, 1000, 1.f, 1000);
   auto active_set =
       PictureLayerTilingSet::Create(&active_client, 1000, 1.f, 1000);
 
   gfx::Size layer_bounds(100, 105);
   auto pile =
-      FakePicturePileImpl::CreateEmptyPile(gfx::Size(77, 77), layer_bounds);
+      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(layer_bounds);
 
   // Tilings can be added of any scale, the tiling client can controls this.
-  pending_set->AddTiling(1.f, layer_bounds);
-  pending_set->AddTiling(2.f, layer_bounds);
-  pending_set->AddTiling(3.f, layer_bounds);
+  pending_set->AddTiling(1.f, pile);
+  pending_set->AddTiling(2.f, pile);
+  pending_set->AddTiling(3.f, pile);
 
   // Set some expected things for the tiling set to function.
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   // Update to a new source frame with a max content scale that is larger than
   // everything.
   float max_content_scale = 3.f;
   pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
                                                   1.f, max_content_scale);
@@ skipping 18 matching lines @@
 
   // Clone from the pending to the active tree with the same max content size.
   active_set->UpdateTilingsToCurrentRasterSource(
       pile.get(), pending_set.get(), Region(), 1.f, max_content_scale);
   // All the tilings are on the active tree.
   EXPECT_EQ(2u, active_set->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc