Added preliminary support for tile rasterization with Ganesh

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 <queue>
 #include <set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/base/ref_counted_managed.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
+#include "cc/resources/ganesh_rasterizer.h"
 #include "cc/resources/managed_tile_state.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/prioritized_tile_set.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 
 namespace cc {
 class ResourceProvider;
@@ skipping 13 matching lines @@
   size_t canceled_count;
 };
 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
     const RasterTaskCompletionStats& stats);
 
 // This class manages tiles, deciding which should get rasterized and which
 // should no longer have any memory assigned to them. Tile objects are "owned"
 // by layers; they automatically register with the manager when they are
 // created, and unregister from the manager when they are deleted.
 class CC_EXPORT TileManager : public RasterWorkerPoolClient,
+                              public GaneshRasterizerClient,
                               public RefCountedManager<Tile> {
  public:
   static scoped_ptr<TileManager> Create(
       TileManagerClient* client,
       ResourceProvider* resource_provider,
+      ContextProvider* context_provider,
       size_t num_raster_threads,
       RenderingStatsInstrumentation* rendering_stats_instrumentation,
+      bool use_ganesh,

[reveman, 2013/11/24 21:56:57]

how do we plan to mark layers/tiles as candidates for ganesh? do we need a
use_ganesh option here or can the system that marks layers as candidates take
care of this?

[slavi, 2013/11/25 23:13:14]

We need a heuristic in tile manager (search TODO(skaslev)) whether a tile should
be sw or gpu rasterized. Deciding that on per layer level also makes sense but I
haven't pursued that much yet.

[enne (OOO), 2013/11/25 23:14:10]

I would really not like to have a global mode flag on TileManager, even in the
first version of this patch.  I would really like to have layers say that their
tiles are Ganeshable, and then TileManager handle a set of tiles, some of which
can be Ganeshed.

Maybe in the first cut of this patch the "is ganeshable" decision can just be
true if and only if the setting is turned on, but then we can  refine that over
time.

       bool use_map_image,
       size_t max_transfer_buffer_usage_bytes,
       size_t max_raster_usage_bytes);
   virtual ~TileManager();
 
   void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
 
   // Returns true when visible tiles have been initialized.
   bool UpdateVisibleTiles();
 
@@ skipping 41 matching lines @@
     if (state != global_state_) {
       global_state_ = state;
       prioritized_tiles_dirty_ = true;
       resource_pool_->SetResourceUsageLimits(
           global_state_.memory_limit_in_bytes,
           global_state_.unused_memory_limit_in_bytes,
           global_state_.num_resources_limit);
     }
   }
 
+  // GaneshRasterizerClient interface
+  virtual void OnGaneshRasterTaskCompleted(
+      Tile* tile, scoped_ptr<ResourcePool::Resource> resource,
+      bool was_canceled) OVERRIDE;
+
  protected:
   TileManager(TileManagerClient* client,
               ResourceProvider* resource_provider,
               scoped_ptr<RasterWorkerPool> raster_worker_pool,
+              scoped_ptr<GaneshRasterizer> ganesh_rasterizer,
               size_t num_raster_threads,
               size_t max_raster_usage_bytes,
               RenderingStatsInstrumentation* rendering_stats_instrumentation);
 
   // Methods called by Tile
   friend class Tile;
   void DidChangeTilePriority(Tile* tile);
 
   void CleanUpReleasedTiles();
 
@@ skipping 35 matching lines @@
                                      raster_worker_pool_->GetResourceFormat());
   }
 
   RasterMode DetermineRasterMode(const Tile* tile) const;
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
   RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
+  void CreateGaneshRasterTask(Tile* tile);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
   void UpdatePrioritizedTileSetIfNeeded();
 
   TileManagerClient* client_;
   scoped_ptr<ResourcePool> resource_pool_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+  scoped_ptr<GaneshRasterizer> ganesh_rasterizer_;
   GlobalStateThatImpactsTilePriority global_state_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
   TileMap tiles_;
 
   PrioritizedTileSet prioritized_tiles_;
   bool prioritized_tiles_dirty_;
 
   bool all_tiles_that_need_to_be_rasterized_have_memory_;
   bool all_tiles_required_for_activation_have_memory_;
@@ skipping 23 matching lines @@
   RasterTaskCompletionStats update_visible_tiles_stats_;
 
   std::vector<Tile*> released_tiles_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_