Support impl-side painting in Mandoline.

components/view_manager/gles2/mojo_gpu_memory_buffer.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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 "cc/test/test_gpu_memory_buffer_manager.h"
+#include "components/view_manager/gles2/mojo_gpu_memory_buffer.h"
 
 #include "base/logging.h"
+#include "base/memory/shared_memory.h"
 #include "base/numerics/safe_conversions.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 
-namespace cc {
+namespace gles2 {
+
 namespace {
 
 int NumberOfPlanesForGpuMemoryBufferFormat(
     gfx::GpuMemoryBuffer::Format format) {
   switch (format) {
     case gfx::GpuMemoryBuffer::ATC:
     case gfx::GpuMemoryBuffer::ATCIA:
     case gfx::GpuMemoryBuffer::DXT1:
     case gfx::GpuMemoryBuffer::DXT5:
     case gfx::GpuMemoryBuffer::ETC1:
@@ skipping 68 matching lines @@
                          gfx::GpuMemoryBuffer::Format format) {
   size_t size_in_bytes = 0;
   int num_planes = NumberOfPlanesForGpuMemoryBufferFormat(format);
   for (int i = 0; i < num_planes; ++i) {
     size_in_bytes += StrideInBytes(size.width(), format, i) *
                      (size.height() / SubsamplingFactor(format, i));
   }
   return size_in_bytes;
 }
 
-class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
- public:
-  GpuMemoryBufferImpl(const gfx::Size& size,
-                      Format format,
-                      scoped_ptr<base::SharedMemory> shared_memory)
-      : size_(size),
-        format_(format),
-        shared_memory_(shared_memory.Pass()),
-        mapped_(false) {}
-
-  // Overridden from gfx::GpuMemoryBuffer:
-  bool Map(void** data) override {
-    DCHECK(!mapped_);
-    if (!shared_memory_->Map(BufferSizeInBytes(size_, format_)))
-      return false;
-    mapped_ = true;
-    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;
-      offset += StrideInBytes(size_.width(), format_, i) *
-                (size_.height() / SubsamplingFactor(format_, i));
-    }
-    return true;
-  }
-  void Unmap() override {
-    DCHECK(mapped_);
-    shared_memory_->Unmap();
-    mapped_ = false;
-  }
-  bool IsMapped() const override { return mapped_; }
-  Format GetFormat() const override { return format_; }
-  void GetStride(int* stride) const override {
-    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::GpuMemoryBufferHandle GetHandle() const override {
-    gfx::GpuMemoryBufferHandle handle;
-    handle.type = gfx::SHARED_MEMORY_BUFFER;
-    handle.handle = shared_memory_->handle();
-    return handle;
-  }
-  ClientBuffer AsClientBuffer() override {
-    return reinterpret_cast<ClientBuffer>(this);
-  }
-
- private:
-  const gfx::Size size_;
-  gfx::GpuMemoryBuffer::Format format_;
-  scoped_ptr<base::SharedMemory> shared_memory_;
-  bool mapped_;
-};
-
 }  // namespace
 
-TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {
+MojoGpuMemoryBufferImpl::MojoGpuMemoryBufferImpl(
+    const gfx::Size& size,
+    Format format,
+    scoped_ptr<base::SharedMemory> shared_memory)
+    : size_(size),
+      format_(format),
+      shared_memory_(shared_memory.Pass()),
+      mapped_(false) {
 }
 
-TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
+MojoGpuMemoryBufferImpl::~MojoGpuMemoryBufferImpl() {
 }
 
-scoped_ptr<gfx::GpuMemoryBuffer>
-TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
+scoped_ptr<gfx::GpuMemoryBuffer> MojoGpuMemoryBufferImpl::Create(
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage) {
+    Format format,
+    Usage usage) {
+  size_t bytes = BufferSizeInBytes(size, format);
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  if (!shared_memory->CreateAnonymous(BufferSizeInBytes(size, format)))
+  if (!shared_memory->CreateAnonymous(bytes))
     return nullptr;
   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
-      new GpuMemoryBufferImpl(size, format, shared_memory.Pass()));
+      new MojoGpuMemoryBufferImpl(size, format, shared_memory.Pass()));
 }
 
-gfx::GpuMemoryBuffer*
-TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
+MojoGpuMemoryBufferImpl* MojoGpuMemoryBufferImpl::FromClientBuffer(
     ClientBuffer buffer) {
-  return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer);
+  return reinterpret_cast<MojoGpuMemoryBufferImpl*>(buffer);
 }
 
-void TestGpuMemoryBufferManager::SetDestructionSyncPoint(
-    gfx::GpuMemoryBuffer* buffer,
-    uint32 sync_point) {
+bool MojoGpuMemoryBufferImpl::Map(void** data) {
+  DCHECK(!mapped_);
+  if (!shared_memory_->Map(BufferSizeInBytes(size_, format_)))
+    return false;
+  mapped_ = true;
+  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;
+    offset += StrideInBytes(size_.width(), format_, i) *
+              (size_.height() / SubsamplingFactor(format_, i));
+  }
+  return true;
 }
 
-}  // namespace cc
+void MojoGpuMemoryBufferImpl::Unmap() {
+  DCHECK(mapped_);
+  shared_memory_->Unmap();
+  mapped_ = false;
+}
+
+bool MojoGpuMemoryBufferImpl::IsMapped() const {
+  return mapped_;
+}
+
+gfx::GpuMemoryBuffer::Format MojoGpuMemoryBufferImpl::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::GpuMemoryBufferHandle MojoGpuMemoryBufferImpl::GetHandle() const {
+  gfx::GpuMemoryBufferHandle handle;
+  handle.type = gfx::SHARED_MEMORY_BUFFER;
+  handle.handle = shared_memory_->handle();
+  return handle;
+}
+
+ClientBuffer MojoGpuMemoryBufferImpl::AsClientBuffer() {
+  return reinterpret_cast<ClientBuffer>(this);
+}
+
+}  // namespace gles2