Add FBO support in Android WebView

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 <utility>
 
 #include <GLES2/gl2.h>
@@ skipping 14 matching lines @@
 #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"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
-#include "ui/gl/gl_surface.h"
 
 namespace gpu {
 
 namespace {
 
 static base::LazyInstance<std::set<InProcessCommandBuffer*> >
     g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 static bool g_uses_explicit_scheduling = false;
@@ skipping 234 matching lines @@
          (error::IsError(state.error) && context_lost_));
 }
 
 bool InProcessCommandBuffer::GetBufferChanged(int32 transfer_buffer_id) {
   command_buffer_lock_.AssertAcquired();
   command_buffer_->SetGetBuffer(transfer_buffer_id);
   return true;
 }
 
 bool InProcessCommandBuffer::Initialize(
+    scoped_refptr<gfx::GLSurface> surface,

[no sievers, 2013/08/05 20:41:09]

Hmm, this is dangerous. GLSurface is not RefCountedThreadSafe, so we cannot be
modifying the reference on the client thread (even if this is all on the same
thread for WebView, the code will be wrong).

I think we need to expose this is a factory that can be run on the gpu thread.
Maybe similar to SurfaceFactoryOzone, see gl_surface_egl.cc

[boliu, 2013/08/05 20:42:52]

Bah...good point.

     bool is_offscreen,
     bool share_resources,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     unsigned int share_group_id) {
 
   share_resources_ = share_resources;
   context_lost_callback_ = WrapCallback(context_lost_callback);
   share_group_id_ = share_group_id;
+  surface_ = surface;
 
-  base::WaitableEvent completion(true, false);
-  bool result = false;
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this),
                  is_offscreen,
                  window,
                  size,
                  allowed_extensions,
                  attribs,
                  gpu_preference);
+
+  base::WaitableEvent completion(true, false);
+  bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
   completion.Wait();
   return result;
 }
 
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
@@ skipping 49 matching lines @@
                           NULL, NULL, NULL, 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 (is_offscreen)
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size);
-  else
-    surface_ = gfx::GLSurface::CreateViewGLSurface(window);
+  if (!surface_) {
+    if (is_offscreen)
+      surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size);
+    else
+      surface_ = gfx::GLSurface::CreateViewGLSurface(window);
+  }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
   if (g_use_virtualized_gl_context) {
     context_ = share_group->GetSharedContext();
     if (!context_.get()) {
@@ skipping 296 matching lines @@
   g_uses_explicit_scheduling = true;
   g_gpu_queue.Get().SetScheduleCallback(callback);
 }
 
 // static
 void InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread() {
   g_gpu_queue.Get().RunTasks();
 }
 
 }  // namespace gpu