gpu: Add GpuMemoryBufferFactory interface.

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 <utility>
 #include <vector>
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
 #include "gpu/command_buffer/client/image_factory.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/id_allocator.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/image_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
@@ skipping 25 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 class GLInProcessContextImpl;
 
 static base::LazyInstance<
     std::set<GLInProcessContextImpl*> >
         g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 
-static GLInProcessContext::GpuMemoryBufferCreator* g_gpu_memory_buffer_creator =
-    NULL;
+static GpuMemoryBufferFactory* g_gpu_memory_buffer_factory = NULL;
 
 // Also calls DetachFromThreadHack on all GLES2Decoders before the lock is
 // released to maintain the invariant that all decoders are unbound while the
 // lock is not held. This is to workaround DumpRenderTree using WGC3DIPCBI with
 // shared resources on different threads.
 // Remove this as part of crbug.com/234964.
 class AutoLockAndDecoderDetachThread {
  public:
   AutoLockAndDecoderDetachThread(
       base::Lock& lock,
       const std::set<GLInProcessContextImpl*>& contexts);
   ~AutoLockAndDecoderDetachThread();
 
  private:
   base::AutoLock auto_lock_;
   const std::set<GLInProcessContextImpl*>& contexts_;
 };
 
+size_t SharedContextCount() {
+  AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
+                                      g_all_shared_contexts.Get());
+  return g_all_shared_contexts.Get().size();
+}
+
 class GLInProcessContextImpl
     : public GLInProcessContext,
       public gles2::ImageFactory,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   explicit GLInProcessContextImpl(bool share_resources);
   virtual ~GLInProcessContextImpl();
 
   bool Initialize(bool is_offscreen,
                   gfx::AcceleratedWidget window,
@@ skipping 70 matching lines @@
                 contexts_.end(),
                 &DetachThread);
 }
 
 scoped_ptr<GpuMemoryBuffer> GLInProcessContextImpl::CreateGpuMemoryBuffer(
     int width, int height, GLenum internalformat, unsigned int* image_id) {
   // We're taking the lock here because we're accessing the ContextGroup's
   // shared IdManager.
   AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                       g_all_shared_contexts.Get());
-  // For Android WebView we assume the |internalformat| will always be
-  // GL_RGBA8_OES.
-  DCHECK_EQ(static_cast<GLenum>(GL_RGBA8_OES), internalformat);
-  scoped_ptr<GpuMemoryBuffer> buffer =
-      g_gpu_memory_buffer_creator(width, height);
-
-  if (buffer.get() == NULL)
-    return buffer.Pass();
+  scoped_ptr<GpuMemoryBuffer> buffer(
+      g_gpu_memory_buffer_factory->CreateGpuMemoryBuffer(width,
+                                                         height,
+                                                         internalformat));
+  if (!buffer)
+    return scoped_ptr<GpuMemoryBuffer>();
 
   scoped_refptr<gfx::GLImage> gl_image =
       gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer->GetNativeBuffer(),
                                                     gfx::Size(width, height));
   *image_id = decoder_->GetContextGroup()
       ->GetIdAllocator(gles2::id_namespaces::kImages)->AllocateID();
   GetImageManager()->AddImage(gl_image.get(), *image_id);
   return buffer.Pass();
 }
 
@@ skipping 386 matching lines @@
       allowed_extensions,
       attrib_list,
       gpu_preference,
       callback))
     return NULL;
 
   return context.release();
 }
 
 // static
-void GLInProcessContext::SetGpuMemoryBufferCreator(
-    GpuMemoryBufferCreator* creator) {
-  g_gpu_memory_buffer_creator = creator;
+void GLInProcessContext::SetGpuMemoryBufferFactory(
+    GpuMemoryBufferFactory* factory) {
+  DCHECK_EQ(0u, SharedContextCount());
+  g_gpu_memory_buffer_factory = factory;
 }
 
 // static
 void GLInProcessContext::EnableVirtualizedContext() {
-#if !defined(NDEBUG)
-  {
-    AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
-                                        g_all_shared_contexts.Get());
-    DCHECK(g_all_shared_contexts.Get().empty());
-  }
-#endif  // !defined(NDEBUG)
+  DCHECK_EQ(0u, SharedContextCount());
   g_use_virtualized_gl_context = true;
 }
 
 }  // namespace gpu