Provide TaskRunner to ContextCacheController

gpu/command_buffer/client/gl_in_process_context.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 "gpu/command_buffer/client/gl_in_process_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_ANDROID)
@@ skipping 12 matching lines @@
   ~GLInProcessContextImpl() override;
 
   bool Initialize(scoped_refptr<gl::GLSurface> surface,
                   bool is_offscreen,
                   GLInProcessContext* share_context,
                   gfx::AcceleratedWidget window,
                   const gpu::gles2::ContextCreationAttribHelper& attribs,
                   const scoped_refptr<InProcessCommandBuffer::Service>& service,
                   const SharedMemoryLimits& mem_limits,
                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
-                  ImageFactory* image_factory);
+                  ImageFactory* image_factory,
+                  scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   // GLInProcessContext implementation:
   gles2::GLES2Implementation* GetImplementation() override;
   void SetLock(base::Lock* lock) override;
 
  private:
   void Destroy();
   void OnSignalSyncPoint(const base::Closure& callback);
 
   std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_;
@@ skipping 20 matching lines @@
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     GLInProcessContext* share_context,
     gfx::AcceleratedWidget window,
     const gles2::ContextCreationAttribHelper& attribs,
     const scoped_refptr<InProcessCommandBuffer::Service>& service,
     const SharedMemoryLimits& mem_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    ImageFactory* image_factory) {
+    ImageFactory* image_factory,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK_GE(attribs.offscreen_framebuffer_size.width(), 0);
   DCHECK_GE(attribs.offscreen_framebuffer_size.height(), 0);
 
   command_buffer_.reset(new InProcessCommandBuffer(service));
 
   scoped_refptr<gles2::ShareGroup> share_group;
   InProcessCommandBuffer* share_command_buffer = nullptr;
   if (share_context) {
     GLInProcessContextImpl* impl =
         static_cast<GLInProcessContextImpl*>(share_context);
     share_group = impl->gles2_implementation_->share_group();
     share_command_buffer = impl->command_buffer_.get();
     DCHECK(share_group);
     DCHECK(share_command_buffer);
   }
 
-  if (!command_buffer_->Initialize(surface,
-                                   is_offscreen,
-                                   window,
-                                   attribs,
-                                   share_command_buffer,
-                                   gpu_memory_buffer_manager,
-                                   image_factory)) {
+  if (!command_buffer_->Initialize(
+          surface, is_offscreen, window, attribs, share_command_buffer,
+          gpu_memory_buffer_manager, image_factory, std::move(task_runner))) {
     DLOG(ERROR) << "Failed to initialize InProcessCommmandBuffer";
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(mem_limits.command_buffer_size)) {
     LOG(ERROR) << "Failed to initialize GLES2CmdHelper";
     Destroy();
     return false;
   }
 
   // Create a transfer buffer.
   transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get()));
 
   // Check for consistency.
   DCHECK(!attribs.bind_generates_resource);
   const bool bind_generates_resource = false;
   const bool support_client_side_arrays = false;
 
   // Create the object exposing the OpenGL API.
-  gles2_implementation_.reset(
-      new gles2::GLES2Implementation(gles2_helper_.get(),
-                                     share_group.get(),
-                                     transfer_buffer_.get(),
-                                     bind_generates_resource,
-                                     attribs.lose_context_when_out_of_memory,
-                                     support_client_side_arrays,
-                                     command_buffer_.get()));
+  gles2_implementation_.reset(new gles2::GLES2Implementation(
+      gles2_helper_.get(), share_group.get(), transfer_buffer_.get(),
+      bind_generates_resource, attribs.lose_context_when_out_of_memory,
+      support_client_side_arrays, command_buffer_.get()));
 
   if (!gles2_implementation_->Initialize(
           mem_limits.start_transfer_buffer_size,
           mem_limits.min_transfer_buffer_size,
           mem_limits.max_transfer_buffer_size,
           mem_limits.mapped_memory_reclaim_limit)) {
     return false;
   }
 
   return true;
@@ skipping 21 matching lines @@
 // static
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     GLInProcessContext* share_context,
     const ::gpu::gles2::ContextCreationAttribHelper& attribs,
     const SharedMemoryLimits& memory_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    ImageFactory* image_factory) {
-  if (surface.get()) {
+    ImageFactory* image_factory,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  // If a surface is provided, we are running in a webview and should not have
+  // a task runner. We must have a task runner in all other cases.
+  DCHECK_EQ(!!surface, !task_runner);
+
+  if (surface) {
     DCHECK_EQ(surface->IsOffscreen(), is_offscreen);
     DCHECK_EQ(gfx::kNullAcceleratedWidget, window);
   }
 
   std::unique_ptr<GLInProcessContextImpl> context(new GLInProcessContextImpl);
   if (!context->Initialize(surface, is_offscreen, share_context, window,
                            attribs, service, memory_limits,
-                           gpu_memory_buffer_manager, image_factory))
+                           gpu_memory_buffer_manager, image_factory,
+                           std::move(task_runner)))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu