Move bindToCurrentThread out to the creators of WebGL contexts.

content/renderer/renderer_blink_platform_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/renderer_blink_platform_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 1010 matching lines @@
           "creation failed");
       break;
   }
 }
 
 blink::WebGraphicsContext3DProvider*
 RendererBlinkPlatformImpl::createOffscreenGraphicsContext3DProvider(
     const blink::Platform::ContextAttributes& web_attributes,
     const blink::WebURL& top_document_web_url,
     blink::WebGraphicsContext3DProvider* share_provider,
-    blink::Platform::GraphicsInfo* gl_info,
-    blink::Platform::WillBindToCurrentThread will_bind_to_current_thread) {
+    blink::Platform::GraphicsInfo* gl_info) {
   DCHECK(gl_info);
   if (!RenderThreadImpl::current()) {
     std::string error_message("Failed to run in Current RenderThreadImpl");
     gl_info->errorMessage = WebString::fromUTF8(error_message);
     return nullptr;
   }
 
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
       RenderThreadImpl::current()->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_WEBGL_CONTEXT));
   if (!gpu_channel_host) {
     std::string error_message(
         "OffscreenContext Creation failed, GpuChannelHost creation failed");
     gl_info->errorMessage = WebString::fromUTF8(error_message);
     return nullptr;
   }
   Collect3DContextInformation(gl_info, gpu_channel_host->gpu_info());
 
   content::WebGraphicsContext3DProviderImpl* share_provider_impl =
       static_cast<content::WebGraphicsContext3DProviderImpl*>(share_provider);
   ContextProviderCommandBuffer* share_context = nullptr;
 
-  if (will_bind_to_current_thread == blink::Platform::DoNotBindToCurrentThread)
-    DCHECK(!share_provider_impl);
-
   // WebGL contexts must fail creation if the share group is lost.
   if (share_provider_impl) {
     auto* gl = share_provider_impl->contextGL();
     if (gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
       std::string error_message(
           "OffscreenContext Creation failed, Shared context is lost");
       gl_info->errorMessage = WebString::fromUTF8(error_message);
       return nullptr;
     }
     share_context = share_provider_impl->context_provider();
@@ skipping 23 matching lines @@
   // Prefer discrete GPU for WebGL.
   constexpr gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   scoped_refptr<ContextProviderCommandBuffer> provider(
       new ContextProviderCommandBuffer(
           std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
           gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle,
           GURL(top_document_web_url), gpu_preference, automatic_flushes,
           support_locking, gpu::SharedMemoryLimits(), attributes, share_context,
           command_buffer_metrics::OFFSCREEN_CONTEXT_FOR_WEBGL));
-  if (will_bind_to_current_thread == blink::Platform::BindToCurrentThread) {
-    if (!provider->BindToCurrentThread()) {
-      std::string error_message(
-          "ContextProviderCommandBuffer::BindToCurrentThread failed: ");
-      error_message.append(gl_info->errorMessage.utf8());
-      gl_info->errorMessage = WebString::fromUTF8(error_message);
-      return nullptr;
-    }
-  }
   return new WebGraphicsContext3DProviderImpl(std::move(provider));
 }
 
 //------------------------------------------------------------------------------
 
 blink::WebGraphicsContext3DProvider*
 RendererBlinkPlatformImpl::createSharedOffscreenGraphicsContext3DProvider() {
   scoped_refptr<ContextProviderCommandBuffer> provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider();
   if (!provider)
@@ skipping 189 matching lines @@
   return &trial_token_validator_;
 }
 
 void RendererBlinkPlatformImpl::workerContextCreated(
     const v8::Local<v8::Context>& worker) {
   GetContentClient()->renderer()->DidInitializeWorkerContextOnWorkerThread(
       worker);
 }
 
 }  // namespace content