#include <deque>
#include <vector>
-#include "base/containers/hash_tables.h"
#include "cc/debug/rendering_stats_instrumentation.h"
#include "cc/resources/picture_pile_impl.h"
#include "cc/resources/raster_mode.h"
namespace internal {
+class WorkerPoolTask;
+class RasterWorkerPoolTask;
+
+class CC_EXPORT WorkerPoolTaskClient {
+ public:
+ virtual SkCanvas* AcquireCanvasForRaster(RasterWorkerPoolTask* task) = 0;
+ virtual void OnRasterCompleted(RasterWorkerPoolTask* task,
+ const PicturePileImpl::Analysis& analysis) = 0;
+ virtual void OnImageDecodeCompleted(WorkerPoolTask* task) = 0;
+
+ protected:
+ virtual ~WorkerPoolTaskClient() {}
+};
+
class CC_EXPORT WorkerPoolTask : public Task {
public:
- virtual void CompleteOnOriginThread() = 0;
+ typedef std::vector<scoped_refptr<WorkerPoolTask> > Vector;
+
+ virtual void ScheduleOnOriginThread(WorkerPoolTaskClient* client) = 0;
+ virtual void RunOnOriginThread() = 0;
+ virtual void CompleteOnOriginThread(WorkerPoolTaskClient* client) = 0;
+ virtual void RunReplyOnOriginThread() = 0;
+
+ void WillSchedule();
+ void DidSchedule();
+ bool HasBeenScheduled() const;
void WillComplete();
void DidComplete();
WorkerPoolTask();
virtual ~WorkerPoolTask();
- private:
+ bool did_schedule_;
bool did_complete_;
};
-class CC_EXPORT RasterWorkerPoolTask
- : public base::RefCounted<RasterWorkerPoolTask> {
+class CC_EXPORT RasterWorkerPoolTask : public WorkerPoolTask {
public:
- // Returns true if |buffer| was written to. False indicate that
- // the content of |buffer| is undefined and the resource doesn't
- // need to be initialized.
- virtual bool RunOnWorkerThread(unsigned thread_index,
- void* buffer,
- gfx::Size size,
- int stride) = 0;
- virtual void RunOnOriginThread(ResourceProvider* resource_provider,
- ContextProvider* context_provider) = 0;
- virtual void CompleteOnOriginThread() = 0;
-
- void DidRun(bool was_canceled);
- bool HasFinishedRunning() const;
- bool WasCanceled() const;
- void WillComplete();
- void DidComplete();
- bool HasCompleted() const;
-
const Resource* resource() const { return resource_; }
- const internal::Task::Vector& dependencies() const { return dependencies_; }
- bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
+ const internal::WorkerPoolTask::Vector& dependencies() const {
+ return dependencies_;
+ }
protected:
- friend class base::RefCounted<RasterWorkerPoolTask>;
-
RasterWorkerPoolTask(const Resource* resource,
- internal::Task::Vector* dependencies,
- bool use_gpu_rasterization);
+ internal::WorkerPoolTask::Vector* dependencies);
virtual ~RasterWorkerPoolTask();
private:
- bool did_run_;
- bool did_complete_;
- bool was_canceled_;
const Resource* resource_;
- Task::Vector dependencies_;
- bool use_gpu_rasterization_;
+ WorkerPoolTask::Vector dependencies_;
};
} // namespace internal
-} // namespace cc
-
-#if defined(COMPILER_GCC)
-namespace BASE_HASH_NAMESPACE {
-template <>
-struct hash<cc::internal::RasterWorkerPoolTask*> {
- size_t operator()(cc::internal::RasterWorkerPoolTask* ptr) const {
- return hash<size_t>()(reinterpret_cast<size_t>(ptr));
- }
-};
-} // namespace BASE_HASH_NAMESPACE
-#endif // COMPILER
-
-namespace cc {
class CC_EXPORT RasterWorkerPoolClient {
public:
};
// A worker thread pool that runs raster tasks.
-class CC_EXPORT RasterWorkerPool {
+class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
public:
class CC_EXPORT Task {
public:
private:
friend class RasterWorkerPool;
- friend class RasterWorkerPoolTest;
- internal::Task::Vector tasks_;
+ internal::WorkerPoolTask::Vector tasks_;
};
Task();
protected:
friend class RasterWorkerPool;
- friend class RasterWorkerPoolTest;
explicit Task(internal::WorkerPoolTask* internal);
Queue();
~Queue();
+ void Reset();
void Append(const RasterTask& task, bool required_for_activation);
+ void Swap(Queue* other);
+
+ size_t count() const { return tasks_.size(); }
+ size_t required_for_activation_count() const {
+ return required_for_activation_count_;
+ }
private:
friend class RasterWorkerPool;
+ friend class DirectRasterWorkerPool;
+
+ struct QueuedTask {
+ class TaskComparator {
+ public:
+ explicit TaskComparator(const internal::RasterWorkerPoolTask* task)
+ : task_(task) {}
+
+ bool operator()(const QueuedTask& queued_task) const {
+ return queued_task.task == task_;
+ }
+
+ private:
+ const internal::RasterWorkerPoolTask* task_;
+ };
+
+ typedef std::vector<QueuedTask> Vector;
- typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
- TaskVector;
- TaskVector tasks_;
- typedef base::hash_set<internal::RasterWorkerPoolTask*> TaskSet;
- TaskSet tasks_required_for_activation_;
+ QueuedTask(internal::RasterWorkerPoolTask* task,
+ bool required_for_activation);
+ ~QueuedTask();
+
+ scoped_refptr<internal::RasterWorkerPoolTask> task;
+ bool required_for_activation;
+ };
+
+ QueuedTask::Vector tasks_;
+ size_t required_for_activation_count_;
};
RasterTask();
protected:
friend class RasterWorkerPool;
- friend class RasterWorkerPoolTest;
explicit RasterTask(internal::RasterWorkerPoolTask* internal);
virtual ~RasterWorkerPool();
static void SetNumRasterThreads(int num_threads);
-
static int GetNumRasterThreads();
+ static internal::TaskGraphRunner* GetTaskGraphRunner();
+
+ static unsigned kOnDemandRasterTaskPriority;
+ static unsigned kRasterFinishedTaskPriority;
+ static unsigned kRasterRequiredForActivationFinishedTaskPriority;
+ static unsigned kRasterTaskPriorityBase;
+
// TODO(vmpstr): Figure out an elegant way to not pass this many parameters.
static RasterTask CreateRasterTask(
const Resource* resource,
int layer_id,
const void* tile_id,
int source_frame_number,
- bool use_gpu_rasterization,
RenderingStatsInstrumentation* rendering_stats,
const RasterTask::Reply& reply,
- Task::Set* dependencies);
+ Task::Set* dependencies,
+ ContextProvider* context_provider);
static Task CreateImageDecodeTask(
SkPixelRef* pixel_ref,
int layer_id,
- RenderingStatsInstrumentation* stats_instrumentation,
+ RenderingStatsInstrumentation* rendering_stats,
const Task::Reply& reply);
void SetClient(RasterWorkerPoolClient* client);
virtual void ScheduleTasks(RasterTask::Queue* queue) = 0;
// Force a check for completed tasks.
- virtual void CheckForCompletedTasks();
+ virtual void CheckForCompletedTasks() = 0;
// Returns the target that needs to be used for raster task resources.
virtual unsigned GetResourceTarget() const = 0;
virtual ResourceFormat GetResourceFormat() const = 0;
protected:
- typedef internal::TaskGraphRunner::TaskGraph TaskGraph;
+ class RasterTaskQueueIterator {
+ public:
+ explicit RasterTaskQueueIterator(const RasterTask::Queue* queue)
+ : tasks_(&queue->tasks_), current_index_(0u) {}
+ ~RasterTaskQueueIterator() {}
+
+ bool required_for_activation() const {
+ DCHECK_LT(current_index_, tasks_->size());
+ return (*tasks_)[current_index_].required_for_activation;
+ }
+
+ internal::RasterWorkerPoolTask* operator->() const {
+ DCHECK_LT(current_index_, tasks_->size());
+ return (*tasks_)[current_index_].task.get();
+ }
+
+ internal::RasterWorkerPoolTask* operator*() const {
+ DCHECK_LT(current_index_, tasks_->size());
+ return (*tasks_)[current_index_].task.get();
+ }
+
+ RasterTaskQueueIterator& operator++() {
+ DCHECK_LT(current_index_, tasks_->size());
+ ++current_index_;
+ return *this;
+ }
+
+ operator bool() const { return current_index_ < tasks_->size(); }
+
+ private:
+ const RasterTask::Queue::QueuedTask::Vector* tasks_;
+ size_t current_index_;
+ };
typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
+ typedef std::deque<scoped_refptr<internal::WorkerPoolTask> > TaskDeque;
typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
RasterTaskVector;
- typedef std::deque<scoped_refptr<internal::RasterWorkerPoolTask> >
- RasterTaskDeque;
- typedef base::hash_set<internal::RasterWorkerPoolTask*> RasterTaskSet;
- typedef internal::RasterWorkerPoolTask* TaskMapKey;
- typedef base::hash_map<TaskMapKey, scoped_refptr<internal::WorkerPoolTask> >
- TaskMap;
- RasterWorkerPool(ResourceProvider* resource_provider,
- ContextProvider* context_provider);
+ RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
virtual void OnRasterTasksFinished() = 0;
virtual void OnRasterTasksRequiredForActivationFinished() = 0;
- void CheckForCompletedWorkerPoolTasks();
- void SetTaskGraph(TaskGraph* graph);
-
- void SetRasterTasks(RasterTask::Queue* queue);
- bool IsRasterTaskRequiredForActivation(internal::RasterWorkerPoolTask* task)
- const;
- // Run raster tasks that use GPU on current thread.
- void RunGpuRasterTasks(const RasterTaskVector& tasks);
+ void SetTaskGraph(internal::TaskGraph* graph);
+ void CollectCompletedWorkerPoolTasks(internal::Task::Vector* completed_tasks);
RasterWorkerPoolClient* client() const { return client_; }
ResourceProvider* resource_provider() const { return resource_provider_; }
- ContextProvider* context_provider() const { return context_provider_; }
- const RasterTaskVector& raster_tasks() const { return raster_tasks_; }
- const RasterTaskSet& raster_tasks_required_for_activation() const {
- return raster_tasks_required_for_activation_;
- }
+
void set_raster_finished_task(
internal::WorkerPoolTask* raster_finished_task) {
raster_finished_task_ = raster_finished_task;
}
+ internal::WorkerPoolTask* raster_finished_task() const {
+ return raster_finished_task_.get();
+ }
void set_raster_required_for_activation_finished_task(
internal::WorkerPoolTask* raster_required_for_activation_finished_task) {
raster_required_for_activation_finished_task_ =
raster_required_for_activation_finished_task;
}
+ internal::WorkerPoolTask* raster_required_for_activation_finished_task()
+ const {
+ return raster_required_for_activation_finished_task_.get();
+ }
scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask();
scoped_refptr<internal::WorkerPoolTask>
CreateRasterRequiredForActivationFinishedTask(
size_t tasks_required_for_activation_count);
- scoped_ptr<base::Value> ScheduledStateAsValue() const;
+ void RunTaskOnOriginThread(internal::WorkerPoolTask* task);
- static internal::GraphNode* CreateGraphNodeForTask(
- internal::WorkerPoolTask* task,
- unsigned priority,
- TaskGraph* graph);
+ static void InsertNodeForTask(internal::TaskGraph* graph,
+ internal::WorkerPoolTask* task,
+ unsigned priority,
+ size_t dependencies);
- static internal::GraphNode* CreateGraphNodeForRasterTask(
- internal::WorkerPoolTask* raster_task,
- const internal::Task::Vector& decode_tasks,
- unsigned priority,
- TaskGraph* graph);
+ static void InsertNodeForRasterTask(
+ internal::TaskGraph* graph,
+ internal::WorkerPoolTask* task,
+ const internal::WorkerPoolTask::Vector& decode_tasks,
+ unsigned priority);
private:
void OnRasterFinished(const internal::WorkerPoolTask* source);
void OnRasterRequiredForActivationFinished(
const internal::WorkerPoolTask* source);
+ internal::TaskGraphRunner* task_graph_runner_;
internal::NamespaceToken namespace_token_;
RasterWorkerPoolClient* client_;
ResourceProvider* resource_provider_;
- ContextProvider* context_provider_;
- RasterTask::Queue::TaskVector raster_tasks_;
- RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;
- RasterTaskDeque completed_gpu_raster_tasks_;
scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
scoped_refptr<internal::WorkerPoolTask>
projects / platform / framework / web / crosswalk.git / blobdiff