Implement OSMesa image transport for TOUCH_UI builds

content/common/gpu/image_transport_surface_linux.cc

 // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface_linux.h"
 
 // This conflicts with the defines in Xlib.h and must come first.
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 32 matching lines @@
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual void OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
   virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation
-  virtual void OnSetSurfaceACK(uint64 surface_id) OVERRIDE;
+  virtual void OnNewSurfaceACK(
+      uint64 surface_id, TransportDIB::Handle surface_handle) OVERRIDE;
   virtual void OnBuffersSwappedACK() OVERRIDE;
   virtual void OnResize(gfx::Size size) OVERRIDE;
 
  private:
   virtual ~EGLImageTransportSurface() OVERRIDE;
   void ReleaseSurface(scoped_refptr<AcceleratedSurface>* surface);
 
   uint32 fbo_id_;
 
   scoped_refptr<AcceleratedSurface> back_surface_;
   scoped_refptr<AcceleratedSurface> front_surface_;
 
   scoped_ptr<ImageTransportHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(EGLImageTransportSurface);
 };
 
-// We are backed by an Pbuffer offscreen surface for the purposes of creating a
-// context, but use FBOs to render to X Pixmap backed EGLImages.
+// We render to an off-screen (but mapped) window that the browser process will
+// read from via XComposite
 class GLXImageTransportSurface : public ImageTransportSurface,
                                  public gfx::NativeViewGLSurfaceGLX {
  public:
   GLXImageTransportSurface(GpuChannelManager* manager,
                            int32 render_view_id,
                            int32 renderer_id,
                            int32 command_buffer_id);
 
   // gfx::GLSurface implementation:
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual void OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation:
-  void OnSetSurfaceACK(uint64 surface_id) OVERRIDE;
-  void OnBuffersSwappedACK() OVERRIDE;
-  void OnResize(gfx::Size size) OVERRIDE;
+  virtual void OnNewSurfaceACK(
+      uint64 surface_id, TransportDIB::Handle surface_handle) OVERRIDE;
+  virtual void OnBuffersSwappedACK() OVERRIDE;
+  virtual void OnResize(gfx::Size size) OVERRIDE;
 
  private:
   virtual ~GLXImageTransportSurface();
 
   // Tell the browser to release the surface.
   void ReleaseSurface();
 
   XID dummy_parent_;
   gfx::Size size_;
 
   // Whether or not the image has been bound on the browser side.
   bool bound_;
 
   // Whether or not we've set the swap interval on the associated context.
   bool swap_interval_set_;
 
   scoped_ptr<ImageTransportHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(GLXImageTransportSurface);
 };
 
+// We render to an off-screen (but mapped) window, then dump its contents
+// into a shared memory buffer to get the memory to the browser compositor.
+// This is to replicate the behaviour of OSMesa, without using OSMesa for now.
+class GLXShmImageTransportSurface : public ImageTransportSurface,
+                                    public gfx::PbufferGLSurfaceGLX {
+ public:
+  GLXShmImageTransportSurface(GpuChannelManager* manager,
+                           int32 render_view_id,
+                           int32 renderer_id,
+                           int32 command_buffer_id);
+
+  // gfx::GLSurface implementation:
+  virtual bool Initialize() OVERRIDE;
+  virtual void Destroy() OVERRIDE;
+  virtual bool IsOffscreen() OVERRIDE;
+  virtual bool SwapBuffers() OVERRIDE;
+  virtual gfx::Size GetSize() OVERRIDE;
+  virtual void OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
+  virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
+
+ protected:
+  // ImageTransportSurface implementation:
+  virtual void OnNewSurfaceACK(
+      uint64 surface_id, TransportDIB::Handle surface_handle) OVERRIDE;
+  virtual void OnBuffersSwappedACK() OVERRIDE;
+  virtual void OnResize(gfx::Size size) OVERRIDE;
+
+ private:
+  virtual ~GLXShmImageTransportSurface();
+
+  // Tell the browser to release the surface.
+  void ReleaseSurface();
+
+  uint32 fbo_id_;
+  uint32 texture_;
+
+  gfx::Size size_;
+
+  scoped_ptr<TransportDIB> shared_mem_;
+  uint32 shared_id_;
+
+  scoped_ptr<ImageTransportHelper> helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(GLXShmImageTransportSurface);
+};
+
 EGLImageTransportSurface::EGLImageTransportSurface(
     GpuChannelManager* manager,
     int32 render_view_id,
     int32 renderer_id,
     int32 command_buffer_id)
       : gfx::PbufferGLSurfaceEGL(false, gfx::Size(1, 1)),
         fbo_id_(0) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          render_view_id,
@@ skipping 14 matching lines @@
 void EGLImageTransportSurface::Destroy() {
   if (back_surface_.get())
     ReleaseSurface(&back_surface_);
   if (front_surface_.get())
     ReleaseSurface(&front_surface_);
 
   helper_->Destroy();
   PbufferGLSurfaceEGL::Destroy();
 }
 
+// Make sure that buffer swaps occur for the surface, so we can send the data
+// to the actual onscreen surface in the browser
 bool EGLImageTransportSurface::IsOffscreen() {
   return false;
 }
 
 void EGLImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (fbo_id_)
     return;
 
   glGenFramebuffersEXT(1, &fbo_id_);
   glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_id_);
@@ skipping 24 matching lines @@
     ReleaseSurface(&back_surface_);
 
   back_surface_ = new AcceleratedSurface(size);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
                             GL_COLOR_ATTACHMENT0,
                             GL_TEXTURE_2D,
                             back_surface_->texture(),
                             0);
   glFlush();
 
-  GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params;
+  GpuHostMsg_AcceleratedSurfaceNew_Params params;
   params.width = size.width();
   params.height = size.height();
   params.identifier = back_surface_->pixmap();
-  helper_->SendAcceleratedSurfaceSetIOSurface(params);
+  helper_->SendAcceleratedSurfaceNew(params);
 
   helper_->SetScheduled(false);
 }
 
 bool EGLImageTransportSurface::SwapBuffers() {
   front_surface_.swap(back_surface_);
   DCHECK_NE(front_surface_.get(), static_cast<AcceleratedSurface*>(NULL));
   glFlush();
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
@@ skipping 11 matching lines @@
                               0);
   }
   helper_->SetScheduled(false);
   return true;
 }
 
 gfx::Size EGLImageTransportSurface::GetSize() {
   return back_surface_->size();
 }
 
-void EGLImageTransportSurface::OnSetSurfaceACK(
-    uint64 surface_id) {
+void EGLImageTransportSurface::OnNewSurfaceACK(
+    uint64 surface_id, TransportDIB::Handle /*surface_handle*/) {
   DCHECK_EQ(back_surface_->pixmap(), surface_id);
   helper_->SetScheduled(true);
 }
 
 void EGLImageTransportSurface::OnBuffersSwappedACK() {
   helper_->SetScheduled(true);
 }
 
 GLXImageTransportSurface::GLXImageTransportSurface(
     GpuChannelManager* manager,
@@ skipping 84 matching lines @@
   size_ = size;
   if (bound_) {
     ReleaseSurface();
     bound_ = false;
   }
 
   Display* dpy = gfx::GLSurfaceGLX::GetDisplay();
   XResizeWindow(dpy, window_, size_.width(), size_.height());
   XFlush(dpy);
 
-  GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params;
+  GpuHostMsg_AcceleratedSurfaceNew_Params params;
   params.width = size_.width();
   params.height = size_.height();
   params.identifier = window_;
-  helper_->SendAcceleratedSurfaceSetIOSurface(params);
+  helper_->SendAcceleratedSurfaceNew(params);
 
   helper_->SetScheduled(false);
 }
 
 bool GLXImageTransportSurface::SwapBuffers() {
   gfx::NativeViewGLSurfaceGLX::SwapBuffers();
   glFlush();
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_id = window_;
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
   helper_->SetScheduled(false);
   return true;
 }
 
 gfx::Size GLXImageTransportSurface::GetSize() {
   return size_;
 }
 
 void GLXImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (!swap_interval_set_) {
     context->SetSwapInterval(0);
     swap_interval_set_ = true;
   }
 }
 
-void GLXImageTransportSurface::OnSetSurfaceACK(
-    uint64 surface_id) {
+void GLXImageTransportSurface::OnNewSurfaceACK(
+    uint64 surface_id, TransportDIB::Handle /*surface_handle*/) {
   DCHECK(!bound_);
   bound_ = true;
   helper_->SetScheduled(true);
 }
 
 void GLXImageTransportSurface::OnBuffersSwappedACK() {
   helper_->SetScheduled(true);
 }
 
+GLXShmImageTransportSurface::GLXShmImageTransportSurface(
+    GpuChannelManager* manager,
+    int32 render_view_id,
+    int32 renderer_id,
+    int32 command_buffer_id)
+      : gfx::PbufferGLSurfaceGLX(gfx::Size(1,1)),
+        size_(0, 0) {
+  helper_.reset(new ImageTransportHelper(this,
+                                         manager,
+                                         render_view_id,
+                                         renderer_id,
+                                         command_buffer_id));
+}
+
+GLXShmImageTransportSurface::~GLXShmImageTransportSurface() {
+  Destroy();
+}
+
+bool GLXShmImageTransportSurface::Initialize() {
+  if (!helper_->Initialize())
+    return false;
+  return gfx::PbufferGLSurfaceGLX::Initialize();
+}
+
+void GLXShmImageTransportSurface::Destroy() {
+  if (shared_mem_.get())
+    ReleaseSurface();
+
+  helper_->Destroy();
+  gfx::PbufferGLSurfaceGLX::Destroy();
+}
+
+// Make sure that buffer swaps occur for the surface, so we can send the data
+// to the actual onscreen surface in the browser
+bool GLXShmImageTransportSurface::IsOffscreen() {
+  return false;
+}
+
+void GLXShmImageTransportSurface::ReleaseSurface() {
+  GpuHostMsg_AcceleratedSurfaceRelease_Params params;
+  params.identifier = shared_id_;
+  helper_->SendAcceleratedSurfaceRelease(params);
+
+  shared_mem_.reset();
+  shared_id_ = 0;
+}
+
+void GLXShmImageTransportSurface::OnResize(gfx::Size size) {
+  LOG(ERROR) << "OnResize *********** " << size;
+  size_ = size;
+
+  if (shared_mem_.get())
+    ReleaseSurface();
+
+  // resize the texture
+  LOG(ERROR) << std::hex << "4 GLError: " << glGetError();
+  glBindTexture(GL_TEXTURE_2D, texture_);
+  LOG(ERROR) << std::hex << "5 GLError: " << glGetError();
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
+               size_.width(), size_.height(), 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  LOG(ERROR) << std::hex << "6 GLError: " << glGetError();
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id_);
+  LOG(ERROR) << std::hex << "6.1 GLError: " << glGetError();
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
+                            GL_COLOR_ATTACHMENT0,
+                            GL_TEXTURE_2D,
+                            texture_,
+                            0);
+  LOG(ERROR) << std::hex << "7 GLError: " << glGetError();
+  glBindTexture(GL_TEXTURE_2D, 0);
+  glFlush();
+  LOG(ERROR) << std::hex << "7.1 GLError: " << glGetError();
+
+  GpuHostMsg_AcceleratedSurfaceNew_Params params;
+  params.width = size_.width();
+  params.height = size_.height();
+  params.identifier = 0; // id comes from the browser with the shared mem
+  helper_->SendAcceleratedSurfaceNew(params);
+
+  helper_->SetScheduled(false);
+}
+
+void GLXShmImageTransportSurface::OnNewSurfaceACK(
+    uint64 surface_id, TransportDIB::Handle surface_handle) {
+  shared_id_ = surface_id;
+  shared_mem_.reset(TransportDIB::Map(surface_handle));
+  DCHECK_NE(shared_mem_.get(), static_cast<void*>(NULL));
+
+  helper_->SetScheduled(true);
+}
+
+bool GLXShmImageTransportSurface::SwapBuffers() {
+  DCHECK_NE(shared_mem_.get(), static_cast<void*>(NULL));
+
+  // grab the pixel data from the texture into the shared memory, and send
+  // it over to the browser
+  LOG(ERROR) << std::hex << "1 GLError: " << glGetError();
+  glBindTexture(GL_TEXTURE_2D, texture_);
+  LOG(ERROR) << std::hex << "2 GLError: " << glGetError();
+  LOG(ERROR) << "glReadPixels ***************";
+  glReadPixels(0, 0, size_.width(), size_.height(),
+               GL_RGBA, GL_UNSIGNED_BYTE, shared_mem_->memory());
+  LOG(ERROR) << std::hex << "3 GLError: " << glGetError();
+  glBindTexture(GL_TEXTURE_2D, 0);
+  glFlush();
+  LOG(ERROR) << std::hex << "3.1 GLError: " << glGetError();
+
+  GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
+  params.surface_id = shared_id_;
+  helper_->SendAcceleratedSurfaceBuffersSwapped(params);
+
+  helper_->SetScheduled(false);
+  return true;
+}
+
+gfx::Size GLXShmImageTransportSurface::GetSize() {
+  return size_;
+}
+
+unsigned int GLXShmImageTransportSurface::GetBackingFrameBufferObject() {
+  return fbo_id_;
+}
+
+void GLXShmImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
+  if (fbo_id_)
+    return;
+
+  LOG(ERROR) << std::hex << "8 GLError: " << glGetError();
+  glGenTextures(1, &texture_);
+  glBindTexture(GL_TEXTURE_2D, texture_);

[jonathan.backer, 2011/09/20 15:16:29]

I think you can get rid of a bit of code duplication by calling OnResize(): It
has to glTexImage2D the texture size and rebind to the FBO
(glFramebufferTexture2DEXT) anyway.

+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  glBindTexture(GL_TEXTURE_2D, 0);
+  LOG(ERROR) << std::hex << "9 GLError: " << glGetError();
+
+  glGenFramebuffersEXT(1, &fbo_id_);
+  LOG(ERROR) << std::hex << "10 GLError: " << glGetError();
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo_id_);
+  LOG(ERROR) << std::hex << "11 GLError: " << glGetError();
+
+  GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+  if (status != GL_FRAMEBUFFER_COMPLETE) {
+    LOG(ERROR) << "Framebuffer incomplete";
+  }
+  LOG(ERROR) << std::hex << "12 GLError: " << glGetError();
+}
+
+void GLXShmImageTransportSurface::OnBuffersSwappedACK() {
+  helper_->SetScheduled(true);
+}
+
 }  // namespace
 
 // static
 scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateSurface(
     GpuChannelManager* manager,
     int32 render_view_id,
     int32 renderer_id,
     int32 command_buffer_id) {
   scoped_refptr<gfx::GLSurface> surface;
   switch (gfx::GetGLImplementation()) {
     case gfx::kGLImplementationDesktopGL:
-      surface = new GLXImageTransportSurface(manager,
+      surface = new GLXShmImageTransportSurface(manager,
                                              render_view_id,
                                              renderer_id,
                                              command_buffer_id);
       break;
     case gfx::kGLImplementationEGLGLES2:
       surface = new EGLImageTransportSurface(manager,
                                              render_view_id,
                                              renderer_id,
                                              command_buffer_id);
       break;
@@ skipping 35 matching lines @@
 
   return true;
 }
 
 void ImageTransportHelper::Destroy() {
 }
 
 bool ImageTransportHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ImageTransportHelper, message)
-    IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_SetSurfaceACK,
-                        OnSetSurfaceACK)
+    IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_NewACK,
+                        OnNewSurfaceACK)
     IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_BuffersSwappedACK,
                         OnBuffersSwappedACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ImageTransportHelper::SendAcceleratedSurfaceRelease(
     GpuHostMsg_AcceleratedSurfaceRelease_Params params) {
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.route_id = route_id_;
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceRelease(params));
 }
 
-void ImageTransportHelper::SendAcceleratedSurfaceSetIOSurface(
-    GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params) {
+void ImageTransportHelper::SendAcceleratedSurfaceNew(
+    GpuHostMsg_AcceleratedSurfaceNew_Params params) {
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.route_id = route_id_;
-  manager_->Send(new GpuHostMsg_AcceleratedSurfaceSetIOSurface(params));
+  manager_->Send(new GpuHostMsg_AcceleratedSurfaceNew(params));
 }
 
 void ImageTransportHelper::SendAcceleratedSurfaceBuffersSwapped(
     GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params) {
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.route_id = route_id_;
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
 }
 
 void ImageTransportHelper::SetScheduled(bool is_scheduled) {
   gpu::GpuScheduler* scheduler = Scheduler();
   if (!scheduler)
     return;
 
   scheduler->SetScheduled(is_scheduled);
 }
 
-void ImageTransportHelper::OnSetSurfaceACK(uint64 surface_id) {
-  surface_->OnSetSurfaceACK(surface_id);
+void ImageTransportHelper::OnNewSurfaceACK(
+    uint64 surface_id, TransportDIB::Handle surface_handle) {
+  surface_->OnNewSurfaceACK(surface_id, surface_handle);
 }
 
 void ImageTransportHelper::OnBuffersSwappedACK() {
   surface_->OnBuffersSwappedACK();
 }
 
 void ImageTransportHelper::Resize(gfx::Size size) {
   surface_->OnResize(size);
 }
 
@@ skipping 17 matching lines @@
 
   GpuCommandBufferStub* stub =
       channel->LookupCommandBuffer(command_buffer_id_);
   if (!stub)
     return NULL;
 
   return stub->decoder();
 }
 
 #endif  // defined(USE_GPU)