Index: cc/resources/direct_raster_worker_pool.cc |
diff --git a/cc/resources/direct_raster_worker_pool.cc b/cc/resources/direct_raster_worker_pool.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..b2f648cc5e9bdf7e8344640beb11c78f7d510392 |
--- /dev/null |
+++ b/cc/resources/direct_raster_worker_pool.cc |
@@ -0,0 +1,152 @@ |
+// Copyright 2014 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "cc/resources/direct_raster_worker_pool.h" |
+ |
+#include "cc/output/context_provider.h" |
+#include "cc/resources/resource.h" |
+#include "cc/resources/resource_provider.h" |
+#include "gpu/command_buffer/client/gles2_interface.h" |
+#include "third_party/skia/include/gpu/GrContext.h" |
+ |
+namespace cc { |
+ |
+// static |
+scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create( |
+ ResourceProvider* resource_provider, |
+ ContextProvider* context_provider) { |
+ return make_scoped_ptr<RasterWorkerPool>( |
+ new DirectRasterWorkerPool(resource_provider, context_provider)); |
+} |
+ |
+DirectRasterWorkerPool::DirectRasterWorkerPool( |
+ ResourceProvider* resource_provider, |
+ ContextProvider* context_provider) |
+ : RasterWorkerPool(NULL, resource_provider), |
+ context_provider_(context_provider), |
+ run_tasks_on_origin_thread_pending_(false), |
+ raster_tasks_pending_(false), |
+ raster_tasks_required_for_activation_pending_(false), |
+ weak_factory_(this) {} |
+ |
+DirectRasterWorkerPool::~DirectRasterWorkerPool() { |
+ DCHECK_EQ(0u, completed_tasks_.size()); |
+} |
+ |
+void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { |
reveman
2014/02/14 16:11:53
Technically this needs to cancel tasks that have n
reveman
2014/02/14 23:30:52
Done.
|
+ TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks"); |
+ |
+ DCHECK_EQ(queue->required_for_activation_count, |
+ static_cast<size_t>( |
+ std::count_if(queue->tasks.begin(), |
+ queue->tasks.end(), |
+ RasterTaskQueue::Task::IsRequiredForActivation))); |
+ |
+ raster_tasks_pending_ = true; |
+ raster_tasks_required_for_activation_pending_ = true; |
+ |
+ scoped_refptr<internal::WorkerPoolTask> |
+ new_raster_required_for_activation_finished_task( |
+ CreateRasterRequiredForActivationFinishedTask( |
+ queue->required_for_activation_count)); |
+ scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task( |
+ CreateRasterFinishedTask()); |
+ |
+ ScheduleRunTasksOnOriginThread(); |
+ |
+ raster_tasks_.Swap(queue); |
+ |
+ set_raster_finished_task(new_raster_finished_task); |
+ set_raster_required_for_activation_finished_task( |
+ new_raster_required_for_activation_finished_task); |
+} |
+ |
+unsigned DirectRasterWorkerPool::GetResourceTarget() const { |
+ return GL_TEXTURE_2D; |
+} |
+ |
+ResourceFormat DirectRasterWorkerPool::GetResourceFormat() const { |
+ return resource_provider()->best_texture_format(); |
+} |
+ |
+void DirectRasterWorkerPool::CheckForCompletedTasks() { |
+ TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks"); |
+ |
+ for (internal::WorkerPoolTask::Vector::const_iterator it = |
+ completed_tasks_.begin(); |
+ it != completed_tasks_.end(); |
+ ++it) { |
+ internal::WorkerPoolTask* task = it->get(); |
+ |
+ task->RunReplyOnOriginThread(); |
+ } |
+ completed_tasks_.clear(); |
+} |
+ |
+SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster( |
+ internal::RasterWorkerPoolTask* task) { |
+ return resource_provider()->MapDirectRasterBuffer(task->resource()->id()); |
+} |
+ |
+void DirectRasterWorkerPool::OnRasterCompleted( |
+ internal::RasterWorkerPoolTask* task, |
+ const PicturePileImpl::Analysis& analysis) { |
+ resource_provider()->UnmapDirectRasterBuffer(task->resource()->id()); |
+} |
+ |
+void DirectRasterWorkerPool::OnRasterTasksFinished() { |
+ DCHECK(raster_tasks_pending_); |
+ raster_tasks_pending_ = false; |
+ client()->DidFinishRunningTasks(); |
+} |
+ |
+void DirectRasterWorkerPool::OnRasterTasksRequiredForActivationFinished() { |
+ DCHECK(raster_tasks_required_for_activation_pending_); |
+ raster_tasks_required_for_activation_pending_ = false; |
+ client()->DidFinishRunningTasksRequiredForActivation(); |
+} |
+ |
+void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() { |
+ if (run_tasks_on_origin_thread_pending_) |
+ return; |
+ |
+ base::MessageLoopProxy::current()->PostTask( |
+ FROM_HERE, |
+ base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread, |
+ weak_factory_.GetWeakPtr())); |
+ run_tasks_on_origin_thread_pending_ = true; |
+} |
+ |
+void DirectRasterWorkerPool::RunTasksOnOriginThread() { |
+ DCHECK(run_tasks_on_origin_thread_pending_); |
+ run_tasks_on_origin_thread_pending_ = false; |
+ |
+ if (!raster_tasks_.tasks.empty()) { |
+ GrContext* gr_context = context_provider_->GrContext(); |
+ // TODO(alokp): Implement TestContextProvider::GrContext(). |
+ if (gr_context) |
+ gr_context->resetContext(); |
+ |
+ for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) { |
+ internal::RasterWorkerPoolTask* task = *it; |
+ DCHECK(!task->HasCompleted()); |
+ |
+ // TODO(reveman): Run image decode tasks on origin thread. |
+ DCHECK_EQ(0u, task->dependencies().size()); |
reveman
2014/02/14 23:30:52
Turned out this needs to be implement for unit and
|
+ |
+ RunTaskOnOriginThread(task); |
+ |
+ completed_tasks_.push_back(task); |
+ } |
+ |
+ // TODO(alokp): Implement TestContextProvider::GrContext(). |
+ if (gr_context) |
+ gr_context->flush(); |
+ } |
+ |
+ RunTaskOnOriginThread(raster_finished_task()); |
+ RunTaskOnOriginThread(raster_required_for_activation_finished_task()); |
alokp
2014/02/14 18:50:59
shouldn't activation-finished be run before raster
reveman
2014/02/14 23:30:52
Good point. Done. This is not currently required b
|
+} |
+ |
+} // namespace cc |