src/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
   6
   7 #include "base/bind.h"
   8 #include "base/numerics/safe_math.h"
   9 #include "ui/gl/gl_bindings.h"
  10
  11 namespace content {
  12 namespace {
  13
  14 void Noop() {
  15 }
  16
  17 }  // namespace
  18
  19 GpuMemoryBufferImplSharedMemory::GpuMemoryBufferImplSharedMemory(
  20     const gfx::Size& size,
  21     unsigned internalformat,
  22     const DestructionCallback& callback,
  23     scoped_ptr<base::SharedMemory> shared_memory)
  24     : GpuMemoryBufferImpl(size, internalformat, callback),
  25       shared_memory_(shared_memory.Pass()) {
  26 }
  27
  28 GpuMemoryBufferImplSharedMemory::~GpuMemoryBufferImplSharedMemory() {
  29 }
  30
  31 // static
  32 void GpuMemoryBufferImplSharedMemory::Create(const gfx::Size& size,
  33                                              unsigned internalformat,
  34                                              unsigned usage,
  35                                              const CreationCallback& callback) {
  36   DCHECK(GpuMemoryBufferImplSharedMemory::IsConfigurationSupported(
  37       size, internalformat, usage));
  38
  39   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
  40   if (!shared_memory->CreateAnonymous(size.GetArea() *
  41                                       BytesPerPixel(internalformat))) {
  42     callback.Run(scoped_ptr<GpuMemoryBufferImpl>());
  43     return;
  44   }
  45
  46   callback.Run(
  47       make_scoped_ptr<GpuMemoryBufferImpl>(new GpuMemoryBufferImplSharedMemory(
  48           size, internalformat, base::Bind(&Noop), shared_memory.Pass())));
  49 }
  50
  51 // static
  52 void GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
  53     const gfx::Size& size,
  54     unsigned internalformat,
  55     base::ProcessHandle child_process,
  56     const AllocationCallback& callback) {
  57   DCHECK(IsLayoutSupported(size, internalformat));
  58   base::SharedMemory shared_memory;
  59   if (!shared_memory.CreateAnonymous(size.GetArea() *
  60                                      BytesPerPixel(internalformat))) {
  61     callback.Run(gfx::GpuMemoryBufferHandle());
  62     return;
  63   }
  64   gfx::GpuMemoryBufferHandle handle;
  65   handle.type = gfx::SHARED_MEMORY_BUFFER;
  66   shared_memory.GiveToProcess(child_process, &handle.handle);
  67   callback.Run(handle);
  68 }
  69
  70 // static
  71 scoped_ptr<GpuMemoryBufferImpl>
  72 GpuMemoryBufferImplSharedMemory::CreateFromHandle(
  73     const gfx::GpuMemoryBufferHandle& handle,
  74     const gfx::Size& size,
  75     unsigned internalformat,
  76     const DestructionCallback& callback) {
  77   DCHECK(IsLayoutSupported(size, internalformat));
  78
  79   if (!base::SharedMemory::IsHandleValid(handle.handle))
  80     return scoped_ptr<GpuMemoryBufferImpl>();
  81
  82   return make_scoped_ptr<GpuMemoryBufferImpl>(
  83       new GpuMemoryBufferImplSharedMemory(
  84           size,
  85           internalformat,
  86           callback,
  87           make_scoped_ptr(new base::SharedMemory(handle.handle, false))));
  88 }
  89
  90 // static
  91 bool GpuMemoryBufferImplSharedMemory::IsLayoutSupported(
  92     const gfx::Size& size,
  93     unsigned internalformat) {
  94   base::CheckedNumeric<int> buffer_size = size.width();
  95   buffer_size *= size.height();
  96   buffer_size *= BytesPerPixel(internalformat);
  97   return buffer_size.IsValid();
  98 }
  99
 100 // static
 101 bool GpuMemoryBufferImplSharedMemory::IsUsageSupported(unsigned usage) {
 102   switch (usage) {
 103     case GL_IMAGE_MAP_CHROMIUM:
 104       return true;
 105     default:
 106       return false;
 107   }
 108 }
 109
 110 // static
 111 bool GpuMemoryBufferImplSharedMemory::IsConfigurationSupported(
 112     const gfx::Size& size,
 113     unsigned internalformat,
 114     unsigned usage) {
 115   return IsLayoutSupported(size, internalformat) && IsUsageSupported(usage);
 116 }
 117
 118 void* GpuMemoryBufferImplSharedMemory::Map() {
 119   DCHECK(!mapped_);
 120   if (!shared_memory_->Map(size_.GetArea() * BytesPerPixel(internalformat_)))
 121     return NULL;
 122   mapped_ = true;
 123   return shared_memory_->memory();
 124 }
 125
 126 void GpuMemoryBufferImplSharedMemory::Unmap() {
 127   DCHECK(mapped_);
 128   shared_memory_->Unmap();
 129   mapped_ = false;
 130 }
 131
 132 uint32 GpuMemoryBufferImplSharedMemory::GetStride() const {
 133   return size_.width() * BytesPerPixel(internalformat_);
 134 }
 135
 136 gfx::GpuMemoryBufferHandle GpuMemoryBufferImplSharedMemory::GetHandle() const {
 137   gfx::GpuMemoryBufferHandle handle;
 138   handle.type = gfx::SHARED_MEMORY_BUFFER;
 139   handle.handle = shared_memory_->handle();
 140   return handle;
 141 }
 142
 143 }  // namespace content