Add preliminary support for hw-accelerated tile rasterization.

cc/resources/pixel_buffer_raster_worker_pool.cc

 // Copyright 2013 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/pixel_buffer_raster_worker_pool.h"
 
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
@@ skipping 73 matching lines @@
 
 // Only used as std::find_if predicate for DCHECKs.
 bool WasCanceled(const internal::RasterWorkerPoolTask* task) {
   return task->WasCanceled();
 }
 
 }  // namespace
 
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_threads,
     size_t max_transfer_buffer_usage_bytes)
-    : RasterWorkerPool(resource_provider, num_threads),
+    : RasterWorkerPool(resource_provider, context_provider, num_threads),
       shutdown_(false),
       scheduled_raster_task_count_(0),
       bytes_pending_upload_(0),
       max_bytes_pending_upload_(max_transfer_buffer_usage_bytes),
       has_performed_uploads_since_last_flush_(false),
       check_for_completed_raster_tasks_pending_(false),
       should_notify_client_if_no_tasks_are_pending_(false),
       should_notify_client_if_no_tasks_required_for_activation_are_pending_(
           false),
       raster_finished_task_pending_(false),
       raster_required_for_activation_finished_task_pending_(false) {
 }
 
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK(shutdown_);
   DCHECK(!check_for_completed_raster_tasks_pending_);
   DCHECK_EQ(0u, pixel_buffer_tasks_.size());
   DCHECK_EQ(0u, tasks_with_pending_upload_.size());
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
 void PixelBufferRasterWorkerPool::Shutdown() {
   shutdown_ = true;
   RasterWorkerPool::Shutdown();
-  RasterWorkerPool::CheckForCompletedTasks();
+  CheckForCompletedWorkerTasks();
   CheckForCompletedUploads();
   check_for_completed_raster_tasks_callback_.Cancel();
   check_for_completed_raster_tasks_pending_ = false;
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
        it != pixel_buffer_tasks_.end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
     internal::WorkerPoolTask* pixel_buffer_task = it->second.get();
 
     // All inactive tasks needs to be canceled.
     if (!pixel_buffer_task && !task->HasFinishedRunning()) {
@@ skipping 12 matching lines @@
   if (!should_notify_client_if_no_tasks_are_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
   should_notify_client_if_no_tasks_are_pending_ = true;
   should_notify_client_if_no_tasks_required_for_activation_are_pending_ = true;
 
   tasks_required_for_activation_.clear();
 
   // Build new pixel buffer task set.
   TaskMap new_pixel_buffer_tasks;
+  RasterTaskVector gpu_raster_tasks;
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(new_pixel_buffer_tasks.find(task) == new_pixel_buffer_tasks.end());
     DCHECK(!task->HasCompleted());
     DCHECK(!task->WasCanceled());
 
+    if (task->use_gpu_rasterization()) {
+      gpu_raster_tasks.push_back(task);
+      continue;
+    }
+
     new_pixel_buffer_tasks[task] = pixel_buffer_tasks_[task];
     pixel_buffer_tasks_.erase(task);
 
     if (IsRasterTaskRequiredForActivation(task))
       tasks_required_for_activation_.insert(task);
   }
 
   // Transfer remaining pixel buffer tasks to |new_pixel_buffer_tasks|
   // and cancel all remaining inactive tasks.
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
@@ skipping 12 matching lines @@
                        task) == completed_tasks_.end());
       completed_tasks_.push_back(task);
     } else if (IsRasterTaskRequiredForActivation(task)) {
       tasks_required_for_activation_.insert(task);
     }
   }
 
   // |tasks_required_for_activation_| contains all tasks that need to
   // complete before we can send a "ready to activate" signal. Tasks
   // that have already completed should not be part of this set.
-  for (TaskDeque::const_iterator it = completed_tasks_.begin();
+  for (RasterTaskDeque::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end() && !tasks_required_for_activation_.empty();
        ++it) {
     tasks_required_for_activation_.erase(*it);
   }
 
   pixel_buffer_tasks_.swap(new_pixel_buffer_tasks);
 
   // Check for completed tasks when ScheduleTasks() is called as
   // priorities might have changed and this maximizes the number
   // of top priority tasks that are scheduled.
-  RasterWorkerPool::CheckForCompletedTasks();
+  CheckForCompletedWorkerTasks();
   CheckForCompletedUploads();
   FlushUploads();
 
   // Schedule new tasks.
   ScheduleMoreTasks();
 
   // Cancel any pending check for completed raster tasks and schedule
   // another check.
   check_for_completed_raster_tasks_callback_.Cancel();
   check_for_completed_raster_tasks_pending_ = false;
   ScheduleCheckForCompletedRasterTasks();
 
+  RunGpuRasterTasks(gpu_raster_tasks);
+
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, StateName(),
       "state", TracedValue::FromValue(StateAsValue().release()));
 }
 
 GLenum PixelBufferRasterWorkerPool::GetResourceTarget() const {
   return GL_TEXTURE_2D;
 }
 
 ResourceFormat PixelBufferRasterWorkerPool::GetResourceFormat() const {
   return resource_provider()->memory_efficient_texture_format();
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::CheckForCompletedTasks");
 
   RasterWorkerPool::CheckForCompletedTasks();
   CheckForCompletedUploads();
   FlushUploads();
 
-  TaskDeque completed_tasks;
+  RasterTaskDeque completed_tasks;
   completed_tasks_.swap(completed_tasks);
 
   while (!completed_tasks.empty()) {
     internal::RasterWorkerPoolTask* task = completed_tasks.front().get();
     DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
     pixel_buffer_tasks_.erase(task);
 
     task->WillComplete();
     task->CompleteOnOriginThread();
@@ skipping 33 matching lines @@
 
 void PixelBufferRasterWorkerPool::FlushUploads() {
   if (!has_performed_uploads_since_last_flush_)
     return;
 
   resource_provider()->ShallowFlushIfSupported();
   has_performed_uploads_since_last_flush_ = false;
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
-  TaskDeque tasks_with_completed_uploads;
+  RasterTaskDeque tasks_with_completed_uploads;
 
   // First check if any have completed.
   while (!tasks_with_pending_upload_.empty()) {
     internal::RasterWorkerPoolTask* task =
         tasks_with_pending_upload_.front().get();
 
     // Uploads complete in the order they are issued.
     if (!resource_provider()->DidSetPixelsComplete(task->resource()->id()))
       break;
 
     tasks_with_completed_uploads.push_back(task);
     tasks_with_pending_upload_.pop_front();
   }
 
   DCHECK(client());
   bool should_force_some_uploads_to_complete =
       shutdown_ || client()->ShouldForceTasksRequiredForActivationToComplete();
 
   if (should_force_some_uploads_to_complete) {
-    TaskDeque tasks_with_uploads_to_force;
-    TaskDeque::iterator it = tasks_with_pending_upload_.begin();
+    RasterTaskDeque tasks_with_uploads_to_force;
+    RasterTaskDeque::iterator it = tasks_with_pending_upload_.begin();
     while (it != tasks_with_pending_upload_.end()) {
       internal::RasterWorkerPoolTask* task = it->get();
       DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
       // Force all uploads required for activation to complete.
       // During shutdown, force all pending uploads to complete.
       if (shutdown_ || IsRasterTaskRequiredForActivation(task)) {
         tasks_with_uploads_to_force.push_back(task);
         tasks_with_completed_uploads.push_back(task);
         it = tasks_with_pending_upload_.erase(it);
         continue;
       }
 
       ++it;
     }
 
     // Force uploads in reverse order. Since forcing can cause a wait on
     // all previous uploads, we would rather wait only once downstream.
-    for (TaskDeque::reverse_iterator it = tasks_with_uploads_to_force.rbegin();
-         it != tasks_with_uploads_to_force.rend();
-         ++it) {
+    for (RasterTaskDeque::reverse_iterator it =
+         tasks_with_uploads_to_force.rbegin();
+         it != tasks_with_uploads_to_force.rend(); ++it) {
       resource_provider()->ForceSetPixelsToComplete((*it)->resource()->id());
       has_performed_uploads_since_last_flush_ = true;
     }
   }
 
   // Release shared memory and move tasks with completed uploads
   // to |completed_tasks_|.
   while (!tasks_with_completed_uploads.empty()) {
     internal::RasterWorkerPoolTask* task =
         tasks_with_completed_uploads.front().get();
@@ skipping 32 matching lines @@
 
 void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   TRACE_EVENT0(
       "cc", "PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks");
 
   DCHECK(should_notify_client_if_no_tasks_are_pending_);
 
   check_for_completed_raster_tasks_callback_.Cancel();
   check_for_completed_raster_tasks_pending_ = false;
 
-  RasterWorkerPool::CheckForCompletedTasks();
+  CheckForCompletedWorkerTasks();
   CheckForCompletedUploads();
   FlushUploads();
 
   // Determine what client notifications to generate.
   bool will_notify_client_that_no_tasks_required_for_activation_are_pending =
       (should_notify_client_if_no_tasks_required_for_activation_are_pending_ &&
        !raster_required_for_activation_finished_task_pending_ &&
        !HasPendingTasksRequiredForActivation());
   bool will_notify_client_that_no_tasks_are_pending =
       (should_notify_client_if_no_tasks_are_pending_ &&
@@ skipping 188 matching lines @@
 
 void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
     bool was_canceled,
     bool needs_upload) {
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc"),
                "PixelBufferRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled,
                "needs_upload", needs_upload);
 
+  DCHECK(!task->use_gpu_rasterization());
   DCHECK(pixel_buffer_tasks_.find(task.get()) != pixel_buffer_tasks_.end());
 
   // Balanced with MapPixelBuffer() call in ScheduleMoreTasks().
   resource_provider()->UnmapPixelBuffer(task->resource()->id());
 
   if (!needs_upload) {
     resource_provider()->ReleasePixelBuffer(task->resource()->id());
 
     if (was_canceled) {
       // When priorites change, a raster task can be canceled as a result of
@@ skipping 71 matching lines @@
 
   throttle_state->SetInteger("bytes_available_for_upload",
                              max_bytes_pending_upload_ - bytes_pending_upload_);
   throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_);
   throttle_state->SetInteger("scheduled_raster_task_count",
                              scheduled_raster_task_count_);
   return throttle_state.PassAs<base::Value>();
 }
 
 }  // namespace cc