cc: Implement shared worker contexts. (v1)

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 <vector>
@@ skipping 825 matching lines @@
   // RenderThreadImpl.
   embedded_worker_dispatcher_.reset();
 
   // Ramp down IDB before we ramp down WebKit (and V8), since IDB classes might
   // hold pointers to V8 objects (e.g., via pending requests).
   main_thread_indexed_db_dispatcher_.reset();
 
   main_thread_compositor_task_runner_ = NULL;
 
   // Context providers must be released prior to destroying the GPU channel.
+  shared_worker_context_provider_ = nullptr;
   gpu_va_context_provider_ = nullptr;
   shared_main_thread_contexts_ = nullptr;
 
   if (gpu_channel_.get())
     gpu_channel_->DestroyChannel();
 
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   NPChannelBase::CleanupChannels();
@@ skipping 474 matching lines @@
     }
     return NULL;
   }
 #endif
 
   scoped_refptr<GpuChannelHost> gpu_channel_host = GetGpuChannel();
   scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories;
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       GetMediaThreadTaskRunner();
   if (!gpu_va_context_provider_.get() ||
-      gpu_va_context_provider_->DestroyedOnMainThread()) {
+      gpu_va_context_provider_->HasBeenLostOnMainThread()) {
     if (!gpu_channel_host.get()) {
       gpu_channel_host = EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
     }
     blink::WebGraphicsContext3D::Attributes attributes;
     bool lose_context_when_out_of_memory = false;
     gpu_va_context_provider_ = ContextProviderCommandBuffer::Create(
         make_scoped_ptr(
             WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
                 gpu_channel_host.get(), attributes,
@@ skipping 41 matching lines @@
           lose_context_when_out_of_memory,
           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d"),
           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
           NULL));
 }
 
 scoped_refptr<cc_blink::ContextProviderWebContext>
 RenderThreadImpl::SharedMainThreadContextProvider() {
   DCHECK(IsMainThread());
   if (!shared_main_thread_contexts_.get() ||
-      shared_main_thread_contexts_->DestroyedOnMainThread()) {
+      shared_main_thread_contexts_->HasBeenLostOnMainThread()) {
     shared_main_thread_contexts_ = NULL;
 #if defined(OS_ANDROID)
     SynchronousCompositorFactory* factory =
         SynchronousCompositorFactory::GetInstance();
     if (factory && factory->OverrideWithFactory()) {
       shared_main_thread_contexts_ = factory->CreateOffscreenContextProvider(
           GetOffscreenAttribs(), "Offscreen-MainThread");
     }
 #endif
     if (!shared_main_thread_contexts_.get()) {
@@ skipping 462 matching lines @@
     AddFilter(renderer_demuxer_.get());
 #endif
   }
   return media_thread_->task_runner();
 }
 
 base::TaskRunner* RenderThreadImpl::GetWorkerTaskRunner() {
   return raster_worker_pool_.get();
 }
 
+scoped_refptr<ContextProviderCommandBuffer>
+RenderThreadImpl::SharedWorkerContextProvider() {
+  DCHECK(IsMainThread());
+  // Try to reuse existing shared worker context provider.
+  if (shared_worker_context_provider_) {
+    base::AutoLock lock(*shared_worker_context_provider_->GetLock());
+    if (shared_worker_context_provider_->ContextGL()
+            ->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
+      shared_worker_context_provider_->Destroy();
+      shared_worker_context_provider_ = nullptr;
+    }
+  }
+  if (!shared_worker_context_provider_) {
+    shared_worker_context_provider_ = ContextProviderCommandBuffer::Create(
+        CreateOffscreenContext3d(), RENDER_WORKER_CONTEXT);
+    if (shared_worker_context_provider_ &&
+        !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);
 }
 
 bool RenderThreadImpl::RendererIsHidden() const {
   return widget_count_ > 0 && hidden_widget_count_ == widget_count_;
 }
 
 void RenderThreadImpl::WidgetCreated() {
   bool renderer_was_hidden = RendererIsHidden();
@@ skipping 72 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content