Mandoline: Merge Surfaces and Views apps

components/view_manager/gles2/gpu_memory_buffer_impl.cc

 // Copyright 2015 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 "components/view_manager/gles2/mojo_gpu_memory_buffer.h"
+#include "components/view_manager/gles2/gpu_memory_buffer_impl.h"
 
-#include "base/logging.h"
-#include "base/memory/shared_memory.h"
-#include "base/numerics/safe_conversions.h"
-
-namespace gles2 {
+#include "ui/gfx/gpu_memory_buffer.h"
 
 namespace {
 
-int NumberOfPlanesForGpuMemoryBufferFormat(gfx::BufferFormat format) {
+size_t NumberOfPlanesForGpuMemoryBufferFormat(
+    gfx::BufferFormat format) {
   switch (format) {
     case gfx::BufferFormat::ATC:
     case gfx::BufferFormat::ATCIA:
     case gfx::BufferFormat::DXT1:
     case gfx::BufferFormat::DXT5:
     case gfx::BufferFormat::ETC1:
     case gfx::BufferFormat::R_8:
     case gfx::BufferFormat::RGBA_4444:
     case gfx::BufferFormat::RGBA_8888:
     case gfx::BufferFormat::RGBX_8888:
@@ skipping 32 matching lines @@
 size_t StrideInBytes(size_t width, gfx::BufferFormat format, int plane) {
   switch (format) {
     case gfx::BufferFormat::ATCIA:
     case gfx::BufferFormat::DXT5:
       DCHECK_EQ(plane, 0);
       return width;
     case gfx::BufferFormat::ATC:
     case gfx::BufferFormat::DXT1:
     case gfx::BufferFormat::ETC1:
       DCHECK_EQ(plane, 0);
-      DCHECK_EQ(width % 2, 0u);
+      DCHECK_EQ(width % 2, 0U);
       return width / 2;
     case gfx::BufferFormat::R_8:
       return (width + 3) & ~0x3;
     case gfx::BufferFormat::RGBA_4444:
       DCHECK_EQ(plane, 0);
       return width * 2;
     case gfx::BufferFormat::RGBA_8888:
-    case gfx::BufferFormat::RGBX_8888:
     case gfx::BufferFormat::BGRA_8888:
       DCHECK_EQ(plane, 0);
       return width * 4;
+    case gfx::BufferFormat::RGBX_8888:
+      NOTREACHED();
+      return 0;
     case gfx::BufferFormat::YUV_420:
       return width / SubsamplingFactor(format, plane);
   }
+
   NOTREACHED();
   return 0;
 }
 
-size_t BufferSizeInBytes(const gfx::Size& size, gfx::BufferFormat format) {
+size_t GetBufferSizeInBytes(const gfx::Size& size, gfx::BufferFormat format) {
   size_t size_in_bytes = 0;
-  int num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format);
-  for (int i = 0; i < num_planes; ++i) {
+  size_t num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format);
+  for (size_t i = 0; i < num_planes; ++i) {
     size_in_bytes += StrideInBytes(size.width(), format, i) *
                      (size.height() / SubsamplingFactor(format, i));
   }
   return size_in_bytes;
 }
 
 }  // namespace
 
-MojoGpuMemoryBufferImpl::MojoGpuMemoryBufferImpl(
+namespace gles2 {
+
+scoped_ptr<gfx::GpuMemoryBuffer> GpuMemoryBufferImpl::Create(
     const gfx::Size& size,
-    gfx::BufferFormat format,
-    scoped_ptr<base::SharedMemory> shared_memory)
-    : size_(size),
-      format_(format),
-      shared_memory_(shared_memory.Pass()),
-      mapped_(false) {}
-
-MojoGpuMemoryBufferImpl::~MojoGpuMemoryBufferImpl() {
+    gfx::BufferFormat format) {
+  std::vector<unsigned char> data(GetBufferSizeInBytes(size, format), 0);
+  scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
+  return make_scoped_ptr<GpuMemoryBufferImpl>(
+      new GpuMemoryBufferImpl(bytes.get(), size, format));
 }
 
-scoped_ptr<gfx::GpuMemoryBuffer> MojoGpuMemoryBufferImpl::Create(
-    const gfx::Size& size,
-    gfx::BufferFormat format,
-    gfx::BufferUsage usage) {
-  size_t bytes = BufferSizeInBytes(size, format);
-  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  if (!shared_memory->CreateAnonymous(bytes))
-    return nullptr;
-  return make_scoped_ptr<gfx::GpuMemoryBuffer>(
-      new MojoGpuMemoryBufferImpl(size, format, shared_memory.Pass()));
+GpuMemoryBufferImpl::GpuMemoryBufferImpl(base::RefCountedBytes* bytes,
+                                         const gfx::Size& size,
+                                         gfx::BufferFormat format)
+    : bytes_(bytes),
+      size_(size),
+      format_(format),
+      mapped_(false) {
 }
 
-MojoGpuMemoryBufferImpl* MojoGpuMemoryBufferImpl::FromClientBuffer(
-    ClientBuffer buffer) {
-  return reinterpret_cast<MojoGpuMemoryBufferImpl*>(buffer);
+GpuMemoryBufferImpl::~GpuMemoryBufferImpl() {
 }
 
-bool MojoGpuMemoryBufferImpl::Map(void** data) {
-  DCHECK(!mapped_);
-  if (!shared_memory_->Map(BufferSizeInBytes(size_, format_)))
-    return false;
-  mapped_ = true;
+bool GpuMemoryBufferImpl::Map(void** data) {
   size_t offset = 0;
-  int num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format_);
-  for (int i = 0; i < num_planes; ++i) {
-    data[i] = reinterpret_cast<uint8*>(shared_memory_->memory()) + offset;
+  size_t num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format_);
+  for (size_t i = 0; i < num_planes; ++i) {
+    data[i] = reinterpret_cast<uint8*>(&bytes_->data().front()) + offset;
     offset += StrideInBytes(size_.width(), format_, i) *
               (size_.height() / SubsamplingFactor(format_, i));
   }
+  mapped_ = true;
   return true;
 }
 
-void MojoGpuMemoryBufferImpl::Unmap() {
-  DCHECK(mapped_);
-  shared_memory_->Unmap();
+void GpuMemoryBufferImpl::Unmap() {
   mapped_ = false;
 }
 
-bool MojoGpuMemoryBufferImpl::IsMapped() const {
+bool GpuMemoryBufferImpl::IsMapped() const {
   return mapped_;
 }
 
-gfx::BufferFormat MojoGpuMemoryBufferImpl::GetFormat() const {
+gfx::BufferFormat GpuMemoryBufferImpl::GetFormat() const {
   return format_;
 }
 
-void MojoGpuMemoryBufferImpl::GetStride(int* stride) const {
-  int num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format_);
-  for (int i = 0; i < num_planes; ++i)
-    stride[i] =
-        base::checked_cast<int>(StrideInBytes(size_.width(), format_, i));
-}
-
-gfx::GpuMemoryBufferId MojoGpuMemoryBufferImpl::GetId() const {
+gfx::GpuMemoryBufferId GpuMemoryBufferImpl::GetId() const {
   return 0;
 }
 
-gfx::GpuMemoryBufferHandle MojoGpuMemoryBufferImpl::GetHandle() const {
-  gfx::GpuMemoryBufferHandle handle;
-  handle.type = gfx::SHARED_MEMORY_BUFFER;
-  handle.handle = shared_memory_->handle();
-  return handle;
+void GpuMemoryBufferImpl::GetStride(int* stride) const {
+  size_t num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format_);
+  for (size_t i = 0; i < num_planes; ++i)
+    stride[i] = StrideInBytes(size_.width(), format_, i);
 }
 
-ClientBuffer MojoGpuMemoryBufferImpl::AsClientBuffer() {
+gfx::GpuMemoryBufferHandle GpuMemoryBufferImpl::GetHandle() const {
+  NOTREACHED();
+  return gfx::GpuMemoryBufferHandle();
+}
+
+ClientBuffer GpuMemoryBufferImpl::AsClientBuffer() {
   return reinterpret_cast<ClientBuffer>(this);
 }
 
 }  // namespace gles2