cc/raster/tile_task_runner.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_RASTER_TILE_TASK_RUNNER_H_
   6 #define CC_RASTER_TILE_TASK_RUNNER_H_
   7
   8 #include <bitset>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "cc/raster/task_graph_runner.h"
  13 #include "cc/resources/resource_format.h"
  14
  15 namespace cc {
  16 class ImageDecodeTask;
  17 class RasterTask;
  18 class Resource;
  19 class RasterBuffer;
  20
  21 class CC_EXPORT TileTaskClient {
  22  public:
  23   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
  24       const Resource* resource,
  25       uint64_t resource_content_id,
  26       uint64_t previous_content_id) = 0;
  27   virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) = 0;
  28
  29  protected:
  30   virtual ~TileTaskClient() {}
  31 };
  32
  33 class CC_EXPORT TileTask : public Task {
  34  public:
  35   typedef std::vector<scoped_refptr<TileTask>> Vector;
  36
  37   virtual void ScheduleOnOriginThread(TileTaskClient* client) = 0;
  38   virtual void CompleteOnOriginThread(TileTaskClient* client) = 0;
  39   virtual void RunReplyOnOriginThread() = 0;
  40
  41   // Type-checking downcast routines.
  42   virtual ImageDecodeTask* AsImageDecodeTask();
  43   virtual RasterTask* AsRasterTask();
  44
  45   void WillSchedule();
  46   void DidSchedule();
  47   bool HasBeenScheduled() const;
  48
  49   void WillComplete();
  50   void DidComplete();
  51   bool HasCompleted() const;
  52
  53  protected:
  54   TileTask();
  55   ~TileTask() override;
  56
  57   bool did_schedule_;
  58   bool did_complete_;
  59 };
  60
  61 class CC_EXPORT ImageDecodeTask : public TileTask {
  62  public:
  63   typedef std::vector<scoped_refptr<ImageDecodeTask>> Vector;
  64
  65   // Overridden from TileTask:
  66   ImageDecodeTask* AsImageDecodeTask() override;
  67
  68  protected:
  69   ImageDecodeTask();
  70   ~ImageDecodeTask() override;
  71 };
  72
  73 class CC_EXPORT RasterTask : public TileTask {
  74  public:
  75   typedef std::vector<scoped_refptr<RasterTask>> Vector;
  76
  77   // Overridden from TileTask:
  78   RasterTask* AsRasterTask() override;
  79
  80   const Resource* resource() const { return resource_; }
  81   const ImageDecodeTask::Vector& dependencies() const { return dependencies_; }
  82
  83  protected:
  84   RasterTask(const Resource* resource, ImageDecodeTask::Vector* dependencies);
  85   ~RasterTask() override;
  86
  87  private:
  88   const Resource* resource_;
  89   ImageDecodeTask::Vector dependencies_;
  90 };
  91
  92 // kNumberOfTaskSets must be greater or equal to the number of values in
  93 // TileManager::NamedTaskSet.
  94 // TODO(reveman): Use template specialization to make it easy for client code to
  95 // check at compile time that the number of supported task sets is correct.
  96 static const size_t kNumberOfTaskSets = 3;
  97 typedef size_t TaskSet;
  98 typedef std::bitset<kNumberOfTaskSets> TaskSetCollection;
  99
 100 class CC_EXPORT TileTaskRunnerClient {
 101  public:
 102   virtual void DidFinishRunningTileTasks(TaskSet task_set) = 0;
 103
 104  protected:
 105   virtual ~TileTaskRunnerClient() {}
 106 };
 107
 108 struct CC_EXPORT TileTaskQueue {
 109   struct CC_EXPORT Item {
 110     class TaskComparator {
 111      public:
 112       explicit TaskComparator(const RasterTask* task) : task_(task) {}
 113
 114       bool operator()(const Item& item) const { return item.task == task_; }
 115
 116      private:
 117       const RasterTask* task_;
 118     };
 119
 120     typedef std::vector<Item> Vector;
 121
 122     Item(RasterTask* task, const TaskSetCollection& task_sets);
 123     ~Item();
 124
 125     RasterTask* task;
 126     TaskSetCollection task_sets;
 127   };
 128
 129   TileTaskQueue();
 130   ~TileTaskQueue();
 131
 132   void Swap(TileTaskQueue* other);
 133   void Reset();
 134
 135   Item::Vector items;
 136 };
 137
 138 // This interface can be used to schedule and run tile tasks. The client will
 139 // be notified asynchronously when the set of tasks marked as "required for
 140 // activation" have finished running, when tasks marked "required for draw"
 141 // have finished running, and when all scheduled tasks have finished running.
 142 // The client can call CheckForCompletedTasks() at any time to dispatch
 143 // pending completion callbacks for all tasks that have finished running.
 144 class CC_EXPORT TileTaskRunner {
 145  public:
 146   // Set the client instance to be notified when finished running tasks.
 147   virtual void SetClient(TileTaskRunnerClient* client) = 0;
 148
 149   // Tells the worker pool to shutdown after canceling all previously scheduled
 150   // tasks. Reply callbacks are still guaranteed to run when
 151   // CheckForCompletedTasks() is called.
 152   virtual void Shutdown() = 0;
 153
 154   // Schedule running of tile tasks in |queue| and all dependencies.
 155   // Previously scheduled tasks that are not in |queue| will be canceled unless
 156   // already running. Once scheduled, reply callbacks are guaranteed to run for
 157   // all tasks even if they later get canceled by another call to
 158   // ScheduleTasks().
 159   virtual void ScheduleTasks(TileTaskQueue* queue) = 0;
 160
 161   // Check for completed tasks and dispatch reply callbacks.
 162   virtual void CheckForCompletedTasks() = 0;
 163
 164   // Returns the format to use for the tiles.
 165   virtual ResourceFormat GetResourceFormat() const = 0;
 166
 167   // Determine if the resource requires swizzling.
 168   virtual bool GetResourceRequiresSwizzle() const = 0;
 169
 170  protected:
 171   virtual ~TileTaskRunner() {}
 172 };
 173
 174 }  // namespace cc
 175
 176 #endif  // CC_RASTER_TILE_TASK_RUNNER_H_