Add InProcessContextProvider and update InProcessCommandBuffer

gpu/ipc/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/ipc/gl_in_process_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
 class GLInProcessContextImpl
     : public GLInProcessContext,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   GLInProcessContextImpl();
   ~GLInProcessContextImpl() override;
 
   bool Initialize(scoped_refptr<gl::GLSurface> surface,
                   bool is_offscreen,
                   GLInProcessContext* share_context,
-                  gfx::AcceleratedWidget window,
+                  SurfaceHandle window,
                   const gpu::gles2::ContextCreationAttribHelper& attribs,
                   const scoped_refptr<InProcessCommandBuffer::Service>& service,
                   const SharedMemoryLimits& mem_limits,
                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
                   ImageFactory* image_factory,
                   scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   // GLInProcessContext implementation:
   gles2::GLES2Implementation* GetImplementation() override;
+  void SetSwapBuffersCompletionCallback(
+      const gpu::InProcessCommandBuffer::SwapBuffersCompletionCallback&
+          callback) override;
+  void SetUpdateVSyncParametersCallback(
+      const gpu::InProcessCommandBuffer::UpdateVSyncParametersCallback&
+          callback) override;
   void SetLock(base::Lock* lock) override;
 
  private:
   void Destroy();
   void OnSignalSyncPoint(const base::Closure& callback);
 
   std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   std::unique_ptr<TransferBuffer> transfer_buffer_;
   std::unique_ptr<gles2::GLES2Implementation> gles2_implementation_;
   std::unique_ptr<InProcessCommandBuffer> command_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl);
 };
 
 GLInProcessContextImpl::GLInProcessContextImpl() = default;
 
 GLInProcessContextImpl::~GLInProcessContextImpl() {
   Destroy();
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
+void GLInProcessContextImpl::SetSwapBuffersCompletionCallback(
+    const gpu::InProcessCommandBuffer::SwapBuffersCompletionCallback&
+        callback) {
+  command_buffer_->SetSwapBuffersCompletionCallback(callback);
+}
+
+void GLInProcessContextImpl::SetUpdateVSyncParametersCallback(
+    const gpu::InProcessCommandBuffer::UpdateVSyncParametersCallback&
+        callback) {
+  command_buffer_->SetUpdateVSyncParametersCallback(callback);
+}
+
 void GLInProcessContextImpl::SetLock(base::Lock* lock) {
   NOTREACHED();
 }
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     GLInProcessContext* share_context,
-    gfx::AcceleratedWidget window,
+    SurfaceHandle window,
     const gles2::ContextCreationAttribHelper& attribs,
     const scoped_refptr<InProcessCommandBuffer::Service>& service,
     const SharedMemoryLimits& mem_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     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));
@@ skipping 66 matching lines @@
   command_buffer_.reset();
 }
 
 }  // anonymous namespace
 
 // static
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
-    gfx::AcceleratedWidget window,
+    SurfaceHandle window,
     GLInProcessContext* share_context,
     const ::gpu::gles2::ContextCreationAttribHelper& attribs,
     const SharedMemoryLimits& memory_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     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);
+    DCHECK_EQ(kNullSurfaceHandle, 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,
                            std::move(task_runner)))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu