Update from chromium https://crrev.com/302282

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 <set>
 #include <utility>
 #include <vector>
 
@@ skipping 32 matching lines @@
 const unsigned int kDefaultMaxTransferBufferSize = 16 * 1024 * 1024;
 
 class GLInProcessContextImpl
     : public GLInProcessContext,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   explicit GLInProcessContextImpl(
       const GLInProcessContextSharedMemoryLimits& mem_limits);
   ~GLInProcessContextImpl() override;
 
-  bool Initialize(
-      scoped_refptr<gfx::GLSurface> surface,
-      bool is_offscreen,
-      bool use_global_share_group,
-      GLInProcessContext* share_context,
-      gfx::AcceleratedWidget window,
-      const gfx::Size& size,
-      const gpu::gles2::ContextCreationAttribHelper& attribs,
-      gfx::GpuPreference gpu_preference,
-      const scoped_refptr<InProcessCommandBuffer::Service>& service);
+  bool Initialize(scoped_refptr<gfx::GLSurface> surface,
+                  bool is_offscreen,
+                  bool use_global_share_group,
+                  GLInProcessContext* share_context,
+                  gfx::AcceleratedWidget window,
+                  const gfx::Size& size,
+                  const gpu::gles2::ContextCreationAttribHelper& attribs,
+                  gfx::GpuPreference gpu_preference,
+                  const scoped_refptr<InProcessCommandBuffer::Service>& service,
+                  GpuMemoryBufferManager* gpu_memory_buffer_manager,
+                  ImageFactory* image_factory);
 
   // GLInProcessContext implementation:
   void SetContextLostCallback(const base::Closure& callback) override;
   gles2::GLES2Implementation* GetImplementation() override;
   size_t GetMappedMemoryLimit() override;
 
 #if defined(OS_ANDROID)
   virtual scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
       uint32 stream_id) override;
 #endif
@@ skipping 55 matching lines @@
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     bool use_global_share_group,
     GLInProcessContext* share_context,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const gles2::ContextCreationAttribHelper& attribs,
     gfx::GpuPreference gpu_preference,
-    const scoped_refptr<InProcessCommandBuffer::Service>& service) {
+    const scoped_refptr<InProcessCommandBuffer::Service>& service,
+    GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    ImageFactory* image_factory) {
   DCHECK(!use_global_share_group || !share_context);
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   std::vector<int32> attrib_vector;
   attribs.Serialize(&attrib_vector);
 
   base::Closure wrapped_callback =
       base::Bind(&GLInProcessContextImpl::OnContextLost, AsWeakPtr());
   command_buffer_.reset(new InProcessCommandBuffer(service));
 
@@ skipping 25 matching lines @@
     DCHECK(share_command_buffer);
   }
 
   if (!command_buffer_->Initialize(surface,
                                    is_offscreen,
                                    window,
                                    size,
                                    attrib_vector,
                                    gpu_preference,
                                    wrapped_callback,
-                                   share_command_buffer)) {
+                                   share_command_buffer,
+                                   gpu_memory_buffer_manager,
+                                   image_factory)) {
     LOG(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;
@@ skipping 69 matching lines @@
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     GLInProcessContext* share_context,
     bool use_global_share_group,
     const ::gpu::gles2::ContextCreationAttribHelper& attribs,
     gfx::GpuPreference gpu_preference,
-    const GLInProcessContextSharedMemoryLimits& memory_limits) {
+    const GLInProcessContextSharedMemoryLimits& memory_limits,
+    GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    ImageFactory* image_factory) {
   DCHECK(!use_global_share_group || !share_context);
   if (surface.get()) {
     DCHECK_EQ(surface->IsOffscreen(), is_offscreen);
     DCHECK(surface->GetSize() == size);
     DCHECK_EQ(gfx::kNullAcceleratedWidget, window);
   }
 
   scoped_ptr<GLInProcessContextImpl> context(
       new GLInProcessContextImpl(memory_limits));
   if (!context->Initialize(surface,
                            is_offscreen,
                            use_global_share_group,
                            share_context,
                            window,
                            size,
                            attribs,
                            gpu_preference,
-                           service))
+                           service,
+                           gpu_memory_buffer_manager,
+                           image_factory))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu