cc: Implement shared worker contexts. (v1)

cc/raster/one_copy_tile_task_worker_pool.cc

 // 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/raster/one_copy_tile_task_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/strings/stringprintf.h"
@@ skipping 94 matching lines @@
 
 OneCopyTileTaskWorkerPool::StagingBuffer::~StagingBuffer() {
   DCHECK_EQ(texture_id, 0u);
   DCHECK_EQ(image_id, 0u);
   DCHECK_EQ(query_id, 0u);
 }
 
 void OneCopyTileTaskWorkerPool::StagingBuffer::DestroyGLResources(
     gpu::gles2::GLES2Interface* gl) {
   if (query_id) {
-    gl->DeleteQueriesEXT(1, &query_id);
+    if (gl)
+      gl->DeleteQueriesEXT(1, &query_id);
     query_id = 0;
   }
   if (image_id) {
-    gl->DestroyImageCHROMIUM(image_id);
+    if (gl)
+      gl->DestroyImageCHROMIUM(image_id);
     image_id = 0;
   }
   if (texture_id) {
-    gl->DeleteTextures(1, &texture_id);
+    if (gl)
+      gl->DeleteTextures(1, &texture_id);
     texture_id = 0;
   }
 }
 
 void OneCopyTileTaskWorkerPool::StagingBuffer::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd,
     ResourceFormat format,
     bool in_free_list) const {
   if (!gpu_memory_buffer)
     return;
@@ skipping 283 matching lines @@
   }
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
   DCHECK(context_provider);
 
   {
     ContextProvider::ScopedContextLock scoped_context(context_provider);
 
     gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
-    DCHECK(gl);
+    if (gl) {
+      unsigned image_target = resource_provider_->GetImageTextureTarget(
+          resource_provider_->memory_efficient_texture_format());
 
-    unsigned image_target = resource_provider_->GetImageTextureTarget(
-        resource_provider_->memory_efficient_texture_format());
+      // Create and bind staging texture.
+      if (!staging_buffer->texture_id) {
+        gl->GenTextures(1, &staging_buffer->texture_id);
+        gl->BindTexture(image_target, staging_buffer->texture_id);
+        gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+      } else {
+        gl->BindTexture(image_target, staging_buffer->texture_id);
+      }
 
-    // Create and bind staging texture.
-    if (!staging_buffer->texture_id) {
-      gl->GenTextures(1, &staging_buffer->texture_id);
-      gl->BindTexture(image_target, staging_buffer->texture_id);
-      gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-      gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    } else {
-      gl->BindTexture(image_target, staging_buffer->texture_id);
-    }
-
-    // Create and bind image.
-    if (!staging_buffer->image_id) {
-      if (staging_buffer->gpu_memory_buffer) {
-        staging_buffer->image_id = gl->CreateImageCHROMIUM(
-            staging_buffer->gpu_memory_buffer->AsClientBuffer(),
-            staging_buffer->size.width(), staging_buffer->size.height(),
-            GLInternalFormat(
-                resource_provider_->memory_efficient_texture_format()));
+      // Create and bind image.
+      if (!staging_buffer->image_id) {
+        if (staging_buffer->gpu_memory_buffer) {
+          staging_buffer->image_id = gl->CreateImageCHROMIUM(
+              staging_buffer->gpu_memory_buffer->AsClientBuffer(),
+              staging_buffer->size.width(), staging_buffer->size.height(),
+              GLInternalFormat(
+                  resource_provider_->memory_efficient_texture_format()));
+          gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
+        }
+      } else {
+        gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
         gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
       }
-    } else {
-      gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
-      gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
-    }
 
-    // Unbind staging texture.
-    gl->BindTexture(image_target, 0);
+      // Unbind staging texture.
+      gl->BindTexture(image_target, 0);
 
-    if (resource_provider_->use_sync_query()) {
-      if (!staging_buffer->query_id)
-        gl->GenQueriesEXT(1, &staging_buffer->query_id);
+      if (resource_provider_->use_sync_query()) {
+        if (!staging_buffer->query_id)
+          gl->GenQueriesEXT(1, &staging_buffer->query_id);
 
 #if defined(OS_CHROMEOS)
-      // TODO(reveman): This avoids a performance problem on some ChromeOS
-      // devices. This needs to be removed to support native GpuMemoryBuffer
-      // implementations. crbug.com/436314
-      gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id);
+        // TODO(reveman): This avoids a performance problem on some ChromeOS
+        // devices. This needs to be removed to support native GpuMemoryBuffer
+        // implementations. crbug.com/436314
+        gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
+                          staging_buffer->query_id);
 #else
-      gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
-                        staging_buffer->query_id);
+        gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
+                          staging_buffer->query_id);
 #endif
+      }
+
+      int bytes_per_row =
+          (BitsPerPixel(resource_provider_->memory_efficient_texture_format()) *
+           resource->size().width()) /
+          8;
+      int chunk_size_in_rows =
+          std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
+      // Align chunk size to 4. Required to support compressed texture formats.
+      chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
+      int y = 0;
+      int height = resource->size().height();
+      while (y < height) {
+        // Copy at most |chunk_size_in_rows|.
+        int rows_to_copy = std::min(chunk_size_in_rows, height - y);
+        DCHECK_GT(rows_to_copy, 0);
+
+        gl->CopySubTextureCHROMIUM(GL_TEXTURE_2D, staging_buffer->texture_id,
+                                   resource_lock->texture_id(), 0, y, 0, y,
+                                   resource->size().width(), rows_to_copy,
+                                   false, false, false);
+        y += rows_to_copy;
+
+        // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
+        // used for this copy operation.
+        bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
+
+        if (bytes_scheduled_since_last_flush_ >=
+            max_bytes_per_copy_operation_) {
+          gl->ShallowFlushCHROMIUM();
+          bytes_scheduled_since_last_flush_ = 0;
+        }
+      }
+
+      if (resource_provider_->use_sync_query()) {
+#if defined(OS_CHROMEOS)
+        gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
+#else
+        gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
+#endif
+      }
+
+      // Barrier to sync worker context output to cc context.
+      gl->OrderingBarrierCHROMIUM();
     }
