cc: Added tile bundles

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_pool.h"
 #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/fake_tile_manager.h"
 #include "cc/test/fake_tile_manager_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
 TEST(PictureLayerTilingSetTest, NoResources) {
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   gfx::Size layer_bounds(1000, 800);
   PictureLayerTilingSet set(&client, layer_bounds);
   client.SetTileSize(gfx::Size(256, 256));
 
   set.AddTiling(1.0);
   set.AddTiling(1.5);
   set.AddTiling(2.0);
 
   float contents_scale = 2.0;
   gfx::Size content_bounds(
@@ skipping 27 matching lines @@
       float ideal_contents_scale,
       float expected_scale) {
     FakeOutputSurfaceClient output_surface_client;
     scoped_ptr<FakeOutputSurface> output_surface =
         FakeOutputSurface::Create3d();
     CHECK(output_surface->BindToClient(&output_surface_client));
 
     scoped_ptr<ResourceProvider> resource_provider =
         ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1);
 
-    FakePictureLayerTilingClient client(resource_provider.get());
+    FakeTileManagerClient tile_manager_client;
+    FakeTileManager tile_manager(&tile_manager_client, resource_provider.get());
+
+    FakePictureLayerTilingClient client(&tile_manager);
     client.SetTileSize(gfx::Size(256, 256));
     gfx::Size layer_bounds(1000, 800);
     PictureLayerTilingSet set(&client, layer_bounds);
 
     float scale = min_scale;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
       PictureLayerTiling* tiling = set.AddTiling(scale);
       tiling->CreateAllTilesForTesting();
       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
       client.tile_manager()->InitializeTilesWithResourcesForTesting(
@@ skipping 61 matching lines @@
 TEST_F(PictureLayerTilingSetTestWithResources, ManyTilings_NotEqual) {
   runTest(10, 1.f, 1.f, 4.5f, 5.f);
 }
 
 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_);
-    target_client_.SetTileSize(tile_size_);
-    source_.reset(new PictureLayerTilingSet(&source_client_, source_bounds_));
-    target_.reset(new PictureLayerTilingSet(&target_client_, target_bounds_));
+    output_surface_ = FakeOutputSurface::Create3d();
+    CHECK(output_surface_->BindToClient(&output_surface_client_));
+    resource_provider_ =
+        ResourceProvider::Create(output_surface_.get(), NULL, 0, false, 1);
+    tile_manager_ = make_scoped_ptr(
+        new FakeTileManager(&tile_manager_client_, resource_provider_.get()));
+    source_client_ =
+        make_scoped_ptr(new FakePictureLayerTilingClient(tile_manager_.get()));
+    target_client_ =
+        make_scoped_ptr(new FakePictureLayerTilingClient(tile_manager_.get()));
+
+    source_client_->SetTileSize(tile_size_);
+    target_client_->SetTileSize(tile_size_);
+
+    source_.reset(
+        new PictureLayerTilingSet(source_client_.get(), source_bounds_));
+    target_.reset(
+        new PictureLayerTilingSet(target_client_.get(), target_bounds_));
+  }
+
+  ~PictureLayerTilingSetSyncTest() {

[enne (OOO), 2013/12/03 02:28:37]

Could you just order these variables differently in the class to get the
implicit destruction order you need?

[vmpstr, 2013/12/03 18:44:43]

Done.

+    source_.reset(NULL);
+    target_.reset(NULL);
+    tile_manager_.reset(NULL);
+    resource_provider_.reset(NULL);
   }
 
   // Sync from source to target.
   void SyncTilings(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();
+      source_->tiling_at(i)->CreateTilesForTesting(ACTIVE_TREE);
     for (size_t i = 0; i < target_->num_tilings(); ++i)
-      target_->tiling_at(i)->CreateAllTilesForTesting();
+      target_->tiling_at(i)->CreateTilesForTesting(PENDING_TREE);
 
     target_->SyncTilings(
         *source_.get(), new_bounds, invalidation, minimum_scale);
   }
   void SyncTilings(gfx::Size new_bounds) {
     Region invalidation;
     SyncTilings(new_bounds, invalidation, 0.f);
   }
   void SyncTilings(gfx::Size new_bounds, const Region& invalidation) {
     SyncTilings(new_bounds, invalidation, 0.f);
@@ skipping 11 matching lines @@
     for (size_t i = 0; i < target_->num_tilings(); ++i) {
       ASSERT_GT(source_->num_tilings(), i);
       const PictureLayerTiling* source_tiling = source_->tiling_at(i);
       const PictureLayerTiling* target_tiling = target_->tiling_at(i);
       EXPECT_EQ(target_tiling->layer_bounds().ToString(),
                 new_bounds.ToString());
       EXPECT_EQ(source_tiling->contents_scale(),
                 target_tiling->contents_scale());
     }
 
-    EXPECT_EQ(source_->client(), &source_client_);
-    EXPECT_EQ(target_->client(), &target_client_);
+    EXPECT_EQ(source_->client(), source_client_.get());
+    EXPECT_EQ(target_->client(), target_client_.get());
     ValidateTargetTilingSet();
   }
 
   void ValidateTargetTilingSet() const {
     // Tilings should be sorted largest to smallest.
     if (target_->num_tilings() > 0) {
       float last_scale = target_->tiling_at(0)->contents_scale();
       for (size_t i = 1; i < target_->num_tilings(); ++i) {
         const PictureLayerTiling* target_tiling = target_->tiling_at(i);
         EXPECT_LT(target_tiling->contents_scale(), last_scale);
         last_scale = target_tiling->contents_scale();
       }
     }
 
     for (size_t i = 0; i < target_->num_tilings(); ++i)
-      ValidateTiling(target_->tiling_at(i), target_client_.pile());
+      ValidateTiling(target_->tiling_at(i), target_client_->pile());
   }
 
   void ValidateTiling(const PictureLayerTiling* tiling,
                       const PicturePileImpl* pile) const {
     if (tiling->ContentRect().IsEmpty())
       EXPECT_TRUE(tiling->live_tiles_rect().IsEmpty());
     else if (!tiling->live_tiles_rect().IsEmpty())
       EXPECT_TRUE(tiling->ContentRect().Contains(tiling->live_tiles_rect()));
 
-    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+    std::vector<Tile*> tiles = tiling->TilesForTesting(PENDING_TREE);
     for (size_t i = 0; i < tiles.size(); ++i) {
       const Tile* tile = tiles[i];
       ASSERT_TRUE(!!tile);
       EXPECT_EQ(tile->picture_pile(), pile);
       EXPECT_TRUE(tile->content_rect().Intersects(tiling->live_tiles_rect()))
           << "All tiles must be inside the live tiles rect.";
     }
 
     for (PictureLayerTiling::CoverageIterator iter(
              tiling, tiling->contents_scale(), tiling->live_tiles_rect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter) << "The live tiles rect must be full.";
     }
   }
 
   gfx::Size tile_size_;
 
