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