src/cc/resources/direct_raster_worker_pool.cc

   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 #include "cc/resources/direct_raster_worker_pool.h"
   6
   7 #include "cc/output/context_provider.h"
   8 #include "cc/resources/resource.h"
   9 #include "cc/resources/resource_provider.h"
  10 #include "gpu/command_buffer/client/gles2_interface.h"
  11 #include "third_party/skia/include/gpu/GrContext.h"
  12
  13 namespace cc {
  14
  15 // static
  16 scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
  17     ResourceProvider* resource_provider,
  18     ContextProvider* context_provider) {
  19   return make_scoped_ptr<RasterWorkerPool>(
  20       new DirectRasterWorkerPool(resource_provider, context_provider));
  21 }
  22
  23 DirectRasterWorkerPool::DirectRasterWorkerPool(
  24     ResourceProvider* resource_provider,
  25     ContextProvider* context_provider)
  26     : RasterWorkerPool(NULL, resource_provider),
  27       context_provider_(context_provider),
  28       run_tasks_on_origin_thread_pending_(false),
  29       raster_tasks_pending_(false),
  30       raster_tasks_required_for_activation_pending_(false),
  31       weak_factory_(this) {}
  32
  33 DirectRasterWorkerPool::~DirectRasterWorkerPool() {
  34   DCHECK_EQ(0u, completed_tasks_.size());
  35 }
  36
  37 void DirectRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
  38   TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks");
  39
  40   raster_tasks_pending_ = true;
  41   raster_tasks_required_for_activation_pending_ = true;
  42
  43   scoped_refptr<internal::WorkerPoolTask>
  44       new_raster_required_for_activation_finished_task(
  45           CreateRasterRequiredForActivationFinishedTask(
  46               queue->required_for_activation_count()));
  47   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
  48       CreateRasterFinishedTask());
  49
  50   // Need to cancel tasks not present in new queue if we haven't had a
  51   // chance to run the previous set of tasks yet.
  52   // TODO(reveman): Remove this once only tasks for which
  53   // ::ScheduleOnOriginThread has been called need to be canceled.
  54   if (run_tasks_on_origin_thread_pending_) {
  55     for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) {
  56       internal::RasterWorkerPoolTask* task = *it;
  57
  58       if (std::find_if(queue->tasks_.begin(),
  59                        queue->tasks_.end(),
  60                        RasterTask::Queue::QueuedTask::TaskComparator(task)) ==
  61           queue->tasks_.end())
  62         completed_tasks_.push_back(task);
  63     }
  64   }
  65
  66   ScheduleRunTasksOnOriginThread();
  67
  68   raster_tasks_.Swap(queue);
  69
  70   set_raster_finished_task(new_raster_finished_task);
  71   set_raster_required_for_activation_finished_task(
  72       new_raster_required_for_activation_finished_task);
  73 }
  74
  75 unsigned DirectRasterWorkerPool::GetResourceTarget() const {
  76   return GL_TEXTURE_2D;
  77 }
  78
  79 ResourceFormat DirectRasterWorkerPool::GetResourceFormat() const {
  80   return resource_provider()->best_texture_format();
  81 }
  82
  83 void DirectRasterWorkerPool::CheckForCompletedTasks() {
  84   TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
  85
  86   for (internal::WorkerPoolTask::Vector::const_iterator it =
  87            completed_tasks_.begin();
  88        it != completed_tasks_.end();
  89        ++it) {
  90     internal::WorkerPoolTask* task = it->get();
  91
  92     task->RunReplyOnOriginThread();
  93   }
  94   completed_tasks_.clear();
  95 }
  96
  97 SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(
  98     internal::RasterWorkerPoolTask* task) {
  99   return resource_provider()->MapDirectRasterBuffer(task->resource()->id());
 100 }
 101
 102 void DirectRasterWorkerPool::OnRasterCompleted(
 103     internal::RasterWorkerPoolTask* task,
 104     const PicturePileImpl::Analysis& analysis) {
 105   resource_provider()->UnmapDirectRasterBuffer(task->resource()->id());
 106 }
 107
 108 void DirectRasterWorkerPool::OnRasterTasksFinished() {
 109   DCHECK(raster_tasks_pending_);
 110   raster_tasks_pending_ = false;
 111   client()->DidFinishRunningTasks();
 112 }
 113
 114 void DirectRasterWorkerPool::OnRasterTasksRequiredForActivationFinished() {
 115   DCHECK(raster_tasks_required_for_activation_pending_);
 116   raster_tasks_required_for_activation_pending_ = false;
 117   client()->DidFinishRunningTasksRequiredForActivation();
 118 }
 119
 120 void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
 121   if (run_tasks_on_origin_thread_pending_)
 122     return;
 123
 124   base::MessageLoopProxy::current()->PostTask(
 125       FROM_HERE,
 126       base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread,
 127                  weak_factory_.GetWeakPtr()));
 128   run_tasks_on_origin_thread_pending_ = true;
 129 }
 130
 131 void DirectRasterWorkerPool::RunTasksOnOriginThread() {
 132   DCHECK(run_tasks_on_origin_thread_pending_);
 133   run_tasks_on_origin_thread_pending_ = false;
 134
 135   if (!raster_tasks_.tasks_.empty()) {
 136     GrContext* gr_context = context_provider_->GrContext();
 137     // TODO(alokp): Implement TestContextProvider::GrContext().
 138     if (gr_context)
 139       gr_context->resetContext();
 140
 141     for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) {
 142       internal::RasterWorkerPoolTask* task = *it;
 143       DCHECK(!task->HasCompleted());
 144
 145       // First need to run all dependencies.
 146       for (internal::WorkerPoolTask::Vector::const_iterator it =
 147                task->dependencies().begin();
 148            it != task->dependencies().end();
 149            ++it) {
 150         internal::WorkerPoolTask* dependency = it->get();
 151
 152         if (dependency->HasCompleted())
 153           continue;
 154
 155         RunTaskOnOriginThread(dependency);
 156
 157         completed_tasks_.push_back(dependency);
 158       }
 159
 160       RunTaskOnOriginThread(task);
 161
 162       completed_tasks_.push_back(task);
 163     }
 164
 165     // TODO(alokp): Implement TestContextProvider::GrContext().
 166     if (gr_context)
 167       gr_context->flush();
 168   }
 169
 170   RunTaskOnOriginThread(raster_required_for_activation_finished_task());
 171   RunTaskOnOriginThread(raster_finished_task());
 172 }
 173
 174 }  // namespace cc