-  FakePictureLayerTilingClient source_client_;
+  scoped_ptr<FakePictureLayerTilingClient> source_client_;
   gfx::Size source_bounds_;
   scoped_ptr<PictureLayerTilingSet> source_;
 
-  FakePictureLayerTilingClient target_client_;
+  scoped_ptr<FakePictureLayerTilingClient> target_client_;
   gfx::Size target_bounds_;
   scoped_ptr<PictureLayerTilingSet> target_;
+
+  FakeTileManagerClient tile_manager_client_;
+  scoped_ptr<FakeTileManager> tile_manager_;
+  scoped_ptr<ResourceProvider> resource_provider_;
+  scoped_ptr<FakeOutputSurface> output_surface_;
+  FakeOutputSurfaceClient output_surface_client_;
 };
 
 TEST_F(PictureLayerTilingSetSyncTest, EmptyBounds) {
   float source_scales[] = {1.f, 1.2f};
   for (size_t i = 0; i < arraysize(source_scales); ++i)
     source_->AddTiling(source_scales[i]);
 
   gfx::Size new_bounds;
   SyncTilings(new_bounds);
   EXPECT_EQ(target_->num_tilings(), 0u);
@@ skipping 80 matching lines @@
   SyncTilings(new_bounds, minimum_scale);
 
   EXPECT_EQ(target_->num_tilings(), 1u);
   EXPECT_EQ(target_->tiling_at(0)->contents_scale(), 2.f);
   ValidateTargetTilingSet();
 }
 
 TEST_F(PictureLayerTilingSetSyncTest, Invalidation) {
   source_->AddTiling(2.f);
   target_->AddTiling(2.f);
-  target_->tiling_at(0)->CreateAllTilesForTesting();
+  target_->tiling_at(0)->CreateTilesForTesting(PENDING_TREE);
 
   Region layer_invalidation;
   layer_invalidation.Union(gfx::Rect(0, 0, 1, 1));
   layer_invalidation.Union(gfx::Rect(0, 15, 1, 1));
   // Out of bounds layer_invalidation.
   layer_invalidation.Union(gfx::Rect(100, 100, 1, 1));
 
   Region content_invalidation;
   for (Region::Iterator iter(layer_invalidation); iter.has_rect();
        iter.next()) {
@@ skipping 23 matching lines @@
 
 TEST_F(PictureLayerTilingSetSyncTest, TileSizeChange) {
   source_->AddTiling(1.f);
   target_->AddTiling(1.f);
 
   target_->tiling_at(0)->CreateAllTilesForTesting();
   std::vector<Tile*> original_tiles =
       target_->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(original_tiles.size(), 0u);
   gfx::Size new_tile_size(100, 100);
-  target_client_.SetTileSize(new_tile_size);
+  target_client_->SetTileSize(new_tile_size);
   EXPECT_NE(target_->tiling_at(0)->tile_size().ToString(),
             new_tile_size.ToString());
 
   gfx::Size new_bounds(15, 40);
   SyncTilings(new_bounds);
   VerifyTargetEqualsSource(new_bounds);
 
   EXPECT_EQ(target_->tiling_at(0)->tile_size().ToString(),
             new_tile_size.ToString());
 
   // All old tiles should not be present in new tiles.
   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