Implement OSMesa image transport for TOUCH_UI builds

chrome/browser/renderer_host/accelerated_surface_container_touch.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.
 
 #include "chrome/browser/renderer_host/accelerated_surface_container_touch.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_egl.h"
 #include "ui/gfx/gl/gl_surface_glx.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace {
 
 class AcceleratedSurfaceContainerTouchEGL
     : public AcceleratedSurfaceContainerTouch {
  public:
   AcceleratedSurfaceContainerTouchEGL(const gfx::Size& size,
-                                      uint64 surface_handle);
+                                      uint64 surface_id);
   // TextureGL implementation
   virtual void Draw(const ui::TextureDrawParams& params,
                     const gfx::Rect& clip_bounds_in_texture) OVERRIDE;
 
  private:
   ~AcceleratedSurfaceContainerTouchEGL();
 
   void* image_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceContainerTouchEGL);
 };
 
 class AcceleratedSurfaceContainerTouchGLX
     : public AcceleratedSurfaceContainerTouch {
  public:
   AcceleratedSurfaceContainerTouchGLX(const gfx::Size& size,
-                                      uint64 surface_handle);
+                                      uint64 surface_id);
   // TextureGL implementation
   virtual void Draw(const ui::TextureDrawParams& params,
                     const gfx::Rect& clip_bounds_in_texture) OVERRIDE;
 
  private:
   ~AcceleratedSurfaceContainerTouchGLX();
 
   XID pixmap_;
   XID glx_pixmap_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceContainerTouchGLX);
 };
 
+class AcceleratedSurfaceContainerTouchGLXShm
+    : public AcceleratedSurfaceContainerTouch {
+ public:
+  AcceleratedSurfaceContainerTouchGLXShm(const gfx::Size& size,
+                                      uint64 surface_handle);
+  // TextureGL implementation
+  virtual void Draw(const ui::TextureDrawParams& params,
+                    const gfx::Rect& clip_bounds_in_texture) OVERRIDE;
+
+  virtual uint64 id() const OVERRIDE;
+
+  // Some implementations of this class use shared memory, this the handle
+  // to the shared buffer, which is part of the surface container.
+  virtual TransportDIB::Handle handle() const OVERRIDE;
+
+ private:
+  ~AcceleratedSurfaceContainerTouchGLXShm();
+
+  uint64 id_;
+  scoped_ptr<TransportDIB> shared_mem_;
+
+  DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceContainerTouchGLXShm);
+};
+
 class ScopedPtrXFree {
  public:
   void operator()(void* x) const {
     ::XFree(x);
   }
 };
 
 AcceleratedSurfaceContainerTouchEGL::AcceleratedSurfaceContainerTouchEGL(
     const gfx::Size& size,
-    uint64 surface_handle)
-    : AcceleratedSurfaceContainerTouch(size),
+    uint64 surface_id)
+    : AcceleratedSurfaceContainerTouch(size, surface_id),
       image_(NULL) {
   ui::SharedResources* instance = ui::SharedResources::GetInstance();
   DCHECK(instance);
   instance->MakeSharedContextCurrent();
 
   image_ = eglCreateImageKHR(
       gfx::GLSurfaceEGL::GetHardwareDisplay(), EGL_NO_CONTEXT,
-      EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(surface_handle), NULL);
+      EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(surface_id), NULL);
 
   glGenTextures(1, &texture_id_);
   glBindTexture(GL_TEXTURE_2D, texture_id_);
   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);
   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image_);
   glFlush();
 }
@@ skipping 23 matching lines @@
 
   modified_params.transform = flipped;
 
   DrawInternal(*instance->program_no_swizzle(),
                modified_params,
                clip_bounds_in_texture);
 }
 
 AcceleratedSurfaceContainerTouchGLX::AcceleratedSurfaceContainerTouchGLX(
     const gfx::Size& size,
-    uint64 surface_handle)
-    : AcceleratedSurfaceContainerTouch(size),
+    uint64 surface_id)
+    : AcceleratedSurfaceContainerTouch(size, surface_id),
       pixmap_(0),
       glx_pixmap_(0) {
   ui::SharedResources* instance = ui::SharedResources::GetInstance();
   DCHECK(instance);
   instance->MakeSharedContextCurrent();
 
   // Create pixmap from window.
+  // We receive a window here rather than a pixmap directly because drivers
+  // require (or required) that the pixmap used to create the GL texture be
+  // created in the same process as the texture.
   Display* dpy = gfx::GLSurfaceGLX::GetDisplay();
   int event_base, error_base;
   if (XCompositeQueryExtension(dpy, &event_base, &error_base)) {
     int major = 0, minor = 2;
     XCompositeQueryVersion(dpy, &major, &minor);
     if (major == 0 && minor < 2) {
       LOG(ERROR) << "Pixmap from window not supported.";
       return;
     }
   }
-  pixmap_ = XCompositeNameWindowPixmap(dpy, surface_handle);
+  pixmap_ = XCompositeNameWindowPixmap(dpy, surface_id);
 
   // Wrap the pixmap in a GLXPixmap
   int screen = DefaultScreen(dpy);
   XWindowAttributes gwa;
   XGetWindowAttributes(dpy, RootWindow(dpy, screen), &gwa);
   unsigned int visualid = XVisualIDFromVisual(gwa.visual);
 
   int nfbconfigs, config;
   scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> fbconfigs(
       glXGetFBConfigs(dpy, screen, &nfbconfigs));
@@ skipping 75 matching lines @@
   Display* dpy = gfx::GLSurfaceGLX::GetDisplay();
 
   glBindTexture(GL_TEXTURE_2D, texture_id_);
   glXBindTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
   DrawInternal(*instance->program_no_swizzle(),
                params,
                clip_bounds_in_texture);
   glXReleaseTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT);
 }
 
+AcceleratedSurfaceContainerTouchGLXShm::AcceleratedSurfaceContainerTouchGLXShm(
+    const gfx::Size& size,
+    uint64 surface_id)
+      : AcceleratedSurfaceContainerTouch(size, surface_id),
+        id_(0),
+        shared_mem_(0) {
+  static uint32 next_id = 1;
+
+  ui::SharedResources* instance = ui::SharedResources::GetInstance();
+  DCHECK(instance);
+  instance->MakeSharedContextCurrent();
+
+  // We expect to make the id here, so don't want the other end giving us one
+  DCHECK_EQ(surface_id, static_cast<uint64>(0));
+
+  // It's possible that this ID gneration could clash with IDs from other
+  // AcceleratedSurfaceContainerTouch* objects, however we should never have
+  // ids active from more than one type at the same time, so we have free
+  // reign of the id namespace.
+  shared_mem_.reset(
+      TransportDIB::Create(size.width() * size.height() * 4,  // GL_RGBA=4 B/px
+                           next_id));
+  id_ = next_id++;
+
+  // Create texture.
+  glGenTextures(1, &texture_id_);
+  glBindTexture(GL_TEXTURE_2D, texture_id_);
+  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);
+}
+
+AcceleratedSurfaceContainerTouchGLXShm::
+    ~AcceleratedSurfaceContainerTouchGLXShm() {
+}
+
+uint64 AcceleratedSurfaceContainerTouchGLXShm::id() const {
+  return id_;
+}
+
+
+TransportDIB::Handle AcceleratedSurfaceContainerTouchGLXShm::handle() const {
+  if (shared_mem_.get())
+    return shared_mem_->handle();
+  else
+    return TransportDIB::DefaultHandleValue();
+}
+
+
+void AcceleratedSurfaceContainerTouchGLXShm::Draw(
+    const ui::TextureDrawParams& params,
+    const gfx::Rect& clip_bounds_in_texture) {
+  ui::SharedResources* instance = ui::SharedResources::GetInstance();
+  DCHECK(instance);
+
+  if (shared_mem_.get()) {
+    glBindTexture(GL_TEXTURE_2D, texture_id_);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
+                 size_.width(), size_.height(), 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, shared_mem_->memory());
+
+    ui::TextureDrawParams modified_params = params;
+
+    // Texture from GPU is flipped vertically.
+    ui::Transform flipped;
+    flipped.SetScaleY(-1.0);
+    flipped.SetTranslateY(size_.height());
+    flipped.ConcatTransform(params.transform);
+
+    modified_params.transform = flipped;
+
+    DrawInternal(*instance->program_no_swizzle(),
+                 modified_params,
+                 clip_bounds_in_texture);
+  }
+}
+
 }  // namespace
 
 AcceleratedSurfaceContainerTouch::AcceleratedSurfaceContainerTouch(
-    const gfx::Size& size) : TextureGL(size) {
+    const gfx::Size& size,
+    uint64 surface_id) : TextureGL(size) {
+  id_ = surface_id;
+}
+
+uint64 AcceleratedSurfaceContainerTouch::id() const {
+  return id_;
+}
+
+TransportDIB::Handle AcceleratedSurfaceContainerTouch::handle() const {
+  return TransportDIB::DefaultHandleValue();
 }
 
 // static
 AcceleratedSurfaceContainerTouch*
 AcceleratedSurfaceContainerTouch::CreateAcceleratedSurfaceContainer(
     const gfx::Size& size,
-    uint64 surface_handle) {
+    uint64 surface_id) {
   switch (gfx::GetGLImplementation()) {
     case gfx::kGLImplementationDesktopGL:
-      return new AcceleratedSurfaceContainerTouchGLX(size,
-                                                     surface_handle);
+      return new AcceleratedSurfaceContainerTouchGLXShm(size,
+                                                        surface_id);
     case gfx::kGLImplementationEGLGLES2:
       return new AcceleratedSurfaceContainerTouchEGL(size,
-                                                     surface_handle);
+                                                     surface_id);
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 void AcceleratedSurfaceContainerTouch::SetCanvas(
     const SkCanvas& canvas,
     const gfx::Point& origin,
     const gfx::Size& overall_size) {
   NOTREACHED();
 }