cc: Check for completed raster tasks at interval.

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 <list>
 #include <queue>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/memory_history.h"
 #include "cc/rendering_stats.h"
 #include "cc/resource_pool.h"
 #include "cc/tile_priority.h"
 
 namespace cc {
 class RasterWorkerPool;
 class ResourceProvider;
 class Tile;
 class TileVersion;
 
 class CC_EXPORT TileManagerClient {
  public:
   virtual void ScheduleManageTiles() = 0;
+  virtual void ScheduleCheckForCompletedRasterTasks() = 0;
   virtual void DidUploadVisibleHighResolutionTile() = 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
   // Be sure to update TileManagerBinAsValue when adding new fields.
 };
 scoped_ptr<base::Value> TileManagerBinAsValue(
     TileManagerBin bin);
 
 enum TileManagerBinPriority {
   HIGH_PRIORITY_BIN = 0,
   LOW_PRIORITY_BIN = 1,
   NUM_BIN_PRIORITIES = 2
 };
 
 enum TileRasterState {
   IDLE_STATE = 0,
   WAITING_FOR_RASTER_STATE = 1,
   RASTER_STATE = 2,
-  SET_PIXELS_STATE = 3,
+  UPLOAD_STATE = 3,

[brianderson, 2013/02/12 01:44:31]

Is changing "set_pixels" to "upload" just a cleanup unrelated to this patch?

Would it make sense to split the cleanup into it's own patch?

[reveman, 2013/02/12 02:29:52]

Yes, that's just cleanup and I'm fine moving that out of this patch if you
prefer.

   NUM_STATES = 4
 };
 
 // This is state that is specific to a tile that is
 // managed by the TileManager.
 class CC_EXPORT ManagedTileState {
  public:
   ManagedTileState();
   ~ManagedTileState();
 
@@ skipping 28 matching lines @@
               size_t num_raster_threads,
               bool use_cheapess_estimator);
   virtual ~TileManager();
 
   const GlobalStateThatImpactsTilePriority& GlobalState() const {
       return global_state_;
   }
   void SetGlobalState(const GlobalStateThatImpactsTilePriority& state);
 
   void ManageTiles();
+  void CheckForCompletedRasterTasks();
   void CheckForCompletedTileUploads();
 
   scoped_ptr<base::Value> AsValue() const;
   void GetMemoryStats(size_t* memoryRequiredBytes,
                       size_t* memoryNiceToHaveBytes,
                       size_t* memoryUsedBytes) const;
   void SetRecordRenderingStats(bool record_rendering_stats);
   void GetRenderingStats(RenderingStats* stats);
   bool HasPendingWorkScheduled(WhichTree tree) const;
 
@@ skipping 73 matching lines @@
 
   typedef std::list<Tile*> TileList;
   // Tiles with image decoding tasks. These tiles need to be rasterized
   // when all the image decoding tasks finish.
   TileList tiles_with_image_decoding_tasks_;
 
   typedef base::hash_map<uint32_t, skia::LazyPixelRef*> PixelRefMap;
   PixelRefMap pending_decode_tasks_;
 
   typedef std::queue<scoped_refptr<Tile> > TileQueue;
-  TileQueue tiles_with_pending_set_pixels_;
-  size_t bytes_pending_set_pixels_;
+  TileQueue tiles_with_pending_upload_;
   bool ever_exceeded_memory_budget_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
+  size_t bytes_pending_raster_;
+  size_t bytes_pending_upload_;
+
   bool record_rendering_stats_;
   RenderingStats rendering_stats_;
 
   bool use_cheapness_estimator_;
   int raster_state_count_[NUM_STATES][NUM_TREES][NUM_BINS];
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILE_MANAGER_H_