Split the media context from the compositor 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 1382 matching lines @@
             base::Bind(
                 base::IgnoreResult(
                     &RendererGpuVideoAcceleratorFactories::CheckContextLost),
                 base::Unretained(gpu_factories_.back())));
       }
     }
   }
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
+      EstablishGpuChannelSync(CAUSE_FOR_GPU_LAUNCH_MEDIA_CONTEXT);
+  if (!gpu_channel_host)
+    return nullptr;
+  scoped_refptr<ContextProviderCommandBuffer> shared_context_provider =
+      CreateOffscreenContext(gpu_channel_host,
+                             command_buffer_metrics::RENDER_WORKER_CONTEXT);
+  if (!shared_worker_context_provider_->BindToCurrentThread())

[piman, 2016/05/06 23:38:57]

Did you mean shared_context_provider here?

[danakj, 2016/05/09 17:25:39]

I need to rename this, cuz ya I did.

+    return nullptr;
+  shared_worker_context_provider_->SetupLock();
+
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       GetMediaThreadTaskRunner();
-  scoped_refptr<ContextProviderCommandBuffer> shared_context_provider =
-      SharedWorkerContextProvider();
-  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host = GetGpuChannel();
-  if (shared_context_provider && gpu_channel_host) {
-    const bool enable_video_accelerator =
-        !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
-    const bool enable_gpu_memory_buffer_video_frames =
+  const bool enable_video_accelerator =
+      !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
+  const bool enable_gpu_memory_buffer_video_frames =
 #if defined(OS_MACOSX) || defined(OS_LINUX)
-        !cmd_line->HasSwitch(switches::kDisableGpuMemoryBufferVideoFrames);
+      !cmd_line->HasSwitch(switches::kDisableGpuMemoryBufferVideoFrames);
 #else
-        cmd_line->HasSwitch(switches::kEnableGpuMemoryBufferVideoFrames);
+      cmd_line->HasSwitch(switches::kEnableGpuMemoryBufferVideoFrames);
 #endif
-    std::vector<unsigned> image_texture_targets;
-    std::string video_frame_image_texture_target_string =
-        cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
-    StringToUintVector(video_frame_image_texture_target_string,
-                       &image_texture_targets);
+  std::vector<unsigned> image_texture_targets;
+  std::string video_frame_image_texture_target_string =
+      cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
+  StringToUintVector(video_frame_image_texture_target_string,
+                     &image_texture_targets);
 
-    gpu_factories_.push_back(RendererGpuVideoAcceleratorFactories::Create(
-        std::move(gpu_channel_host), base::ThreadTaskRunnerHandle::Get(),
-        media_task_runner, shared_context_provider,
-        enable_gpu_memory_buffer_video_frames, image_texture_targets,
-        enable_video_accelerator));
-    return gpu_factories_.back();
-  }
-  return nullptr;
+  gpu_factories_.push_back(RendererGpuVideoAcceleratorFactories::Create(
+      std::move(gpu_channel_host), base::ThreadTaskRunnerHandle::Get(),
+      media_task_runner, std::move(shared_context_provider),
+      enable_gpu_memory_buffer_video_frames, image_texture_targets,
+      enable_video_accelerator));
+  return gpu_factories_.back();
 }
 
 scoped_refptr<ContextProviderCommandBuffer>
 RenderThreadImpl::SharedMainThreadContextProvider() {
   DCHECK(IsMainThread());
   if (shared_main_thread_contexts_ &&
       shared_main_thread_contexts_->ContextGL()->GetGraphicsResetStatusKHR() ==
           GL_NO_ERROR)
     return shared_main_thread_contexts_;
 
@@ skipping 485 matching lines @@
 #endif
   }
   return media_thread_->task_runner();
 }
 
 base::TaskRunner* RenderThreadImpl::GetWorkerTaskRunner() {
   return raster_worker_pool_.get();
 }
 
 scoped_refptr<ContextProviderCommandBuffer>
-RenderThreadImpl::SharedWorkerContextProvider() {
+RenderThreadImpl::SharedCompositorWorkerContextProvider() {
   DCHECK(IsMainThread());
   // Try to reuse existing shared worker context provider.
   if (shared_worker_context_provider_) {
     // Note: If context is lost, delete reference after releasing the lock.
     cc::ContextProvider::ScopedContextLock lock(
         shared_worker_context_provider_.get());
     if (shared_worker_context_provider_->ContextGL()
             ->GetGraphicsResetStatusKHR() == GL_NO_ERROR)
       return shared_worker_context_provider_;
   }
@@ skipping 99 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content