gpu: Add flag for enabling asynchronous worker context.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 385 matching lines @@
   for (size_t i = 0; i < pieces.size(); ++i) {
     unsigned number = 0;
     bool succeed = base::StringToUint(pieces[i], &number);
     DCHECK(succeed);
     vector->push_back(number);
   }
 }
 
 scoped_refptr<ContextProviderCommandBuffer> CreateOffscreenContext(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
-    command_buffer_metrics::ContextType type) {
+    command_buffer_metrics::ContextType type,
+    int32_t stream_id,
+    gpu::GpuStreamPriority stream_priority) {
   DCHECK(gpu_channel_host);
   // This is used to create a few different offscreen contexts:
   // - The shared main thread context (offscreen) used by blink for canvas.
   // - The worker context (offscreen) used for GPU raster and video decoding.
   // This is for an offscreen context, so the default framebuffer doesn't need
   // alpha, depth, stencil, antialiasing.
   gpu::gles2::ContextCreationAttribHelper attributes;
   attributes.alpha_size = -1;
   attributes.depth_size = 0;
   attributes.stencil_size = 0;
   attributes.samples = 0;
   attributes.sample_buffers = 0;
   attributes.bind_generates_resource = false;
   attributes.lose_context_when_out_of_memory = true;
-  constexpr bool automatic_flushes = false;
+  const bool automatic_flushes = false;
   return make_scoped_refptr(new ContextProviderCommandBuffer(
-      std::move(gpu_channel_host), gpu::kNullSurfaceHandle,
+      std::move(gpu_channel_host), stream_id, stream_priority,
+      gpu::kNullSurfaceHandle,
       GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext"),
       gfx::PreferIntegratedGpu, automatic_flushes, gpu::SharedMemoryLimits(),
       attributes, nullptr, type));
 }
 
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
@@ skipping 302 matching lines @@
     is_lcd_text_enabled_ = false;
 #else
     is_lcd_text_enabled_ = true;
 #endif
   }
 
   is_gpu_rasterization_enabled_ =
       command_line.HasSwitch(switches::kEnableGpuRasterization);
   is_gpu_rasterization_forced_ =
       command_line.HasSwitch(switches::kForceGpuRasterization);
+  is_async_worker_context_enabled_ =
+      command_line.HasSwitch(switches::kEnableGpuAsyncWorkerContext);
 
   if (command_line.HasSwitch(switches::kGpuRasterizationMSAASampleCount)) {
     std::string string_value = command_line.GetSwitchValueASCII(
         switches::kGpuRasterizationMSAASampleCount);
     bool parsed_msaa_sample_count =
         base::StringToInt(string_value, &gpu_rasterization_msaa_sample_count_);
     DCHECK(parsed_msaa_sample_count) << string_value;
     DCHECK_GE(gpu_rasterization_msaa_sample_count_, 0);
   } else {
     gpu_rasterization_msaa_sample_count_ = -1;
@@ skipping 684 matching lines @@
 
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_RENDERER_SHARED_MAIN_THREAD_CONTEXT));
   if (!gpu_channel_host) {
     shared_main_thread_contexts_ = nullptr;
     return nullptr;
   }
 
   shared_main_thread_contexts_ = CreateOffscreenContext(
       std::move(gpu_channel_host),
-      command_buffer_metrics::RENDERER_MAINTHREAD_CONTEXT);
+      command_buffer_metrics::RENDERER_MAINTHREAD_CONTEXT,
+      gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL);
   if (!shared_main_thread_contexts_->BindToCurrentThread())
     shared_main_thread_contexts_ = nullptr;
   return shared_main_thread_contexts_;
 }
 
 #if defined(OS_ANDROID)
 
 scoped_refptr<StreamTextureFactory> RenderThreadImpl::GetStreamTexureFactory() {
   DCHECK(IsMainThread());
   if (!stream_texture_factory_.get() ||
@@ skipping 59 matching lines @@
 }
 
 bool RenderThreadImpl::IsGpuRasterizationForced() {
   return is_gpu_rasterization_forced_;
 }
 
 bool RenderThreadImpl::IsGpuRasterizationEnabled() {
   return is_gpu_rasterization_enabled_;
 }
 
+bool RenderThreadImpl::IsAsyncWorkerContextEnabled() {
+  return is_async_worker_context_enabled_;
+}
+
 int RenderThreadImpl::GetGpuRasterizationMSAASampleCount() {
   return gpu_rasterization_msaa_sample_count_;
 }
 
 bool RenderThreadImpl::IsLcdTextEnabled() {
   return is_lcd_text_enabled_;
 }
 
 bool RenderThreadImpl::IsDistanceFieldTextEnabled() {
   return is_distance_field_text_enabled_;
@@ skipping 405 matching lines @@
       return shared_worker_context_provider_;
   }
 
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT));
   if (!gpu_channel_host) {
     shared_worker_context_provider_ = nullptr;
     return shared_worker_context_provider_;
   }
 
+  int32_t stream_id = gpu::GPU_STREAM_DEFAULT;
+  gpu::GpuStreamPriority stream_priority = gpu::GpuStreamPriority::NORMAL;
+  if (is_async_worker_context_enabled_) {
+    stream_id = gpu_channel_host->GenerateStreamID();
+    stream_priority = gpu::GpuStreamPriority::LOW;
+  }
+
   shared_worker_context_provider_ =
       CreateOffscreenContext(std::move(gpu_channel_host),
-                             command_buffer_metrics::RENDER_WORKER_CONTEXT);
+                             command_buffer_metrics::RENDER_WORKER_CONTEXT,
+                             stream_id, stream_priority);
   if (!shared_worker_context_provider_->BindToCurrentThread())
     shared_worker_context_provider_ = nullptr;
   if (shared_worker_context_provider_)
     shared_worker_context_provider_->SetupLock();
   return shared_worker_context_provider_;
 }
 
 void RenderThreadImpl::SampleGamepads(blink::WebGamepads* data) {
   blink_platform_impl_->sampleGamepads(*data);
 }
@@ skipping 78 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content