static base::LazyInstance<RasterRequiredForActivationSyntheticDelayInitializer>
g_raster_required_for_activation_delay = LAZY_INSTANCE_INITIALIZER;
-class RasterTaskGraphRunner : public internal::TaskGraphRunner,
+class RasterTaskGraphRunner : public TaskGraphRunner,
public base::DelegateSimpleThread::Delegate {
public:
RasterTaskGraphRunner() {
#endif
workers_.push_back(worker.Pass());
}
+
+ // Use index 0 for origin thread.
+ current_tls_.Set(new ThreadLocalState(0));
}
virtual ~RasterTaskGraphRunner() { NOTREACHED(); }
DCHECK_GT(RasterWorkerPool::GetNumRasterThreads(), picture_clone_index);
current_tls_.Set(new ThreadLocalState(picture_clone_index));
- internal::TaskGraphRunner::Run();
+ TaskGraphRunner::Run();
}
ScopedPtrDeque<base::DelegateSimpleThread> workers_;
int g_num_raster_threads = 0;
-class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+class RasterFinishedTaskImpl : public RasterizerTask {
public:
- typedef base::Callback<void(const internal::WorkerPoolTask* source)> Callback;
-
- explicit RasterFinishedWorkerPoolTaskImpl(
+ explicit RasterFinishedTaskImpl(
base::SequencedTaskRunner* task_runner,
- const Callback& on_raster_finished_callback)
+ const base::Closure& on_raster_finished_callback)
: task_runner_(task_runner),
on_raster_finished_callback_(on_raster_finished_callback) {}
- // Overridden from internal::Task:
+ // Overridden from Task:
virtual void RunOnWorkerThread() OVERRIDE {
- TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
+ TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
RasterFinished();
}
- // Overridden from internal::WorkerPoolTask:
- virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
- OVERRIDE {}
- virtual void RunOnOriginThread() OVERRIDE {
- TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread");
- RasterFinished();
- }
- virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
- OVERRIDE {}
+ // Overridden from RasterizerTask:
+ virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
+ virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
virtual void RunReplyOnOriginThread() OVERRIDE {}
protected:
- virtual ~RasterFinishedWorkerPoolTaskImpl() {}
+ virtual ~RasterFinishedTaskImpl() {}
void RasterFinished() {
- task_runner_->PostTask(
- FROM_HERE,
- base::Bind(
- &RasterFinishedWorkerPoolTaskImpl::OnRasterFinishedOnOriginThread,
- this));
+ task_runner_->PostTask(FROM_HERE, on_raster_finished_callback_);
}
private:
- void OnRasterFinishedOnOriginThread() const {
- on_raster_finished_callback_.Run(this);
- }
-
scoped_refptr<base::SequencedTaskRunner> task_runner_;
- const Callback on_raster_finished_callback_;
+ const base::Closure on_raster_finished_callback_;
- DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
+ DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
};
-class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
- : public RasterFinishedWorkerPoolTaskImpl {
+class RasterRequiredForActivationFinishedTaskImpl
+ : public RasterFinishedTaskImpl {
public:
- RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
+ RasterRequiredForActivationFinishedTaskImpl(
base::SequencedTaskRunner* task_runner,
- const Callback& on_raster_finished_callback,
+ const base::Closure& on_raster_finished_callback,
size_t tasks_required_for_activation_count)
- : RasterFinishedWorkerPoolTaskImpl(task_runner,
- on_raster_finished_callback),
+ : RasterFinishedTaskImpl(task_runner, on_raster_finished_callback),
tasks_required_for_activation_count_(
tasks_required_for_activation_count) {
if (tasks_required_for_activation_count_) {
}
}
- // Overridden from internal::Task:
+ // Overridden from Task:
virtual void RunOnWorkerThread() OVERRIDE {
- TRACE_EVENT0("cc",
- "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
- "RunOnWorkerThread");
- RunRasterFinished();
- }
-
- // Overridden from internal::WorkerPoolTask:
- virtual void RunOnOriginThread() OVERRIDE {
- TRACE_EVENT0("cc",
- "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
- "RunOnOriginThread");
- RunRasterFinished();
- }
+ TRACE_EVENT0(
+ "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnWorkerThread");
- private:
- virtual ~RasterRequiredForActivationFinishedWorkerPoolTaskImpl() {}
-
- void RunRasterFinished() {
if (tasks_required_for_activation_count_) {
g_raster_required_for_activation_delay.Get().delay->EndParallel(
activation_delay_end_time_);
RasterFinished();
}
+ private:
+ virtual ~RasterRequiredForActivationFinishedTaskImpl() {}
+
base::TimeTicks activation_delay_end_time_;
const size_t tasks_required_for_activation_count_;
- DISALLOW_COPY_AND_ASSIGN(
- RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
+ DISALLOW_COPY_AND_ASSIGN(RasterRequiredForActivationFinishedTaskImpl);
};
} // namespace
-namespace internal {
-
-WorkerPoolTask::WorkerPoolTask() : did_schedule_(false), did_complete_(false) {}
-
-WorkerPoolTask::~WorkerPoolTask() {
- DCHECK(!did_schedule_);
- DCHECK(!did_run_ || did_complete_);
-}
-
-void WorkerPoolTask::WillSchedule() { DCHECK(!did_schedule_); }
-
-void WorkerPoolTask::DidSchedule() {
- did_schedule_ = true;
- did_complete_ = false;
-}
-
-bool WorkerPoolTask::HasBeenScheduled() const { return did_schedule_; }
-
-void WorkerPoolTask::WillComplete() { DCHECK(!did_complete_); }
-
-void WorkerPoolTask::DidComplete() {
- DCHECK(did_schedule_);
- DCHECK(!did_complete_);
- did_schedule_ = false;
- did_complete_ = true;
-}
-
-bool WorkerPoolTask::HasCompleted() const { return did_complete_; }
-
-RasterWorkerPoolTask::RasterWorkerPoolTask(
- const Resource* resource,
- internal::WorkerPoolTask::Vector* dependencies)
- : resource_(resource) {
- dependencies_.swap(*dependencies);
-}
-
-RasterWorkerPoolTask::~RasterWorkerPoolTask() {}
-
-} // namespace internal
-
-RasterTaskQueue::Item::Item(internal::RasterWorkerPoolTask* task,
- bool required_for_activation)
- : task(task), required_for_activation(required_for_activation) {}
-
-RasterTaskQueue::Item::~Item() {}
-
-RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {}
-
-RasterTaskQueue::~RasterTaskQueue() {}
-
-void RasterTaskQueue::Swap(RasterTaskQueue* other) {
- items.swap(other->items);
- std::swap(required_for_activation_count,
- other->required_for_activation_count);
-}
-
-void RasterTaskQueue::Reset() {
- required_for_activation_count = 0u;
- items.clear();
-}
-
// This allows an external rasterize on-demand system to run raster tasks
// with highest priority using the same task graph runner instance.
unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
1u;
unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
-RasterWorkerPool::RasterWorkerPool(base::SequencedTaskRunner* task_runner,
- internal::TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- client_(NULL),
- resource_provider_(resource_provider),
- weak_ptr_factory_(this) {
- if (task_graph_runner_)
- namespace_token_ = task_graph_runner_->GetNamespaceToken();
-}
+RasterWorkerPool::RasterWorkerPool() {}
RasterWorkerPool::~RasterWorkerPool() {}
}
// static
-internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
+TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
return g_task_graph_runner.Pointer();
}
return g_task_graph_runner.Pointer()->GetPictureCloneIndexForCurrentThread();
}
-void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
- client_ = client;
+// static
+scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
+ base::SequencedTaskRunner* task_runner,
+ const base::Closure& on_raster_finished_callback) {
+ return make_scoped_refptr(
+ new RasterFinishedTaskImpl(task_runner, on_raster_finished_callback));
}
-void RasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "RasterWorkerPool::Shutdown");
-
- if (task_graph_runner_) {
- internal::TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
- }
-
- weak_ptr_factory_.InvalidateWeakPtrs();
+// static
+scoped_refptr<RasterizerTask>
+RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
+ size_t tasks_required_for_activation_count,
+ base::SequencedTaskRunner* task_runner,
+ const base::Closure& on_raster_finished_callback) {
+ return make_scoped_refptr(new RasterRequiredForActivationFinishedTaskImpl(
+ task_runner,
+ on_raster_finished_callback,
+ tasks_required_for_activation_count));
}
-void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) {
- TRACE_EVENT0("cc", "RasterWorkerPool::SetTaskGraph");
+// static
+void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
+ TaskGraph* graph) {
+ TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
- DCHECK(task_graph_runner_);
- for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+ for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
it != graph->nodes.end();
++it) {
- internal::TaskGraph::Node& node = *it;
- internal::WorkerPoolTask* task =
- static_cast<internal::WorkerPoolTask*>(node.task);
+ TaskGraph::Node& node = *it;
+ RasterizerTask* task = static_cast<RasterizerTask*>(node.task);
if (!task->HasBeenScheduled()) {
task->WillSchedule();
- task->ScheduleOnOriginThread(this);
+ task->ScheduleOnOriginThread(client);
task->DidSchedule();
}
}
-
- task_graph_runner_->ScheduleTasks(namespace_token_, graph);
-}
-
-void RasterWorkerPool::CollectCompletedWorkerPoolTasks(
- internal::Task::Vector* completed_tasks) {
- DCHECK(task_graph_runner_);
- task_graph_runner_->CollectCompletedTasks(namespace_token_, completed_tasks);
-}
-
-scoped_refptr<internal::WorkerPoolTask>
-RasterWorkerPool::CreateRasterFinishedTask() {
- return make_scoped_refptr(new RasterFinishedWorkerPoolTaskImpl(
- task_runner_,
- base::Bind(&RasterWorkerPool::OnRasterFinished,
- weak_ptr_factory_.GetWeakPtr())));
-}
-
-scoped_refptr<internal::WorkerPoolTask>
-RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
- size_t tasks_required_for_activation_count) {
- return make_scoped_refptr(
- new RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
- task_runner_,
- base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished,
- weak_ptr_factory_.GetWeakPtr()),
- tasks_required_for_activation_count));
-}
-
-void RasterWorkerPool::RunTaskOnOriginThread(internal::WorkerPoolTask* task) {
- task->WillSchedule();
- task->ScheduleOnOriginThread(this);
- task->DidSchedule();
-
- task->WillRun();
- task->RunOnOriginThread();
- task->DidRun();
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
-}
-
-void RasterWorkerPool::OnRasterFinished(
- const internal::WorkerPoolTask* source) {
- TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterFinished");
-
- // Early out if current |raster_finished_task_| is not the source.
- if (source != raster_finished_task_.get())
- return;
-
- OnRasterTasksFinished();
-}
-
-void RasterWorkerPool::OnRasterRequiredForActivationFinished(
- const internal::WorkerPoolTask* source) {
- TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterRequiredForActivationFinished");
-
- // Early out if current |raster_required_for_activation_finished_task_|
- // is not the source.
- if (source != raster_required_for_activation_finished_task_.get())
- return;
-
- OnRasterTasksRequiredForActivationFinished();
}
// static
-void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
- internal::WorkerPoolTask* task,
+void RasterWorkerPool::InsertNodeForTask(TaskGraph* graph,
+ RasterizerTask* task,
unsigned priority,
size_t dependencies) {
DCHECK(std::find_if(graph->nodes.begin(),
graph->nodes.end(),
- internal::TaskGraph::Node::TaskComparator(task)) ==
+ TaskGraph::Node::TaskComparator(task)) ==
graph->nodes.end());
- graph->nodes.push_back(
- internal::TaskGraph::Node(task, priority, dependencies));
+ graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
}
// static
-void RasterWorkerPool::InsertNodeForRasterTask(
- internal::TaskGraph* graph,
- internal::WorkerPoolTask* raster_task,
- const internal::WorkerPoolTask::Vector& decode_tasks,
+void RasterWorkerPool::InsertNodesForRasterTask(
+ TaskGraph* graph,
+ RasterTask* raster_task,
+ const ImageDecodeTask::Vector& decode_tasks,
unsigned priority) {
size_t dependencies = 0u;
// Insert image decode tasks.
- for (internal::WorkerPoolTask::Vector::const_iterator it =
- decode_tasks.begin();
+ for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
it != decode_tasks.end();
++it) {
- internal::WorkerPoolTask* decode_task = it->get();
+ ImageDecodeTask* decode_task = it->get();
// Skip if already decoded.
if (decode_task->HasCompleted())
dependencies++;
// Add decode task if it doesn't already exists in graph.
- internal::TaskGraph::Node::Vector::iterator decode_it =
+ TaskGraph::Node::Vector::iterator decode_it =
std::find_if(graph->nodes.begin(),
graph->nodes.end(),
- internal::TaskGraph::Node::TaskComparator(decode_task));
+ TaskGraph::Node::TaskComparator(decode_task));
if (decode_it == graph->nodes.end())
InsertNodeForTask(graph, decode_task, priority, 0u);
- graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
+ graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
}
InsertNodeForTask(graph, raster_task, priority, dependencies);
projects / platform / framework / web / crosswalk.git / blobdiff