Update from https://crrev.com/316786

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 48 matching lines @@
                   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;
+  void SetLock(base::Lock* lock) override;
 
 #if defined(OS_ANDROID)
   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
       uint32 stream_id) override;
 #endif
 
  private:
   void Destroy();
   void OnContextLost();
   void OnSignalSyncPoint(const base::Closure& callback);
 
   scoped_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<gles2::GLES2Implementation> gles2_implementation_;
   scoped_ptr<InProcessCommandBuffer> command_buffer_;
 
   const GLInProcessContextSharedMemoryLimits mem_limits_;
   bool context_lost_;
   base::Closure context_lost_callback_;
+  base::Lock* lock_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl);
 };
 
 base::LazyInstance<base::Lock> g_all_shared_contexts_lock =
     LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<std::set<GLInProcessContextImpl*> > g_all_shared_contexts =
     LAZY_INSTANCE_INITIALIZER;
 
 GLInProcessContextImpl::GLInProcessContextImpl(
     const GLInProcessContextSharedMemoryLimits& mem_limits)
-    : mem_limits_(mem_limits), context_lost_(false) {
+    : mem_limits_(mem_limits), context_lost_(false), lock_(nullptr) {
 }
 
 GLInProcessContextImpl::~GLInProcessContextImpl() {
   {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     g_all_shared_contexts.Get().erase(this);
   }
   Destroy();
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
 size_t GLInProcessContextImpl::GetMappedMemoryLimit() {
   return mem_limits_.mapped_memory_reclaim_limit;
 }
 
+void GLInProcessContextImpl::SetLock(base::Lock* lock) {
+  command_buffer_->SetLock(lock);
+  lock_ = lock;
+}
+
 void GLInProcessContextImpl::SetContextLostCallback(
     const base::Closure& callback) {
   context_lost_callback_ = callback;
 }
 
 void GLInProcessContextImpl::OnContextLost() {
+  scoped_ptr<base::AutoLock> lock;
+  if (lock_)
+    lock.reset(new base::AutoLock(*lock_));
   context_lost_ = true;
   if (!context_lost_callback_.is_null()) {
     context_lost_callback_.Run();
   }
 }
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     bool use_global_share_group,
@@ skipping 166 matching lines @@
                            gpu_preference,
                            service,
                            gpu_memory_buffer_manager,
                            image_factory))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu