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