cc: Remove memory state from tile management

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"
 
 namespace cc {
 namespace {
 
 class FakePicturePileImpl : public PicturePileImpl {
  public:
   FakePicturePileImpl() : PicturePileImpl(false) {
@@ skipping 31 matching lines @@
             0) {}
 };
 
 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) {
-    tile_manager_ = make_scoped_ptr(new FakeTileManager(&tile_manager_client_));
+    output_surface_ = FakeOutputSurface::Create3d();
+    resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
+    tile_manager_ = make_scoped_ptr(
+        new FakeTileManager(&tile_manager_client_, resource_provider_.get()));
 
     GlobalStateThatImpactsTilePriority state;
     gfx::Size tile_size = settings_.default_tile_size;
     state.memory_limit_in_bytes =
         max_memory_tiles * 4 * tile_size.width() * tile_size.height();
     state.memory_limit_policy = memory_limit_policy;
     state.tree_priority = tree_priority;
 
     tile_manager_->SetGlobalState(state);
     picture_pile_ = make_scoped_refptr(new FakePicturePileImpl());
@@ skipping 29 matching lines @@
 
   FakeTileManager* tile_manager() {
     return tile_manager_.get();
   }
 
   int AssignedMemoryCounts(const TileVector& tiles) {
     int has_memory_count = 0;
     for (TileVector::const_iterator it = tiles.begin();
          it != tiles.end();
          ++it) {
-      if ((*it)->IsAssignedGpuMemory())
+      if ((*it)->HasRasterTaskForTesting())
         ++has_memory_count;
+      (*it)->ResetRasterTaskForTesting();
     }
     return has_memory_count;
   }
 
  private:
   FakeTileManagerClient tile_manager_client_;
   LayerTreeSettings settings_;
   scoped_ptr<FakeTileManager> tile_manager_;
   scoped_refptr<FakePicturePileImpl> picture_pile_;
+  scoped_ptr<FakeOutputSurface> output_surface_;
+  scoped_ptr<ResourceProvider> resource_provider_;
 };
 
 TEST_F(TileManagerTest, EnoughMemoryAllowAnything) {
   // A few tiles of each type of priority, with enough memory for all tiles.
 
   Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
   TileVector active_pending_soon = CreateTiles(
       3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->ManageTiles();
 
   EXPECT_EQ(3, AssignedMemoryCounts(active_now));
   EXPECT_EQ(3, AssignedMemoryCounts(pending_now));
   EXPECT_EQ(3, AssignedMemoryCounts(active_pending_soon));
   EXPECT_EQ(1, AssignedMemoryCounts(never_bin));
 
   active_now.clear();
   pending_now.clear();
   active_pending_soon.clear();
   never_bin.clear();
+
   TearDown();
 }
 
 TEST_F(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // with the exception of never bin.
 
   Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
@@ skipping 150 matching lines @@
   EXPECT_EQ(4, AssignedMemoryCounts(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCounts(pending_tree_tiles));
 
   pending_tree_tiles.clear();
   active_tree_tiles.clear();
   TearDown();
 }
 
 }  // namespace
 }  // namespace cc