Add FBO support in Android WebView

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 35 matching lines @@
 static GpuMemoryBufferFactory* g_gpu_memory_buffer_factory = NULL;
 
 class GLInProcessContextImpl
     : public GLInProcessContext,
       public gles2::ImageFactory,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   explicit GLInProcessContextImpl();
   virtual ~GLInProcessContextImpl();
 
-  bool Initialize(bool is_offscreen,
+  bool Initialize(scoped_refptr<gfx::GLSurface> surface,
+                  bool is_offscreen,
                   bool share_resources,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
-                  gfx::GpuPreference gpu_preference,
-                  const base::Closure& context_lost_callback);
+                  gfx::GpuPreference gpu_preference);
 
   // GLInProcessContext implementation:
+  virtual void SetContextLostCallback(const base::Closure& callback) OVERRIDE;
   virtual void SignalSyncPoint(unsigned sync_point,
                                const base::Closure& callback) OVERRIDE;
   virtual void SignalQuery(unsigned query, const base::Closure& callback)
       OVERRIDE;
   virtual gles2::GLES2Implementation* GetImplementation() OVERRIDE;
 
   // ImageFactory implementation:
   virtual scoped_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
       int width, int height, GLenum internalformat,
       unsigned* image_id) OVERRIDE;
   virtual void DeleteGpuMemoryBuffer(unsigned image_id) OVERRIDE;
 
  private:
   void Destroy();
   void PollQueryCallbacks();
   void CallQueryCallback(size_t index);
-  void OnContextLost(const base::Closure& callback);
+  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_;
 
   typedef std::pair<unsigned, base::Closure> QueryCallback;
   std::vector<QueryCallback> query_callbacks_;
 
   unsigned int share_group_id_;
   bool context_lost_;
+  base::Closure context_lost_callback_;
 
   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;
 
 size_t SharedContextCount() {
@@ skipping 35 matching lines @@
   DCHECK(!callback.is_null());
   base::Closure wrapped_callback = base::Bind(
       &GLInProcessContextImpl::OnSignalSyncPoint, AsWeakPtr(), callback);
   command_buffer_->SignalSyncPoint(sync_point, wrapped_callback);
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
-void GLInProcessContextImpl::OnContextLost(const base::Closure& callback) {
+void GLInProcessContextImpl::SetContextLostCallback(
+    const base::Closure& callback) {
+  context_lost_callback_ = callback;
+}
+
+void GLInProcessContextImpl::OnContextLost() {
   context_lost_ = true;
-  callback.Run();
+  if (!context_lost_callback_.is_null()) {
+    context_lost_callback_.Run();
+  }
 }
 
 void GLInProcessContextImpl::OnSignalSyncPoint(const base::Closure& callback) {
   // TODO: Should it always trigger callbacks?
   if (!context_lost_)
     callback.Run();
 }
 
 bool GLInProcessContextImpl::Initialize(
+    scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     bool share_resources,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const int32* attrib_list,
-    gfx::GpuPreference gpu_preference,
-    const base::Closure& context_lost_callback) {
+    gfx::GpuPreference gpu_preference) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   std::vector<int32> attribs;
   while (attrib_list) {
     int32 attrib = *attrib_list++;
     switch (attrib) {
       // Known attributes
       case ALPHA_SIZE:
       case BLUE_SIZE:
       case GREEN_SIZE:
@@ skipping 10 matching lines @@
         attrib_list = NULL;
         break;
       default:
         attribs.push_back(NONE);
         attrib_list = NULL;
         break;
     }
   }
 
   base::Closure wrapped_callback =
-      base::Bind(&GLInProcessContextImpl::OnContextLost,
-                 AsWeakPtr(),
-                 context_lost_callback);
+      base::Bind(&GLInProcessContextImpl::OnContextLost, AsWeakPtr());
   command_buffer_.reset(new InProcessCommandBuffer());
 
   scoped_ptr<base::AutoLock> scoped_shared_context_lock;
   scoped_refptr<gles2::ShareGroup> share_group;
   if (share_resources) {
     scoped_shared_context_lock.reset(
         new base::AutoLock(g_all_shared_contexts_lock.Get()));
     for (std::set<GLInProcessContextImpl*>::const_iterator it =
              g_all_shared_contexts.Get().begin();
          it != g_all_shared_contexts.Get().end();
          it++) {
       const GLInProcessContextImpl* context = *it;
       if (!context->context_lost_) {
         share_group = context->gles2_implementation_->share_group();
         DCHECK(share_group);
         share_group_id_ = context->share_group_id_;
         break;
       }
       share_group_id_ = std::max(share_group_id_, context->share_group_id_);
     }
     if (!share_group && !++share_group_id_)
         ++share_group_id_;
   }
-  if (!command_buffer_->Initialize(is_offscreen,
-                              share_resources,
-                              window,
-                              size,
-                              allowed_extensions,
-                              attribs,
-                              gpu_preference,
-                              wrapped_callback,
-                              share_group_id_)) {
+  if (!command_buffer_->Initialize(surface,
+                                   is_offscreen,
+                                   share_resources,
+                                   window,
+                                   size,
+                                   allowed_extensions,
+                                   attribs,
+                                   gpu_preference,
+                                   wrapped_callback,
+                                   share_group_id_)) {
     LOG(INFO) << "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(kCommandBufferSize)) {
     LOG(INFO) << "Failed to initialize GLES2CmdHelper";
     Destroy();
     return false;
@@ skipping 93 matching lines @@
 }  // anonymous namespace
 
 // static
 GLInProcessContext* GLInProcessContext::CreateContext(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     bool share_resources,
     const char* allowed_extensions,
     const int32* attrib_list,
-    gfx::GpuPreference gpu_preference,
-    const base::Closure& callback) {
+    gfx::GpuPreference gpu_preference) {
   scoped_ptr<GLInProcessContextImpl> context(
       new GLInProcessContextImpl());
   if (!context->Initialize(
+      NULL /* surface */,
       is_offscreen,
       share_resources,
       window,
       size,
       allowed_extensions,
       attrib_list,
-      gpu_preference,
-      callback))
+      gpu_preference))
     return NULL;
 
   return context.release();
+}
+
+// static
+GLInProcessContext* GLInProcessContext::CreateWithSurface(
+    scoped_refptr<gfx::GLSurface> surface,
+    bool is_offscreen,
+    const gfx::Size& size,
+    bool share_resources,
+    const char* allowed_extensions,
+    const int32* attrib_list,
+    gfx::GpuPreference gpu_preference) {
+  scoped_ptr<GLInProcessContextImpl> context(
+      new GLInProcessContextImpl());
+  if (!context->Initialize(
+      surface,
+      is_offscreen,
+      share_resources,
+      NULL /* window */,
+      size,
+      allowed_extensions,
+      attrib_list,
+      gpu_preference))
+    return NULL;
+
+  return context.release();
 }
 
 // static
 void GLInProcessContext::SetGpuMemoryBufferFactory(
     GpuMemoryBufferFactory* factory) {
   DCHECK_EQ(0u, SharedContextCount());
   g_gpu_memory_buffer_factory = factory;
 }
 
 }  // namespace gpu