Make ShaderTranslatorCache thread safe

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>
 
@@ skipping 55 matching lines @@
   virtual void AddRef() const OVERRIDE {
     base::RefCountedThreadSafe<GpuInProcessThread>::AddRef();
   }
   virtual void Release() const OVERRIDE {
     base::RefCountedThreadSafe<GpuInProcessThread>::Release();
   }
 
   virtual void ScheduleTask(const base::Closure& task) OVERRIDE;
   virtual void ScheduleIdleWork(const base::Closure& callback) OVERRIDE;
   virtual bool UseVirtualizedGLContexts() OVERRIDE { return false; }
+  virtual scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
+      OVERRIDE;
 
  private:
   virtual ~GpuInProcessThread();
   friend class base::RefCountedThreadSafe<GpuInProcessThread>;
 
+  scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 };
 
 GpuInProcessThread::GpuInProcessThread() : base::Thread("GpuThread") {
   Start();
 }
 
 GpuInProcessThread::~GpuInProcessThread() {
   Stop();
 }
 
 void GpuInProcessThread::ScheduleTask(const base::Closure& task) {
   message_loop()->PostTask(FROM_HERE, task);
 }
 
 void GpuInProcessThread::ScheduleIdleWork(const base::Closure& callback) {
   message_loop()->PostDelayedTask(
       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_ =
     LAZY_INSTANCE_INITIALIZER;
 
 class ScopedEvent {
  public:
   ScopedEvent(base::WaitableEvent* event) : event_(event) {}
   ~ScopedEvent() { event_->Signal(); }
 
@@ skipping 207 matching lines @@
   gl_share_group_ = params.context_group
                         ? params.context_group->gl_share_group_.get()
                         : new gfx::GLShareGroup;
 
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset(new StreamTextureManagerInProcess);
 #endif
 
   bool bind_generates_resource = false;
   decoder_.reset(gles2::GLES2Decoder::Create(
-      params.context_group ? params.context_group->decoder_->GetContextGroup()
-                    : new gles2::ContextGroup(NULL,
-                                              NULL,
-                                              NULL,
-                                              NULL,
-                                              bind_generates_resource)));
+      params.context_group
+          ? params.context_group->decoder_->GetContextGroup()
+          : new gles2::ContextGroup(NULL,
+                                    NULL,
+                                    NULL,
+                                    service_->shader_translator_cache(),
+                                    NULL,
+                                    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());
 
   if (!surface_) {
@@ skipping 398 matching lines @@
 }
 #endif
 
 // static
 void InProcessCommandBuffer::SetGpuMemoryBufferFactory(
     GpuMemoryBufferFactory* factory) {
   g_gpu_memory_buffer_factory = factory;
 }
 
 }  // namespace gpu