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;
   gfx::Size layer_bounds(1000, 800);
@@ skipping 120 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_);
     target_client_.SetTileSize(tile_size_);
+
+    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_.set_tile_manager(tile_manager_.get());
+    target_client_.set_tile_manager(tile_manager_.get());
+
     source_.reset(new PictureLayerTilingSet(&source_client_, source_bounds_));
     target_.reset(new PictureLayerTilingSet(&target_client_, target_bounds_));
   }
 
+  ~PictureLayerTilingSetSyncTest() {
+    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) {
+    target_client_.MarkPending();
+    source_client_.MarkActive();
     for (size_t i = 0; i < source_->num_tilings(); ++i)
-      source_->tiling_at(i)->CreateAllTilesForTesting();
+      source_->tiling_at(i)->CreateAllActiveTilesForTesting();
     for (size_t i = 0; i < target_->num_tilings(); ++i)
-      target_->tiling_at(i)->CreateAllTilesForTesting();
+      target_->tiling_at(i)->CreateAllPendingTilesForTesting();
 
     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 38 matching lines @@
       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->AllPendingTilesForTesting();
     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_;
   gfx::Size source_bounds_;
   scoped_ptr<PictureLayerTilingSet> source_;
 
   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)->CreateAllPendingTilesForTesting();
 
   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 45 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