Re-land: cc: Examine layers to determine if we're ready to activate.

cc/resources/tile_manager.h

 // 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.
 
 #ifndef CC_RESOURCES_TILE_MANAGER_H_
 #define CC_RESOURCES_TILE_MANAGER_H_
 
 #include <deque>
 #include <queue>
 #include <set>
@@ skipping 137 matching lines @@
     std::vector<PairedPictureLayerIterator> paired_iterators_;
     std::vector<PairedPictureLayerIterator*> iterator_heap_;
     TreePriority tree_priority_;
     EvictionOrderComparator comparator_;
 
     DISALLOW_COPY_AND_ASSIGN(EvictionTileIterator);
   };
 
   static scoped_ptr<TileManager> Create(
       TileManagerClient* client,
+      base::SequencedTaskRunner* task_runner,
       ResourcePool* resource_pool,
       Rasterizer* rasterizer,
       Rasterizer* gpu_rasterizer,
-      bool use_rasterize_on_demand,
       RenderingStatsInstrumentation* rendering_stats_instrumentation);
   virtual ~TileManager();
 
   void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
 
   // Returns true when visible tiles have been initialized.
   bool UpdateVisibleTiles();
 
   scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile,
                                  const gfx::Size& tile_size,
@@ skipping 47 matching lines @@
     // Soft limit is used for resource pool such that
     // memory returns to soft limit after going over.
     if (state != global_state_) {
       global_state_ = state;
       prioritized_tiles_dirty_ = true;
     }
   }
 
  protected:
   TileManager(TileManagerClient* client,
+              base::SequencedTaskRunner* task_runner,
               ResourcePool* resource_pool,
               Rasterizer* rasterizer,
               Rasterizer* gpu_rasterizer,
-              bool use_rasterize_on_demand,
               RenderingStatsInstrumentation* rendering_stats_instrumentation);
 
   // Methods called by Tile
   friend class Tile;
   void DidChangeTilePriority(Tile* tile);
 
   void CleanUpReleasedTiles();
 
   // Overriden from RefCountedManager<Tile>:
   virtual void Release(Tile* tile) OVERRIDE;
@@ skipping 37 matching lines @@
 
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
   scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
                                                        SkPixelRef* pixel_ref);
   scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
   void UpdatePrioritizedTileSetIfNeeded();
 
+  bool IsReadyToActivate() const;
+  void ScheduleCheckIfReadyToActivate();
+  void CheckIfReadyToActivate();
+
   TileManagerClient* client_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   ResourcePool* resource_pool_;
   scoped_ptr<RasterizerDelegate> rasterizer_delegate_;
   GlobalStateThatImpactsTilePriority global_state_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
   TileMap tiles_;
 
   PrioritizedTileSet prioritized_tiles_;
   bool prioritized_tiles_dirty_;
 
@@ skipping 19 matching lines @@
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
 
   typedef base::hash_map<int, int> LayerCountMap;
   LayerCountMap used_layer_counts_;
 
   RasterTaskCompletionStats update_visible_tiles_stats_;
 
   std::vector<Tile*> released_tiles_;
 
-  bool use_rasterize_on_demand_;
-
   ResourceFormat resource_format_;
 
   // Queues used when scheduling raster tasks.
   RasterTaskQueue raster_queue_[NUM_RASTERIZER_TYPES];
 
   std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
 
   std::vector<PictureLayerImpl*> layers_;
 
+  bool check_if_ready_to_activate_pending_;
+
+  base::WeakPtrFactory<TileManager> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_