-
-    int bytes_per_row =
-        (BitsPerPixel(resource_provider_->memory_efficient_texture_format()) *
-         resource->size().width()) /
-        8;
-    int chunk_size_in_rows =
-        std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
-    // Align chunk size to 4. Required to support compressed texture formats.
-    chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
-    int y = 0;
-    int height = resource->size().height();
-    while (y < height) {
-      // Copy at most |chunk_size_in_rows|.
-      int rows_to_copy = std::min(chunk_size_in_rows, height - y);
-      DCHECK_GT(rows_to_copy, 0);
-
-      gl->CopySubTextureCHROMIUM(GL_TEXTURE_2D, staging_buffer->texture_id,
-                                 resource_lock->texture_id(), 0, y, 0, y,
-                                 resource->size().width(), rows_to_copy, false,
-                                 false, false);
-      y += rows_to_copy;
-
-      // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
-      // used for this copy operation.
-      bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
-
-      if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) {
-        gl->ShallowFlushCHROMIUM();
-        bytes_scheduled_since_last_flush_ = 0;
-      }
-    }
-
-    if (resource_provider_->use_sync_query()) {
-#if defined(OS_CHROMEOS)
-      gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
-#else
-      gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
-#endif
-    }
-
-    // Barrier to sync worker context output to cc context.
-    gl->OrderingBarrierCHROMIUM();
   }
 
   staging_buffer->last_usage = base::TimeTicks::Now();
   busy_buffers_.push_back(staging_buffer.Pass());
 
   ScheduleReduceMemoryUsage();
 }
 
 bool OneCopyTileTaskWorkerPool::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
