Implement the logic to kick off image decoding jobs for TileManager

cc/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_TILE_MANAGER_H_
 #define CC_TILE_MANAGER_H_
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/resource_pool.h"
 #include "cc/tile_priority.h"
 
+#if defined(COMPILER_GCC)
+namespace BASE_HASH_NAMESPACE {
+template<>
+struct hash<SkPixelRef*> {

[nduca, 2012/12/06 08:46:53]

Can we make SkLazyPixelRef have an id() field on it that we allocate in the same
way as image id? IDs are super super useful for debugging and it sidesteps this
stuff.

[qinmin, 2012/12/07 05:06:28]

SkPixelRef has getGenerationId() call. But the reverse lookup is not there. I
added a map in tilemanager to do this.

On 2012/12/06 08:46:53, nduca wrote:

+  size_t operator()(SkPixelRef* ptr) const {
+    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
+  }
+};
+} // namespace BASE_HASH_NAMESPACE
+#endif // COMPILER_GCC
+
 namespace base {
 class SequencedWorkerPool;
 }
 
 namespace cc {
 
+class Image;
 class Tile;
 class TileVersion;
 struct RenderingStats;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
  public:
   virtual void ScheduleManageTiles() = 0;
   virtual void ScheduleRedraw() = 0;
 
  protected:
   virtual ~TileManagerClient() {}
 };
 
 // Tile manager classifying tiles into a few basic
 // bins:
 enum TileManagerBin {
   NOW_BIN = 0, // Needed ASAP.
   SOON_BIN = 1, // Impl-side version of prepainting.
   EVENTUALLY_BIN = 2, // Nice to have, if we've got memory and time.
   NEVER_BIN = 3, // Dont bother.
   NUM_BINS = 4
 };
 
+// Current progress of image decoding jobs.
+enum ImageDecodingProgress {
+  NOT_STARTED = 0,
+  IN_PROGRESS = 1,
+  FINISHED = 2
+};
+
 // This is state that is specific to a tile that is
 // managed by the TileManager.
 class CC_EXPORT ManagedTileState {
  public:
   ManagedTileState();
   ~ManagedTileState();
 
   // Persisted state: valid all the time.
   bool can_use_gpu_memory;
   bool can_be_freed;
   ResourceProvider::ResourceId resource_id;
   bool resource_id_is_being_initialized;
   bool contents_swizzled;
 
   // Ephemeral state, valid only during Manage.
   TileManagerBin bin;
   TileResolution resolution;
   float time_to_needed_in_seconds;
+  std::vector<SkPixelRef*> pixel_refs;

[nduca, 2012/12/06 08:46:53]

hmm.... isn't it sufficient to track num_pending_decode_jobs here? When you
pre-dispatch the tile, you bump this each time you enqueue a decode job or find
a decode job pending for that pixel ref id.

Then, all you need to know on the decode-ack side is to decrement this. When the
counter reaches zero, the tile can be dispatched for raster.

[qinmin, 2012/12/07 05:06:28]

Then we need a map in TileManager to map from skpixelref to all tiles.
Otherwise, when an image decoding job finishes, I have no ideas how many tiles
this job would affect as it can impact more than 1 tiles. Currently I can loop
over all tiles to find those affected tiles.

On 2012/12/06 08:46:53, nduca wrote:

 };
 
 // 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:
   TileManager(TileManagerClient* client, ResourceProvider *resource_provider);
   virtual ~TileManager();
@@ skipping 17 matching lines @@
   void FreeResourcesForTile(Tile*);
   void ScheduleManageTiles();
   void DispatchMoreRasterTasks();
   void DispatchOneRasterTask(scoped_refptr<Tile>);
   void OnRasterTaskCompleted(
       scoped_refptr<Tile>,
       ResourceProvider::ResourceId,
       scoped_refptr<PicturePileImpl>,
       RenderingStats*);
   void DidFinishTileInitialization(Tile*, ResourceProvider::ResourceId);
+  bool HasUndecodedImages(Tile*, std::vector<SkPixelRef*>&);

[Alpha Left Google, 2012/12/05 20:24:28]

This seems to be called over and over again, does this do caching?

[qinmin, 2012/12/07 05:06:28]

No, this just check if the tile has undecoded images. If so, we will wait for
all the decoding jobs to finish before kicking off the raster task. Also, this
function returns a list of skpixelRefs that we need to kick off the decoding
job.

On 2012/12/05 20:24:28, Alpha wrote:

+  void OnImageDecoded(scoped_refptr<Image> image);
+  void SpawnImageDecodingTask(SkPixelRef*);

[reveman, 2012/12/05 19:48:46]

Maybe DispatchOneImageDecodingTask/OnImageDecodingTaskCompleted to be consistent
other functions in this class?

[qinmin, 2012/12/07 05:06:28]

Done.

 
   TileManagerClient* client_;
   scoped_ptr<ResourcePool> resource_pool_;
   bool manage_tiles_pending_;
   int pending_raster_tasks_;
   scoped_refptr<base::SequencedWorkerPool> worker_pool_;
 
   GlobalStateThatImpactsTilePriority global_state_;
 
   typedef std::vector<Tile*> TileVector;
   TileVector tiles_;
   TileVector tiles_that_need_to_be_rasterized_;
 
+  typedef base::hash_map<uint32_t, scoped_refptr<Tile> > TileMap;

[reveman, 2012/12/05 19:48:46]

where is TileMap used?

[qinmin, 2012/12/07 05:06:28]

This is originally wrote to map SkPixelRef* to tiles, but i think i forgot to
remove it.

On 2012/12/05 19:48:46, David Reveman wrote:

+
+  typedef base::hash_map<SkPixelRef*, ImageDecodingProgress>
+      PixelRefDecodingProgress;
+  PixelRefDecodingProgress decoding_progress_;

[nduca, 2012/12/06 08:46:53]

All you need is IsDecodeTaskPending. Finished is not useful to you because it
might already be evicted.

pixel_ref_ids_with_pending_decode_task: map of ids. or hash map. But thats it.

[qinmin, 2012/12/07 05:06:28]

changed it to pending_decode_tasks_ hashmap here.

On 2012/12/06 08:46:53, nduca wrote:

+
   RenderingStats rendering_stats_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILE_MANAGER_H_