cc/test/test_gpu_memory_buffer_manager.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 "cc/test/test_gpu_memory_buffer_manager.h"
   6
   7 #include "base/logging.h"
   8 #include "ui/gfx/gpu_memory_buffer.h"
   9
  10 namespace cc {
  11 namespace {
  12
  13 size_t StrideInBytes(size_t width, gfx::GpuMemoryBuffer::Format format) {
  14   switch (format) {
  15     case gfx::GpuMemoryBuffer::RGBA_8888:
  16     case gfx::GpuMemoryBuffer::RGBX_8888:
  17     case gfx::GpuMemoryBuffer::BGRA_8888:
  18       return width * 4;
  19   }
  20
  21   NOTREACHED();
  22   return 0;
  23 }
  24
  25 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  26  public:
  27   GpuMemoryBufferImpl(const gfx::Size& size,
  28                       Format format,
  29                       scoped_ptr<base::SharedMemory> shared_memory)
  30       : size_(size),
  31         format_(format),
  32         shared_memory_(shared_memory.Pass()),
  33         mapped_(false) {}
  34
  35   // Overridden from gfx::GpuMemoryBuffer:
  36   void* Map() override {
  37     DCHECK(!mapped_);
  38     if (!shared_memory_->Map(StrideInBytes(size_.width(), format_) *
  39                              size_.height()))
  40       return NULL;
  41     mapped_ = true;
  42     return shared_memory_->memory();
  43   }
  44   void Unmap() override {
  45     DCHECK(mapped_);
  46     shared_memory_->Unmap();
  47     mapped_ = false;
  48   }
  49   bool IsMapped() const override { return mapped_; }
  50   Format GetFormat() const override { return format_; }
  51   uint32 GetStride() const override {
  52     return StrideInBytes(size_.width(), format_);
  53   }
  54   gfx::GpuMemoryBufferHandle GetHandle() const override {
  55     gfx::GpuMemoryBufferHandle handle;
  56     handle.type = gfx::SHARED_MEMORY_BUFFER;
  57     handle.handle = shared_memory_->handle();
  58     return handle;
  59   }
  60   ClientBuffer AsClientBuffer() override {
  61     return reinterpret_cast<ClientBuffer>(this);
  62   }
  63
  64  private:
  65   const gfx::Size size_;
  66   gfx::GpuMemoryBuffer::Format format_;
  67   scoped_ptr<base::SharedMemory> shared_memory_;
  68   bool mapped_;
  69 };
  70
  71 }  // namespace
  72
  73 TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {
  74 }
  75
  76 TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
  77 }
  78
  79 scoped_ptr<gfx::GpuMemoryBuffer>
  80 TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
  81     const gfx::Size& size,
  82     gfx::GpuMemoryBuffer::Format format,
  83     gfx::GpuMemoryBuffer::Usage usage) {
  84   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
  85   if (!shared_memory->CreateAnonymous(StrideInBytes(size.width(), format) *
  86                                       size.height()))
  87     return nullptr;
  88   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
  89       new GpuMemoryBufferImpl(size, format, shared_memory.Pass()));
  90 }
  91
  92 gfx::GpuMemoryBuffer*
  93 TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
  94     ClientBuffer buffer) {
  95   return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer);
  96 }
  97
  98 void TestGpuMemoryBufferManager::SetDestructionSyncPoint(
  99     gfx::GpuMemoryBuffer* buffer,
 100     uint32 sync_point) {
 101 }
 102
 103 }  // namespace cc