cc: Remove max tiles and skewport constants from tiling client.

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"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
+const size_t kMaxTilesForInterestArea = 128;

[danakj, 2014/12/02 21:58:37]

kinda similar comment here.. these are somewhat meaningless for these tests i'm
guessing? maybe we can grab them from LayerTreeSettings tho? idk. Given they are
in LTSettings means the client can change them tho anyways.. so the defaults
don't necessarily matter either. /ponders

+const float kSkewportTargetTimeInSeconds = 1.0f;
+const int kSkewportExtrapolationLimitInContentPixels = 2000;
+
 TEST(PictureLayerTilingSetTest, NoResources) {
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(1000, 800);
-  auto set = PictureLayerTilingSet::Create(&client);
+  auto set = PictureLayerTilingSet::Create(
+      &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+      kSkewportExtrapolationLimitInContentPixels);
   client.SetTileSize(gfx::Size(256, 256));
 
   set->AddTiling(1.0, layer_bounds);
   set->AddTiling(1.5, layer_bounds);
   set->AddTiling(2.0, layer_bounds);
 
   float contents_scale = 2.0;
   gfx::Size content_bounds(
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
   gfx::Rect content_rect(content_bounds);
@@ skipping 17 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 set = PictureLayerTilingSet::Create(&client);
+  auto set = PictureLayerTilingSet::Create(
+      &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+      kSkewportExtrapolationLimitInContentPixels);
   set->AddTiling(2.0, layer_bounds);
   high_res_tiling = set->AddTiling(1.0, layer_bounds);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
   set->AddTiling(0.5, layer_bounds);
   low_res_tiling = set->AddTiling(0.25, layer_bounds);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
   set->AddTiling(0.125, layer_bounds);
 
   higher_than_high_res_range =
       set->GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
@@ skipping 11 matching lines @@
 
   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 = PictureLayerTilingSet::Create(&client);
+  auto set_without_low_res = PictureLayerTilingSet::Create(
+      &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+      kSkewportExtrapolationLimitInContentPixels);
   set_without_low_res->AddTiling(2.0, layer_bounds);
   high_res_tiling = set_without_low_res->AddTiling(1.0, layer_bounds);
   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);
 
   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 = PictureLayerTilingSet::Create(&client);
+  auto set_with_only_high_and_low_res = PictureLayerTilingSet::Create(
+      &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+      kSkewportExtrapolationLimitInContentPixels);
   high_res_tiling =
       set_with_only_high_and_low_res->AddTiling(1.0, layer_bounds);
   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_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);
@@ skipping 11 matching lines @@
 
   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 = PictureLayerTilingSet::Create(&client);
+  auto set_with_only_high_res = PictureLayerTilingSet::Create(
+      &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+      kSkewportExtrapolationLimitInContentPixels);
   high_res_tiling = set_with_only_high_res->AddTiling(1.0, layer_bounds);
   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);
@@ skipping 35 matching lines @@
                                  NULL,
                                  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 = PictureLayerTilingSet::Create(&client);
+    auto set = PictureLayerTilingSet::Create(
+        &client, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+        kSkewportExtrapolationLimitInContentPixels);
 
     float scale = min_scale;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
       PictureLayerTiling* tiling = set->AddTiling(scale, layer_bounds);
       tiling->CreateAllTilesForTesting();
       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
       client.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
     }
 
     float max_contents_scale = scale;
@@ skipping 58 matching lines @@
 class PictureLayerTilingSetSyncTest : public testing::Test {
  public:
   PictureLayerTilingSetSyncTest()
       : tile_size_(gfx::Size(10, 10)),
         source_bounds_(gfx::Size(30, 20)),
         target_bounds_(gfx::Size(30, 30)) {
     source_client_.SetTileSize(tile_size_);
     source_client_.set_tree(PENDING_TREE);
     target_client_.SetTileSize(tile_size_);
     target_client_.set_tree(PENDING_TREE);
-    source_ = PictureLayerTilingSet::Create(&source_client_);
-    target_ = PictureLayerTilingSet::Create(&target_client_);
+    source_ = PictureLayerTilingSet::Create(
+        &source_client_, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+        kSkewportExtrapolationLimitInContentPixels);
+    target_ = PictureLayerTilingSet::Create(
+        &target_client_, kMaxTilesForInterestArea, kSkewportTargetTimeInSeconds,
+        kSkewportExtrapolationLimitInContentPixels);
   }
 
   // Sync from source to target.
   void SyncTilings(const gfx::Size& new_bounds,
                    const Region& invalidation,
                    float minimum_scale) {
     for (size_t i = 0; i < source_->num_tilings(); ++i)
       source_->tiling_at(i)->CreateAllTilesForTesting();
     for (size_t i = 0; i < target_->num_tilings(); ++i)
       target_->tiling_at(i)->CreateAllTilesForTesting();
@@ skipping 243 matching lines @@
   std::vector<Tile*> new_tiles = target_->tiling_at(0)->AllTilesForTesting();
   for (size_t i = 0; i < original_tiles.size(); ++i) {
     std::vector<Tile*>::iterator find =
         std::find(new_tiles.begin(), new_tiles.end(), original_tiles[i]);
     EXPECT_TRUE(find == new_tiles.end());
   }
 }
 
 }  // namespace
 }  // namespace cc