Update from https://crrev.com/306655

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequence_checker.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/mailbox_manager_sync.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
@@ skipping 66 matching lines @@
       FROM_HERE, callback, base::TimeDelta::FromMilliseconds(5));
 }
 
 scoped_refptr<gles2::ShaderTranslatorCache>
 GpuInProcessThread::shader_translator_cache() {
   if (!shader_translator_cache_.get())
     shader_translator_cache_ = new gpu::gles2::ShaderTranslatorCache;
   return shader_translator_cache_;
 }
 
-base::LazyInstance<std::set<InProcessCommandBuffer*> > default_thread_clients_ =
-    LAZY_INSTANCE_INITIALIZER;
-base::LazyInstance<base::Lock> default_thread_clients_lock_ =
+struct GpuInProcessThreadHolder {
+  GpuInProcessThreadHolder() : gpu_thread(new GpuInProcessThread) {}
+  scoped_refptr<InProcessCommandBuffer::Service> gpu_thread;
+};
+
+base::LazyInstance<GpuInProcessThreadHolder> g_default_service =
     LAZY_INSTANCE_INITIALIZER;
 
 class ScopedEvent {
  public:
   ScopedEvent(base::WaitableEvent* event) : event_(event) {}
   ~ScopedEvent() { event_->Signal(); }
 
  private:
   base::WaitableEvent* event_;
 };
@@ skipping 66 matching lines @@
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableThreadedTextureMailboxes)) {
       mailbox_manager_ = new gles2::MailboxManagerSync();
     } else {
       mailbox_manager_ = new gles2::MailboxManagerImpl();
     }
   }
   return mailbox_manager_;
 }
 
-scoped_refptr<InProcessCommandBuffer::Service>
-InProcessCommandBuffer::GetDefaultService() {
-  base::AutoLock lock(default_thread_clients_lock_.Get());
-  scoped_refptr<Service> service;
-  if (!default_thread_clients_.Get().empty()) {
-    InProcessCommandBuffer* other = *default_thread_clients_.Get().begin();
-    service = other->service_;
-    DCHECK(service.get());
-  } else {
-    service = new GpuInProcessThread;
+scoped_refptr<gpu::ValueStateMap>
+InProcessCommandBuffer::Service::pending_valuebuffer_state() {
+  if (!pending_valuebuffer_state_.get()) {
+    pending_valuebuffer_state_ = new gpu::ValueStateMap();
   }
-  return service;
+  return pending_valuebuffer_state_;
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : context_lost_(false),
       idle_work_pending_(false),
       image_factory_(nullptr),
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
       flush_event_(false, false),
-      service_(service.get() ? service : GetDefaultService()),
+      service_(service.get() ? service : g_default_service.Get().gpu_thread),
       gpu_thread_weak_ptr_factory_(this) {
-  if (!service.get()) {
-    base::AutoLock lock(default_thread_clients_lock_.Get());
-    default_thread_clients_.Get().insert(this);
-  }
+  DCHECK(service_.get());
   next_image_id_.GetNext();
 }
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
-  base::AutoLock lock(default_thread_clients_lock_.Get());
-  default_thread_clients_.Get().erase(this);
 }
 
 void InProcessCommandBuffer::OnResizeView(gfx::Size size, float scale_factor) {
   CheckSequencedThread();
   DCHECK(!surface_->IsOffscreen());
   surface_->Resize(size);
 }
 
 bool InProcessCommandBuffer::MakeCurrent() {
   CheckSequencedThread();
@@ skipping 109 matching lines @@
 #endif
 
   bool bind_generates_resource = false;
   decoder_.reset(gles2::GLES2Decoder::Create(
       params.context_group
           ? params.context_group->decoder_->GetContextGroup()
           : new gles2::ContextGroup(service_->mailbox_manager(),
                                     NULL,
                                     service_->shader_translator_cache(),
                                     NULL,
+                                    service_->pending_valuebuffer_state(),
                                     bind_generates_resource)));
 
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
   command_buffer_ = command_buffer.Pass();
 
   decoder_->set_engine(gpu_scheduler_.get());
 
@@ skipping 503 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu