Implementation of GpuMemoryBufferFactoryOzoneNativeBuffer (reland)

Relanding with switch fix.

BUG=405046
TBR=reveman

Review URL: https://codereview.chromium.org/488643003

Cr-Commit-Position: refs/heads/master@{#290907}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@290907 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 97 insertions, 33 deletions

diff --git a/content/common/gpu/gpu_memory_buffer_factory_ozone.cc b/content/common/gpu/gpu_memory_buffer_factory_ozone.cc
index 8f4232d..ca119e8 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_ozone.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_ozone.cc
@@ -22,9 +22,8 @@ class GpuMemoryBufferFactoryImpl : public GpuMemoryBufferFactory {
       unsigned usage) OVERRIDE {
     switch (handle.type) {
       case gfx::OZONE_NATIVE_BUFFER:
-        return ui::GpuMemoryBufferFactoryOzoneNativeBuffer::GetInstance()
-                       ->CreateGpuMemoryBuffer(
-                           handle.global_id, size, internalformat, usage)
+        return ozone_buffer_factory.CreateGpuMemoryBuffer(
+                   handle.global_id, size, internalformat, usage)
                    ? handle
                    : gfx::GpuMemoryBufferHandle();
       default:
@@ -36,8 +35,7 @@ class GpuMemoryBufferFactoryImpl : public GpuMemoryBufferFactory {
       const gfx::GpuMemoryBufferHandle& handle) OVERRIDE {
     switch (handle.type) {
       case gfx::OZONE_NATIVE_BUFFER:
-        ui::GpuMemoryBufferFactoryOzoneNativeBuffer::GetInstance()
-            ->DestroyGpuMemoryBuffer(handle.global_id);
+        ozone_buffer_factory.DestroyGpuMemoryBuffer(handle.global_id);
         break;
       default:
         NOTREACHED();
@@ -63,14 +61,16 @@ class GpuMemoryBufferFactoryImpl : public GpuMemoryBufferFactory {
         if (handle.global_id.secondary_id != client_id)
           return scoped_refptr<gfx::GLImage>();
 
-        return ui::GpuMemoryBufferFactoryOzoneNativeBuffer::GetInstance()
-            ->CreateImageForGpuMemoryBuffer(
-                handle.global_id, size, internalformat);
+        return ozone_buffer_factory.CreateImageForGpuMemoryBuffer(
+            handle.global_id, size, internalformat);
       default:
         NOTREACHED();
         return scoped_refptr<gfx::GLImage>();
     }
   }
+
+ private:
+  ui::GpuMemoryBufferFactoryOzoneNativeBuffer ozone_buffer_factory;
 };
 
 }  // namespace
diff --git a/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.cc b/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.cc
index 00d1ac6..3e293e9 100644
--- a/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.cc
+++ b/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.cc
@@ -5,9 +5,58 @@
 #include "ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
 
 #include "base/logging.h"
-#include "ui/gl/gl_image.h"
+#include "ui/gl/gl_image_egl.h"
+#include "ui/ozone/public/native_pixmap.h"
+#include "ui/ozone/public/surface_factory_ozone.h"
+#include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace ui {
+namespace {
+class GLImageOzoneNativePixmap : public gfx::GLImageEGL {
+ public:
+  explicit GLImageOzoneNativePixmap(const gfx::Size& size) : GLImageEGL(size) {}
+
+  bool Initialize(scoped_refptr<NativePixmap> pixmap) {
+    EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+    if (!Initialize(EGL_NATIVE_PIXMAP_KHR, pixmap->GetEGLClientBuffer(), attrs))
+      return false;
+    pixmap_ = pixmap;
+    return true;
+  }
+
+  virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                    int z_order,
+                                    gfx::OverlayTransform transform,
+                                    const gfx::Rect& bounds_rect,
+                                    const gfx::RectF& crop_rect) OVERRIDE {
+    return SurfaceFactoryOzone::GetInstance()->ScheduleOverlayPlane(
+        widget, z_order, transform, pixmap_, bounds_rect, crop_rect);
+  }
+
+ protected:
+  virtual ~GLImageOzoneNativePixmap() {}
+
+ private:
+  using gfx::GLImageEGL::Initialize;
+  scoped_refptr<NativePixmap> pixmap_;
+};
+
+SurfaceFactoryOzone::BufferFormat GetOzoneFormatFor(unsigned internal_format) {
+  switch (internal_format) {
+    case GL_RGBA8_OES:
+      return SurfaceFactoryOzone::RGBA_8888;
+    case GL_RGB8_OES:
+      return SurfaceFactoryOzone::RGBX_8888;
+    default:
+      NOTREACHED();
+      return SurfaceFactoryOzone::RGBA_8888;
+  }
+}
+
+std::pair<uint32_t, uint32_t> GetIndex(const gfx::GpuMemoryBufferId& id) {
+  return std::pair<uint32_t, uint32_t>(id.primary_id, id.secondary_id);
+}
+}  // namespace
 
 GpuMemoryBufferFactoryOzoneNativeBuffer::
     GpuMemoryBufferFactoryOzoneNativeBuffer() {
@@ -17,24 +66,27 @@ GpuMemoryBufferFactoryOzoneNativeBuffer::
     ~GpuMemoryBufferFactoryOzoneNativeBuffer() {
 }
 
-GpuMemoryBufferFactoryOzoneNativeBuffer*
-GpuMemoryBufferFactoryOzoneNativeBuffer::GetInstance() {
-  NOTREACHED();
-  return NULL;
-}
-
 bool GpuMemoryBufferFactoryOzoneNativeBuffer::CreateGpuMemoryBuffer(
     const gfx::GpuMemoryBufferId& id,
     const gfx::Size& size,
     unsigned internalformat,
     unsigned usage) {
-  NOTIMPLEMENTED();
-  return false;
+  scoped_refptr<NativePixmap> pixmap =
+      SurfaceFactoryOzone::GetInstance()->CreateNativePixmap(
+          size, GetOzoneFormatFor(internalformat));
+  if (!pixmap) {
+    LOG(ERROR) << "Failed to create pixmap " << size.width() << "x"
+               << size.height() << " format " << internalformat << ", usage "
+               << usage;
+    return false;
+  }
+  native_pixmap_map_[GetIndex(id)] = pixmap;
+  return true;
 }
 
 void GpuMemoryBufferFactoryOzoneNativeBuffer::DestroyGpuMemoryBuffer(
     const gfx::GpuMemoryBufferId& id) {
-  NOTIMPLEMENTED();
+  native_pixmap_map_.erase(GetIndex(id));
 }
 
 scoped_refptr<gfx::GLImage>
@@ -42,8 +94,16 @@ GpuMemoryBufferFactoryOzoneNativeBuffer::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferId& id,
     const gfx::Size& size,
     unsigned internalformat) {
-  NOTIMPLEMENTED();
-  return scoped_refptr<gfx::GLImage>();
+  BufferToPixmapMap::iterator it = native_pixmap_map_.find(GetIndex(id));
+  if (it == native_pixmap_map_.end()) {
+    return scoped_refptr<gfx::GLImage>();
+  }
+  scoped_refptr<GLImageOzoneNativePixmap> image =
+      new GLImageOzoneNativePixmap(size);
+  if (!image->Initialize(it->second)) {
+    return scoped_refptr<gfx::GLImage>();
+  }
+  return image;
 }
 
 }  // namespace ui
diff --git a/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h b/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h
index 0db50bc..79584fc 100644
--- a/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h
+++ b/ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h
@@ -5,6 +5,8 @@
 #ifndef UI_OZONE_GPU_GPU_MEMORY_BUFFER_FACTORY_OZONE_NATIVE_BUFFER_H_
 #define UI_OZONE_GPU_GPU_MEMORY_BUFFER_FACTORY_OZONE_NATIVE_BUFFER_H_
 
+#include <map>
+
 #include "base/memory/ref_counted.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
@@ -15,15 +17,16 @@ class GLImage;
 }
 
 namespace ui {
+class NativePixmap;
 
 class OZONE_GPU_EXPORT GpuMemoryBufferFactoryOzoneNativeBuffer {
+  typedef std::map<std::pair<uint32_t, uint32_t>, scoped_refptr<NativePixmap> >
+      BufferToPixmapMap;
+
  public:
   GpuMemoryBufferFactoryOzoneNativeBuffer();
   virtual ~GpuMemoryBufferFactoryOzoneNativeBuffer();
 
-  // Returns the singleton instance.
-  static GpuMemoryBufferFactoryOzoneNativeBuffer* GetInstance();
-
   // Creates a GPU memory buffer identified by |id|.
   bool CreateGpuMemoryBuffer(const gfx::GpuMemoryBufferId& id,
                              const gfx::Size& size,
@@ -38,6 +41,9 @@ class OZONE_GPU_EXPORT GpuMemoryBufferFactoryOzoneNativeBuffer {
       const gfx::GpuMemoryBufferId& id,
       const gfx::Size& size,
       unsigned internalformat);
+
+ private:
+  BufferToPixmapMap native_pixmap_map_;
 };
 
 }  // namespace ui
diff --git a/ui/ozone/platform/dri/gbm_buffer.cc b/ui/ozone/platform/dri/gbm_buffer.cc
index 79e8b3b..398064d 100644
--- a/ui/ozone/platform/dri/gbm_buffer.cc
+++ b/ui/ozone/platform/dri/gbm_buffer.cc
@@ -14,17 +14,14 @@ namespace {
 
 int GetGbmFormatFromBufferFormat(SurfaceFactoryOzone::BufferFormat fmt) {
   switch (fmt) {
-    case SurfaceFactoryOzone::UNKNOWN:
-      return 0;
-    // TODO(alexst): Setting this to XRGB for now to allow presentation
-    // as a primary plane but disallowing overlay transparency. Address this
-    // to allow both use cases.
     case SurfaceFactoryOzone::RGBA_8888:
-      return GBM_FORMAT_XRGB8888;
-    case SurfaceFactoryOzone::RGB_888:
-      return GBM_FORMAT_RGB888;
+      return GBM_BO_FORMAT_ARGB8888;
+    case SurfaceFactoryOzone::RGBX_8888:
+      return GBM_BO_FORMAT_XRGB8888;
+    default:
+      NOTREACHED();
+      return 0;
   }
-  return 0;
 }
 
 }  // namespace
diff --git a/ui/ozone/platform/dri/ozone_platform_gbm.cc b/ui/ozone/platform/dri/ozone_platform_gbm.cc
index 6106cb7..0bd7cbb 100644
--- a/ui/ozone/platform/dri/ozone_platform_gbm.cc
+++ b/ui/ozone/platform/dri/ozone_platform_gbm.cc
@@ -75,7 +75,7 @@ class GbmBufferGenerator : public ScanoutBufferGenerator {
 class OzonePlatformGbm : public OzonePlatform {
  public:
   OzonePlatformGbm(bool use_surfaceless) : use_surfaceless_(use_surfaceless) {
-     base::AtExitManager::RegisterTask(
+    base::AtExitManager::RegisterTask(
         base::Bind(&base::DeletePointer<OzonePlatformGbm>, this));
   }
   virtual ~OzonePlatformGbm() {}
diff --git a/ui/ozone/public/surface_factory_ozone.h b/ui/ozone/public/surface_factory_ozone.h
index cc7a5f4..62df13e 100644
--- a/ui/ozone/public/surface_factory_ozone.h
+++ b/ui/ozone/public/surface_factory_ozone.h
@@ -64,6 +64,7 @@ class OZONE_BASE_EXPORT SurfaceFactoryOzone {
   enum BufferFormat {
     UNKNOWN,
     RGBA_8888,
+    RGBX_8888,
     RGB_888,
   };