@@ skipping 63 matching lines @@
 
   scoped_ptr<StagingBuffer> staging_buffer;
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
   DCHECK(context_provider);
 
   ContextProvider::ScopedContextLock scoped_context(context_provider);
 
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
-  DCHECK(gl);
+  if (gl) {
+    // Check if any busy buffers have become available.
+    if (resource_provider_->use_sync_query()) {
+      while (!busy_buffers_.empty()) {
+        if (!CheckForQueryResult(gl, busy_buffers_.front()->query_id))
+          break;
 
-  // Check if any busy buffers have become available.
-  if (resource_provider_->use_sync_query()) {
-    while (!busy_buffers_.empty()) {
-      if (!CheckForQueryResult(gl, busy_buffers_.front()->query_id))
-        break;
-
-      MarkStagingBufferAsFree(busy_buffers_.front());
-      free_buffers_.push_back(busy_buffers_.take_front());
-    }
-  }
-
-  // Wait for memory usage of non-free buffers to become less than the limit.
-  while (
-      (staging_buffer_usage_in_bytes_ - free_staging_buffer_usage_in_bytes_) >=
-      max_staging_buffer_usage_in_bytes_) {
-    // Stop when there are no more busy buffers to wait for.
-    if (busy_buffers_.empty())
-      break;
-
-    if (resource_provider_->use_sync_query()) {
-      WaitForQueryResult(gl, busy_buffers_.front()->query_id);
-      MarkStagingBufferAsFree(busy_buffers_.front());
-      free_buffers_.push_back(busy_buffers_.take_front());
-    } else {
-      // Fall-back to glFinish if CHROMIUM_sync_query is not available.
-      gl->Finish();
-      while (!busy_buffers_.empty()) {
         MarkStagingBufferAsFree(busy_buffers_.front());
         free_buffers_.push_back(busy_buffers_.take_front());
       }
     }
+
+    // Wait for memory usage of non-free buffers to become less than the limit.
+    while ((staging_buffer_usage_in_bytes_ -
+            free_staging_buffer_usage_in_bytes_) >=
+           max_staging_buffer_usage_in_bytes_) {
+      // Stop when there are no more busy buffers to wait for.
+      if (busy_buffers_.empty())
+        break;
+
+      if (resource_provider_->use_sync_query()) {
+        WaitForQueryResult(gl, busy_buffers_.front()->query_id);
+        MarkStagingBufferAsFree(busy_buffers_.front());
+        free_buffers_.push_back(busy_buffers_.take_front());
+      } else {
+        // Fall-back to glFinish if CHROMIUM_sync_query is not available.
+        gl->Finish();
+        while (!busy_buffers_.empty()) {
+          MarkStagingBufferAsFree(busy_buffers_.front());
+          free_buffers_.push_back(busy_buffers_.take_front());
+        }
+      }
+    }
   }
 
   // Find a staging buffer that allows us to perform partial raster when
   // using persistent GpuMemoryBuffers.
   if (use_persistent_gpu_memory_buffers_ && previous_content_id) {
     StagingBufferDeque::iterator it =
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
                      [previous_content_id](const StagingBuffer* buffer) {
                        return buffer->content_id == previous_content_id;
                      });
@@ skipping 94 matching lines @@
   lock_.AssertAcquired();
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
   DCHECK(context_provider);
 
   {
     ContextProvider::ScopedContextLock scoped_context(context_provider);
 
     gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
-    DCHECK(gl);
 
     // Note: Front buffer is guaranteed to be LRU so we can stop releasing
     // buffers as soon as we find a buffer that has been used since |time|.
     while (!free_buffers_.empty()) {
       if (free_buffers_.front()->last_usage > time)
         return;
 
       free_buffers_.front()->DestroyGLResources(gl);
       MarkStagingBufferAsBusy(free_buffers_.front());
       RemoveStagingBuffer(free_buffers_.front());
@@ skipping 48 matching lines @@
 
   staging_state->SetInteger("staging_buffer_count",
                             static_cast<int>(buffers_.size()));
   staging_state->SetInteger("busy_count",
                             static_cast<int>(busy_buffers_.size()));
   staging_state->SetInteger("free_count",
                             static_cast<int>(free_buffers_.size()));
 }
 
 }  // namespace cc