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   void* Map() override {
  45     DCHECK(!mapped_);
  46     if (!shared_memory_->Map(StrideInBytes(size_.width(), format_) *
  47                              size_.height()))
  48       return NULL;
  49     mapped_ = true;
  50     return shared_memory_->memory();
  51   }
  52   void Unmap() override {
  53     DCHECK(mapped_);
  54     shared_memory_->Unmap();
  55     mapped_ = false;
  56   }
  57   bool IsMapped() const override { return mapped_; }
  58   Format GetFormat() const override { return format_; }
  59   uint32 GetStride() const override {
  60     return StrideInBytes(size_.width(), format_);
  61   }
  62   gfx::GpuMemoryBufferHandle GetHandle() const override {
  63     gfx::GpuMemoryBufferHandle handle;
  64     handle.type = gfx::SHARED_MEMORY_BUFFER;
  65     handle.handle = shared_memory_->handle();
  66     return handle;
  67   }
  68   ClientBuffer AsClientBuffer() override {
  69     return reinterpret_cast<ClientBuffer>(this);
  70   }
  71
  72  private:
  73   const gfx::Size size_;
  74   gfx::GpuMemoryBuffer::Format format_;
  75   scoped_ptr<base::SharedMemory> shared_memory_;
  76   bool mapped_;
  77 };
  78
  79 }  // namespace
  80
  81 TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {
  82 }
  83
  84 TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
  85 }
  86
  87 scoped_ptr<gfx::GpuMemoryBuffer>
  88 TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
  89     const gfx::Size& size,
  90     gfx::GpuMemoryBuffer::Format format,
  91     gfx::GpuMemoryBuffer::Usage usage) {
  92   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
  93   if (!shared_memory->CreateAnonymous(StrideInBytes(size.width(), format) *
  94                                       size.height()))
  95     return nullptr;
  96   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
  97       new GpuMemoryBufferImpl(size, format, shared_memory.Pass()));
  98 }
  99
 100 gfx::GpuMemoryBuffer*
 101 TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
 102     ClientBuffer buffer) {
 103   return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer);
 104 }
 105
 106 void TestGpuMemoryBufferManager::SetDestructionSyncPoint(
 107     gfx::GpuMemoryBuffer* buffer,
 108     uint32 sync_point) {
 109 }
 110
 111 }  // namespace cc