Roll Chrome into Mojo.

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 42 matching lines @@
   // Called when the visible representation of a tile might have changed. Some
   // examples are:
   // - Tile version initialized.
   // - Tile resources freed.
   // - Tile marked for on-demand raster.
   virtual void NotifyTileStateChanged(const Tile* tile) = 0;
 
   // Given an empty raster tile priority queue, this will build a priority queue
   // that will return tiles in order in which they should be rasterized.
   // Note if the queue was previous built, Reset must be called on it.
-  virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
-                                TreePriority tree_priority,
-                                RasterTilePriorityQueue::Type type) = 0;
+  virtual scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
+      TreePriority tree_priority,
+      RasterTilePriorityQueue::Type type) = 0;
 
   // Given an empty eviction tile priority queue, this will build a priority
   // queue that will return tiles in order in which they should be evicted.
   // Note if the queue was previous built, Reset must be called on it.
-  virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
-                                  TreePriority tree_priority) = 0;
+  virtual scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
+      TreePriority tree_priority) = 0;
 
  protected:
   virtual ~TileManagerClient() {}
 };
 
 struct RasterTaskCompletionStats {
   RasterTaskCompletionStats();
 
   size_t completed_count;
   size_t canceled_count;
@@ skipping 49 matching lines @@
   scoped_refptr<base::debug::ConvertableToTraceFormat> BasicStateAsValue()
       const;
   void BasicStateAsValueInto(base::debug::TracedValue* dict) const;
   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
     return memory_stats_from_last_assign_;
   }
 
   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       TileDrawInfo& draw_info = tiles[i]->draw_info();
-      draw_info.resource_ =
-          resource_pool_->AcquireResource(tiles[i]->desired_texture_size(),
-                                          resource_pool_->default_format());
+      draw_info.resource_ = resource_pool_->AcquireResource(
+          tiles[i]->desired_texture_size(),
+          tile_task_runner_->GetResourceFormat());
     }
   }
 
   void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       Tile* tile = tiles[i];
       FreeResourcesForTile(tile);
     }
   }
 
@@ skipping 86 matching lines @@
   void UpdateTileDrawInfo(Tile* tile,
                           scoped_ptr<ScopedResource> resource,
                           const RasterSource::SolidColorAnalysis& analysis);
 
   void FreeResourcesForTile(Tile* tile);
   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
   scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
                                                        SkPixelRef* pixel_ref);
   scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
 
-  void RebuildEvictionQueueIfNeeded();
-  bool FreeTileResourcesUntilUsageIsWithinLimit(const MemoryUsage& limit,
-                                                MemoryUsage* usage);
-  bool FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+  scoped_ptr<EvictionTilePriorityQueue>
+  FreeTileResourcesUntilUsageIsWithinLimit(
+      scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
+      const MemoryUsage& limit,
+      MemoryUsage* usage);
+  scoped_ptr<EvictionTilePriorityQueue>
+  FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+      scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
       const MemoryUsage& limit,
       const TilePriority& oother_priority,
       MemoryUsage* usage);
   bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority);
   bool IsReadyToActivate() const;
   bool IsReadyToDraw() const;
   void NotifyReadyToActivate();
   void NotifyReadyToDraw();
   void CheckIfReadyToActivate();
   void CheckIfReadyToDraw();
@@ skipping 21 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_;
 
-  ResourceFormat resource_format_;
-
   // Queue used when scheduling raster tasks.
   TileTaskQueue raster_queue_;
 
   std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
 
   UniqueNotifier ready_to_activate_notifier_;
   UniqueNotifier ready_to_draw_notifier_;
   UniqueNotifier ready_to_activate_check_notifier_;
   UniqueNotifier ready_to_draw_check_notifier_;
   UniqueNotifier more_tiles_need_prepare_check_notifier_;
 
-  EvictionTilePriorityQueue eviction_priority_queue_;
-  bool eviction_priority_queue_is_up_to_date_;
-
   bool did_notify_ready_to_activate_;
   bool did_notify_ready_to_draw_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_