Re-land: cc: Add raster finished signals to RasterWorkerPool.

cc/resources/tile_manager_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/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_tile_manager.h"
 #include "cc/test/fake_tile_manager_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 31 matching lines @@
 };
 
 class TilePriorityForNowBin : public TilePriority {
  public:
     TilePriorityForNowBin() : TilePriority(
             HIGH_RESOLUTION,
             0,
             0) {}
 };
 
+class TilePriorityRequiredForActivation : public TilePriority {
+ public:
+    TilePriorityRequiredForActivation() : TilePriority(
+            HIGH_RESOLUTION,
+            0,
+            0) {
+      required_for_activation = true;
+    }
+};
+
 class TileManagerTest : public testing::Test {
  public:
   typedef std::vector<scoped_refptr<Tile> > TileVector;
 
   void Initialize(int max_memory_tiles,
                   TileMemoryLimitPolicy memory_limit_policy,
                   TreePriority tree_priority) {
     output_surface_ = FakeOutputSurface::Create3d();
     resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
     tile_manager_ = make_scoped_ptr(
@@ skipping 41 matching lines @@
 
   FakeTileManager* tile_manager() {
     return tile_manager_.get();
   }
 
   int AssignedMemoryCount(const TileVector& tiles) {
     int has_memory_count = 0;
     for (TileVector::const_iterator it = tiles.begin();
          it != tiles.end();
          ++it) {
-      if ((*it)->HasRasterTaskForTesting())
+      if (tile_manager_->HasBeenAssignedMemory(*it))
         ++has_memory_count;
-      (*it)->ResetRasterTaskForTesting();
     }
     return has_memory_count;
   }
 
   int TilesWithLCDCount(const TileVector& tiles) {
     int has_lcd_count = 0;
     for (TileVector::const_iterator it = tiles.begin();
          it != tiles.end();
          ++it) {
       if ((*it)->GetRasterModeForTesting() == HIGH_QUALITY_RASTER_MODE)
         ++has_lcd_count;
-      (*it)->ResetRasterTaskForTesting();
     }
     return has_lcd_count;
   }
 
  private:
   FakeTileManagerClient tile_manager_client_;
   LayerTreeSettings settings_;
   scoped_ptr<FakeTileManager> tile_manager_;
   scoped_refptr<FakePicturePileImpl> picture_pile_;
   scoped_ptr<FakeOutputSurface> output_surface_;
@@ skipping 77 matching lines @@
 
   tile_manager()->ManageTiles();
 
   EXPECT_EQ(0, AssignedMemoryCount(active_now));
   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 }
 
 TEST_F(TileManagerTest, PartialOOMMemoryToPending) {
-  // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
-  // but only enough memory for 8 tiles. The result is all pending tree tiles
-  // get memory, and 3 of the active tree tiles get memory.
+  // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
+  // required for activation, but only enough memory for 8 tiles. The result
+  // is all pending tree tiles get memory, and 3 of the active tree tiles
+  // get memory.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
   tile_manager()->ManageTiles();
 
+  EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
+  EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
+
+  tile_manager()->ReassignMemoryToOOMTilesRequiredForActivation();
+
   EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_F(TileManagerTest, PartialOOMMemoryToActive) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
   // but only enough memory for 8 tiles. The result is all active tree tiles
   // get memory, and 3 of the pending tree tiles get memory.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForNowBin(), TilePriority());
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityForNowBin());
 
   tile_manager()->ManageTiles();
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_F(TileManagerTest, TotalOOMMemoryToPending) {
-  // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
-  // but only enough memory for 4 tiles. The result is 4 pending tree tiles
-  // get memory, and none of the active tree tiles get memory.
+  // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
+  // required for activation, but only enough memory for 4 tiles. The result
+  // is 4 pending tree tiles get memory, and none of the active tree tiles
+  // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
   tile_manager()->ManageTiles();
 
+  EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
+  EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
+
+  tile_manager()->ReassignMemoryToOOMTilesRequiredForActivation();
+
   EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_F(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
-  // 5 tiles on active tree soon bin, 5 tiles on pending tree now bin,
-  // but only enough memory for 4 tiles. The result is 4 pending tree tiles
-  // get memory, and none of the active tree tiles get memory.
+  // 5 tiles on active tree soon bin, 5 tiles on pending tree that are
+  // required for activation, but only enough memory for 4 tiles. The result
+  // is 4 pending tree tiles get memory, and none of the active tree tiles
+  // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForSoonBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 
   tile_manager()->ManageTiles();
 
+  EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
+  EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
+
+  tile_manager()->ReassignMemoryToOOMTilesRequiredForActivation();
+
   EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_F(TileManagerTest, TotalOOMMemoryToActive) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
   // but only enough memory for 4 tiles. The result is 5 active tree tiles
   // get memory, and none of the pending tree tiles get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
@@ skipping 143 matching lines @@
   }
 
   tile_manager()->ManageTiles();
 
   EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles));
   EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles));
 }
 
 }  // namespace
 }  // namespace cc