OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/test/test_gpu_memory_buffer_manager.h" | 5 #include "cc/test/test_gpu_memory_buffer_manager.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "ui/gfx/gpu_memory_buffer.h" | 8 #include "ui/gfx/gpu_memory_buffer.h" |
9 | 9 |
10 namespace cc { | 10 namespace cc { |
11 namespace { | 11 namespace { |
12 | 12 |
13 size_t BytesPerPixel(gfx::GpuMemoryBuffer::Format format) { | 13 size_t BitsPerPixel(gfx::GpuMemoryBuffer::Format format) { |
14 switch (format) { | 14 switch (format) { |
15 case gfx::GpuMemoryBuffer::RGBA_8888: | 15 case gfx::GpuMemoryBuffer::RGBA_8888: |
16 case gfx::GpuMemoryBuffer::RGBX_8888: | 16 case gfx::GpuMemoryBuffer::RGBX_8888: |
17 case gfx::GpuMemoryBuffer::BGRA_8888: | 17 case gfx::GpuMemoryBuffer::BGRA_8888: |
18 return 4; | 18 return 32; |
19 } | 19 } |
20 | 20 |
21 NOTREACHED(); | 21 NOTREACHED(); |
22 return 0; | 22 return 0; |
23 } | 23 } |
24 | 24 |
| 25 size_t PixelsToBytes(size_t pixel_count, gfx::GpuMemoryBuffer::Format format) { |
| 26 size_t size_in_bits = pixel_count * BitsPerPixel(format); |
| 27 DCHECK_EQ(size_in_bits % 8, 0u); |
| 28 return size_in_bits / 8; |
| 29 } |
| 30 |
25 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer { | 31 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer { |
26 public: | 32 public: |
27 GpuMemoryBufferImpl(const gfx::Size& size, | 33 GpuMemoryBufferImpl(const gfx::Size& size, |
28 Format format, | 34 Format format, |
29 scoped_ptr<base::SharedMemory> shared_memory) | 35 scoped_ptr<base::SharedMemory> shared_memory) |
30 : size_(size), | 36 : size_(size), |
31 format_(format), | 37 format_(format), |
32 shared_memory_(shared_memory.Pass()), | 38 shared_memory_(shared_memory.Pass()), |
33 mapped_(false) {} | 39 mapped_(false) {} |
34 | 40 |
35 // Overridden from gfx::GpuMemoryBuffer: | 41 // Overridden from gfx::GpuMemoryBuffer: |
36 void* Map() override { | 42 void* Map() override { |
37 DCHECK(!mapped_); | 43 DCHECK(!mapped_); |
38 if (!shared_memory_->Map(size_.GetArea() * BytesPerPixel(format_))) | 44 if (!shared_memory_->Map(PixelsToBytes(size_.GetArea(), format_))) |
39 return NULL; | 45 return NULL; |
40 mapped_ = true; | 46 mapped_ = true; |
41 return shared_memory_->memory(); | 47 return shared_memory_->memory(); |
42 } | 48 } |
43 void Unmap() override { | 49 void Unmap() override { |
44 DCHECK(mapped_); | 50 DCHECK(mapped_); |
45 shared_memory_->Unmap(); | 51 shared_memory_->Unmap(); |
46 mapped_ = false; | 52 mapped_ = false; |
47 } | 53 } |
48 bool IsMapped() const override { return mapped_; } | 54 bool IsMapped() const override { return mapped_; } |
49 Format GetFormat() const override { return format_; } | 55 Format GetFormat() const override { return format_; } |
50 uint32 GetStride() const override { | 56 uint32 GetStride() const override { |
51 return size_.width() * BytesPerPixel(format_); | 57 return PixelsToBytes(size_.width(), format_); |
52 } | 58 } |
53 gfx::GpuMemoryBufferHandle GetHandle() const override { | 59 gfx::GpuMemoryBufferHandle GetHandle() const override { |
54 gfx::GpuMemoryBufferHandle handle; | 60 gfx::GpuMemoryBufferHandle handle; |
55 handle.type = gfx::SHARED_MEMORY_BUFFER; | 61 handle.type = gfx::SHARED_MEMORY_BUFFER; |
56 handle.handle = shared_memory_->handle(); | 62 handle.handle = shared_memory_->handle(); |
57 return handle; | 63 return handle; |
58 } | 64 } |
59 ClientBuffer AsClientBuffer() override { | 65 ClientBuffer AsClientBuffer() override { |
60 return reinterpret_cast<ClientBuffer>(this); | 66 return reinterpret_cast<ClientBuffer>(this); |
61 } | 67 } |
(...skipping 12 matching lines...) Expand all Loading... |
74 | 80 |
75 TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() { | 81 TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() { |
76 } | 82 } |
77 | 83 |
78 scoped_ptr<gfx::GpuMemoryBuffer> | 84 scoped_ptr<gfx::GpuMemoryBuffer> |
79 TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer( | 85 TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer( |
80 const gfx::Size& size, | 86 const gfx::Size& size, |
81 gfx::GpuMemoryBuffer::Format format, | 87 gfx::GpuMemoryBuffer::Format format, |
82 gfx::GpuMemoryBuffer::Usage usage) { | 88 gfx::GpuMemoryBuffer::Usage usage) { |
83 scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory); | 89 scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory); |
84 if (!shared_memory->CreateAnonymous(size.GetArea() * BytesPerPixel(format))) | 90 if (!shared_memory->CreateAnonymous(PixelsToBytes(size.GetArea(), format))) |
85 return nullptr; | 91 return nullptr; |
86 return make_scoped_ptr<gfx::GpuMemoryBuffer>( | 92 return make_scoped_ptr<gfx::GpuMemoryBuffer>( |
87 new GpuMemoryBufferImpl(size, format, shared_memory.Pass())); | 93 new GpuMemoryBufferImpl(size, format, shared_memory.Pass())); |
88 } | 94 } |
89 | 95 |
90 gfx::GpuMemoryBuffer* | 96 gfx::GpuMemoryBuffer* |
91 TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer( | 97 TestGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer( |
92 ClientBuffer buffer) { | 98 ClientBuffer buffer) { |
93 return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer); | 99 return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer); |
94 } | 100 } |
95 | 101 |
96 void TestGpuMemoryBufferManager::SetDestructionSyncPoint( | 102 void TestGpuMemoryBufferManager::SetDestructionSyncPoint( |
97 gfx::GpuMemoryBuffer* buffer, | 103 gfx::GpuMemoryBuffer* buffer, |
98 uint32 sync_point) { | 104 uint32 sync_point) { |
99 } | 105 } |
100 | 106 |
101 } // namespace cc | 107 } // namespace cc |
OLD | NEW |