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   virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const = 0;
 104
 105  protected:
 106   virtual ~TileTaskRunnerClient() {}
 107 };
 108
 109 struct CC_EXPORT TileTaskQueue {
 110   struct CC_EXPORT Item {
 111     class TaskComparator {
 112      public:
 113       explicit TaskComparator(const RasterTask* task) : task_(task) {}
 114
 115       bool operator()(const Item& item) const { return item.task == task_; }
 116
 117      private:
 118       const RasterTask* task_;
 119     };
 120
 121     typedef std::vector<Item> Vector;
 122
 123     Item(RasterTask* task, const TaskSetCollection& task_sets);
 124     ~Item();
 125
 126     RasterTask* task;
 127     TaskSetCollection task_sets;
 128   };
 129
 130   TileTaskQueue();
 131   ~TileTaskQueue();
 132
 133   void Swap(TileTaskQueue* other);
 134   void Reset();
 135
 136   Item::Vector items;
 137 };
 138
 139 // This interface can be used to schedule and run tile tasks. The client will
 140 // be notified asynchronously when the set of tasks marked as "required for
 141 // activation" have finished running, when tasks marked "required for draw"
 142 // have finished running, and when all scheduled tasks have finished running.
 143 // The client can call CheckForCompletedTasks() at any time to dispatch
 144 // pending completion callbacks for all tasks that have finished running.
 145 class CC_EXPORT TileTaskRunner {
 146  public:
 147   // Set the client instance to be notified when finished running tasks.
 148   virtual void SetClient(TileTaskRunnerClient* client) = 0;
 149
 150   // Tells the worker pool to shutdown after canceling all previously scheduled
 151   // tasks. Reply callbacks are still guaranteed to run when
 152   // CheckForCompletedTasks() is called.
 153   virtual void Shutdown() = 0;
 154
 155   // Schedule running of tile tasks in |queue| and all dependencies.
 156   // Previously scheduled tasks that are not in |queue| will be canceled unless
 157   // already running. Once scheduled, reply callbacks are guaranteed to run for
 158   // all tasks even if they later get canceled by another call to
 159   // ScheduleTasks().
 160   virtual void ScheduleTasks(TileTaskQueue* queue) = 0;
 161
 162   // Check for completed tasks and dispatch reply callbacks.
 163   virtual void CheckForCompletedTasks() = 0;
 164
 165   // Returns the format to use for the tiles.
 166   virtual ResourceFormat GetResourceFormat() const = 0;
 167
 168   // Determine if the resource requires swizzling.
 169   virtual bool GetResourceRequiresSwizzle() const = 0;
 170
 171  protected:
 172   virtual ~TileTaskRunner() {}
 173 };
 174
 175 }  // namespace cc
 176
 177 #endif  // CC_RASTER_TILE_TASK_RUNNER_H_