ozone: Implement zero/one-copy texture for Ozone GBM.

content/common/gpu/client/gpu_memory_buffer_impl_ozone_native_buffer.cc

 // Copyright 2014 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 "content/common/gpu/client/gpu_memory_buffer_impl_ozone_native_buffer.h"
 
-#include "ui/ozone/public/surface_factory_ozone.h"
+namespace content {
 
-namespace content {
+namespace {
+
+ui::SurfaceFactoryOzone::BufferFormat GetOzoneFormatFor(
+    gfx::GpuMemoryBuffer::Format format) {
+  switch (format) {
+    case gfx::GpuMemoryBuffer::BGRA_8888:
+      return ui::SurfaceFactoryOzone::BGRA_8888;
+    case gfx::GpuMemoryBuffer::RGBX_8888:
+      return ui::SurfaceFactoryOzone::RGBX_8888;
+    case gfx::GpuMemoryBuffer::ATC:
+    case gfx::GpuMemoryBuffer::ATCIA:
+    case gfx::GpuMemoryBuffer::DXT1:
+    case gfx::GpuMemoryBuffer::DXT5:
+    case gfx::GpuMemoryBuffer::ETC1:
+    case gfx::GpuMemoryBuffer::R_8:
+    case gfx::GpuMemoryBuffer::RGBA_4444:
+    case gfx::GpuMemoryBuffer::RGBA_8888:
+    case gfx::GpuMemoryBuffer::YUV_420:
+      NOTREACHED();
+  }
+  NOTREACHED();
+  return ui::SurfaceFactoryOzone::BGRA_8888;
+}
+
+ui::SurfaceFactoryOzone::BufferUsage GetOzoneUsageFor(
+    gfx::GpuMemoryBuffer::Usage usage) {
+  switch (usage) {
+    case gfx::GpuMemoryBuffer::MAP:
+      return ui::SurfaceFactoryOzone::MAP;
+    case gfx::GpuMemoryBuffer::PERSISTENT_MAP:
+      return ui::SurfaceFactoryOzone::PERSISTENT_MAP;
+    case gfx::GpuMemoryBuffer::SCANOUT:
+      return ui::SurfaceFactoryOzone::SCANOUT;
+  }
+  NOTREACHED();
+  return ui::SurfaceFactoryOzone::SCANOUT;
+}
+
+}  // namespace
 
 GpuMemoryBufferImplOzoneNativeBuffer::GpuMemoryBufferImplOzoneNativeBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     Format format,
+    Usage usage,
     const DestructionCallback& callback)
-    : GpuMemoryBufferImpl(id, size, format, callback) {
+    : GpuMemoryBufferImpl(id, size, format, callback), usage_(usage) {
 }
 
 GpuMemoryBufferImplOzoneNativeBuffer::~GpuMemoryBufferImplOzoneNativeBuffer() {
 }
 
 // static
 scoped_ptr<GpuMemoryBufferImpl>
 GpuMemoryBufferImplOzoneNativeBuffer::CreateFromHandle(
+    ui::NativePixmapManager* manager,
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     Format format,
     Usage usage,
     const DestructionCallback& callback) {
-  return make_scoped_ptr<GpuMemoryBufferImpl>(
-      new GpuMemoryBufferImplOzoneNativeBuffer(
-          handle.id, size, format, callback));
+  scoped_ptr<GpuMemoryBufferImplOzoneNativeBuffer> buffer =
+      make_scoped_ptr(new GpuMemoryBufferImplOzoneNativeBuffer(
+          handle.id, size, format, usage, callback));
+
+  if (!buffer->Initialize(manager, handle))
+    return nullptr;
+  return buffer.Pass();
+}
+
+bool GpuMemoryBufferImplOzoneNativeBuffer::Initialize(
+    ui::NativePixmapManager* manager,
+    const gfx::GpuMemoryBufferHandle& handle) {
+  DCHECK(manager);
+  pixmap_ = manager->CreateFromFileDescriptor(handle.handle, size_,
+                                              GetOzoneFormatFor(format_),
+                                              GetOzoneUsageFor(usage_));
+  return !!pixmap_;
 }
 
 bool GpuMemoryBufferImplOzoneNativeBuffer::Map(void** data) {
-  NOTREACHED();
-  return false;
+  DCHECK(!mapped_);
+  DCHECK_EQ(usage_, MAP);
+  mapped_ = true;
+  void* buffer = pixmap_->Map();
+  if (!buffer)
+    return false;
+  *data = buffer;
+  return true;
 }
 
 void GpuMemoryBufferImplOzoneNativeBuffer::Unmap() {
-  NOTREACHED();
+  DCHECK(mapped_);
+  DCHECK_EQ(usage_, MAP);
+  pixmap_->Unmap();
+  mapped_ = false;
 }
 
 void GpuMemoryBufferImplOzoneNativeBuffer::GetStride(int* stride) const {
-  NOTREACHED();
+  *stride = pixmap_->GetDmaBufPitch();
 }
 
 gfx::GpuMemoryBufferHandle GpuMemoryBufferImplOzoneNativeBuffer::GetHandle()
     const {
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::OZONE_NATIVE_BUFFER;
   handle.id = id_;
   return handle;
 }
 
 }  // namespace content