1 // Copyright 2013 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_RASTER_WORKER_POOL_H_ 6 #define CC_RESOURCES_RASTER_WORKER_POOL_H_ 7 8 #include <vector> 9 10 #include "base/containers/hash_tables.h" 11 #include "cc/debug/rendering_stats_instrumentation.h" 12 #include "cc/resources/picture_pile_impl.h" 13 #include "cc/resources/raster_mode.h" 14 #include "cc/resources/tile_priority.h" 15 #include "cc/resources/worker_pool.h" 16 17 class SkDevice; 18 19 namespace skia { 20 class LazyPixelRef; 21 } 22 23 namespace cc { 24 class PicturePileImpl; 25 class PixelBufferRasterWorkerPool; 26 class Resource; 27 class ResourceProvider; 28 29 namespace internal { 30 31 class CC_EXPORT RasterWorkerPoolTask 32 : public base::RefCounted<RasterWorkerPoolTask> { 33 public: 34 typedef std::vector<scoped_refptr<WorkerPoolTask> > TaskVector; 35 36 // Returns true if |device| was written to. False indicate that 37 // the content of |device| is undefined and the resource doesn't 38 // need to be initialized. 39 virtual bool RunOnWorkerThread(SkDevice* device, unsigned thread_index) = 0; 40 virtual void CompleteOnOriginThread() = 0; 41 42 void DidRun(bool was_canceled); 43 bool HasFinishedRunning() const; 44 bool WasCanceled() const; 45 void WillComplete(); 46 void DidComplete(); 47 bool HasCompleted() const; 48 49 const Resource* resource() const { return resource_; } 50 const TaskVector& dependencies() const { return dependencies_; } 51 52 protected: 53 friend class base::RefCounted<RasterWorkerPoolTask>; 54 55 RasterWorkerPoolTask(const Resource* resource, TaskVector* dependencies); 56 virtual ~RasterWorkerPoolTask(); 57 58 private: 59 bool did_run_; 60 bool did_complete_; 61 bool was_canceled_; 62 const Resource* resource_; 63 TaskVector dependencies_; 64 }; 65 66 } // namespace internal 67 } // namespace cc 68 69 #if defined(COMPILER_GCC) 70 namespace BASE_HASH_NAMESPACE { 71 template <> struct hash<cc::internal::RasterWorkerPoolTask*> { 72 size_t operator()(cc::internal::RasterWorkerPoolTask* ptr) const { 73 return hash<size_t>()(reinterpret_cast<size_t>(ptr)); 74 } 75 }; 76 } // namespace BASE_HASH_NAMESPACE 77 #endif // COMPILER 78 79 namespace cc { 80 81 class CC_EXPORT RasterWorkerPoolClient { 82 public: 83 virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0; 84 virtual void DidFinishRunningTasks() = 0; 85 virtual void DidFinishRunningTasksRequiredForActivation() = 0; 86 87 protected: 88 virtual ~RasterWorkerPoolClient() {} 89 }; 90 91 // A worker thread pool that runs raster tasks. 92 class CC_EXPORT RasterWorkerPool : public WorkerPool { 93 public: 94 class CC_EXPORT Task { 95 public: 96 typedef base::Callback<void(bool was_canceled)> Reply; 97 98 class CC_EXPORT Set { 99 public: 100 Set(); 101 ~Set(); 102 103 void Insert(const Task& task); 104 105 private: 106 friend class RasterWorkerPool; 107 friend class RasterWorkerPoolTest; 108 109 typedef internal::RasterWorkerPoolTask::TaskVector TaskVector; 110 TaskVector tasks_; 111 }; 112 113 Task(); 114 ~Task(); 115 116 // Returns true if Task is null (doesn't refer to anything). 117 bool is_null() const { return !internal_.get(); } 118 119 // Returns the Task into an uninitialized state. 120 void Reset(); 121 122 protected: 123 friend class RasterWorkerPool; 124 friend class RasterWorkerPoolTest; 125 126 explicit Task(internal::WorkerPoolTask* internal); 127 128 scoped_refptr<internal::WorkerPoolTask> internal_; 129 }; 130 131 class CC_EXPORT RasterTask { 132 public: 133 typedef base::Callback<void(const PicturePileImpl::Analysis& analysis, 134 bool was_canceled)> Reply; 135 136 class CC_EXPORT Queue { 137 public: 138 Queue(); 139 ~Queue(); 140 141 void Append(const RasterTask& task, bool required_for_activation); 142 143 private: 144 friend class RasterWorkerPool; 145 146 typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> > 147 TaskVector; 148 TaskVector tasks_; 149 typedef base::hash_set<internal::RasterWorkerPoolTask*> TaskSet; 150 TaskSet tasks_required_for_activation_; 151 }; 152 153 RasterTask(); 154 ~RasterTask(); 155 156 // Returns true if Task is null (doesn't refer to anything). 157 bool is_null() const { return !internal_.get(); } 158 159 // Returns the Task into an uninitialized state. 160 void Reset(); 161 162 protected: 163 friend class RasterWorkerPool; 164 friend class RasterWorkerPoolTest; 165 166 explicit RasterTask(internal::RasterWorkerPoolTask* internal); 167 168 scoped_refptr<internal::RasterWorkerPoolTask> internal_; 169 }; 170 171 virtual ~RasterWorkerPool(); 172 173 void SetClient(RasterWorkerPoolClient* client); 174 175 // Tells the worker pool to shutdown after canceling all previously 176 // scheduled tasks. Reply callbacks are still guaranteed to run. 177 virtual void Shutdown() OVERRIDE; 178 179 // Schedule running of raster tasks in |queue| and all dependencies. 180 // Previously scheduled tasks that are no longer needed to run 181 // raster tasks in |queue| will be canceled unless already running. 182 // Once scheduled, reply callbacks are guaranteed to run for all tasks 183 // even if they later get canceled by another call to ScheduleTasks(). 184 virtual void ScheduleTasks(RasterTask::Queue* queue) = 0; 185 186 // TODO(vmpstr): Figure out an elegant way to not pass this many parameters. 187 static RasterTask CreateRasterTask( 188 const Resource* resource, 189 PicturePileImpl* picture_pile, 190 gfx::Rect content_rect, 191 float contents_scale, 192 RasterMode raster_mode, 193 bool is_tile_in_pending_tree_now_bin, 194 TileResolution tile_resolution, 195 int layer_id, 196 const void* tile_id, 197 int source_frame_number, 198 RenderingStatsInstrumentation* rendering_stats, 199 const RasterTask::Reply& reply, 200 Task::Set* dependencies); 201 202 static Task CreateImageDecodeTask( 203 skia::LazyPixelRef* pixel_ref, 204 int layer_id, 205 RenderingStatsInstrumentation* stats_instrumentation, 206 const Task::Reply& reply); 207 208 protected: 209 typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector; 210 typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> > 211 RasterTaskVector; 212 typedef base::hash_set<internal::RasterWorkerPoolTask*> RasterTaskSet; 213 typedef internal::RasterWorkerPoolTask* TaskMapKey; 214 typedef base::hash_map<TaskMapKey, 215 scoped_refptr<internal::WorkerPoolTask> > TaskMap; 216 217 RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads); 218 219 virtual void OnRasterTasksFinished() = 0; 220 virtual void OnRasterTasksRequiredForActivationFinished() = 0; 221 222 void SetRasterTasks(RasterTask::Queue* queue); 223 bool IsRasterTaskRequiredForActivation( 224 internal::RasterWorkerPoolTask* task) const; 225 226 RasterWorkerPoolClient* client() const { return client_; } 227 ResourceProvider* resource_provider() const { return resource_provider_; } 228 const RasterTaskVector& raster_tasks() const { return raster_tasks_; } 229 const RasterTaskSet& raster_tasks_required_for_activation() const { 230 return raster_tasks_required_for_activation_; 231 } 232 void set_raster_finished_task( 233 scoped_refptr<internal::WorkerPoolTask> raster_finished_task) { 234 raster_finished_task_ = raster_finished_task; 235 } 236 void set_raster_required_for_activation_finished_task( 237 scoped_refptr<internal::WorkerPoolTask> 238 raster_required_for_activation_finished_task) { 239 raster_required_for_activation_finished_task_ = 240 raster_required_for_activation_finished_task; 241 } 242 243 scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask(); 244 scoped_refptr<internal::WorkerPoolTask> 245 CreateRasterRequiredForActivationFinishedTask(); 246 247 scoped_ptr<base::Value> ScheduledStateAsValue() const; 248 249 static internal::GraphNode* CreateGraphNodeForTask( 250 internal::WorkerPoolTask* task, 251 unsigned priority, 252 TaskGraph* graph); 253 254 static internal::GraphNode* CreateGraphNodeForRasterTask( 255 internal::WorkerPoolTask* raster_task, 256 const TaskVector& decode_tasks, 257 unsigned priority, 258 TaskGraph* graph); 259 260 private: 261 void OnRasterFinished(const internal::WorkerPoolTask* source); 262 void OnRasterRequiredForActivationFinished( 263 const internal::WorkerPoolTask* source); 264 265 RasterWorkerPoolClient* client_; 266 ResourceProvider* resource_provider_; 267 RasterTask::Queue::TaskVector raster_tasks_; 268 RasterTask::Queue::TaskSet raster_tasks_required_for_activation_; 269 270 base::WeakPtrFactory<RasterWorkerPool> weak_ptr_factory_; 271 scoped_refptr<internal::WorkerPoolTask> raster_finished_task_; 272 scoped_refptr<internal::WorkerPoolTask> 273 raster_required_for_activation_finished_task_; 274 }; 275 276 } // namespace cc 277 278 #endif // CC_RESOURCES_RASTER_WORKER_POOL_H_ 279