test_gpu_memory_buffer_manager.cc 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
  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. #include "components/viz/test/test_gpu_memory_buffer_manager.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <utility>
  8. #include "base/check_op.h"
  9. #include "base/memory/raw_ptr.h"
  10. #include "base/numerics/safe_conversions.h"
  11. #include "ui/gfx/buffer_format_util.h"
  12. #include "ui/gfx/gpu_memory_buffer.h"
  13. namespace viz {
  14. namespace {
  15. class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  16. public:
  17. GpuMemoryBufferImpl(TestGpuMemoryBufferManager* manager,
  18. int id,
  19. const gfx::Size& size,
  20. gfx::BufferFormat format,
  21. base::UnsafeSharedMemoryRegion shared_memory_region,
  22. size_t offset,
  23. size_t stride)
  24. : manager_(manager),
  25. id_(id),
  26. size_(size),
  27. format_(format),
  28. region_(std::move(shared_memory_region)),
  29. offset_(offset),
  30. stride_(stride),
  31. mapped_(false) {}
  32. ~GpuMemoryBufferImpl() override { manager_->OnGpuMemoryBufferDestroyed(id_); }
  33. // Overridden from gfx::GpuMemoryBuffer:
  34. bool Map() override {
  35. DCHECK(!mapped_);
  36. DCHECK_EQ(stride_, gfx::RowSizeForBufferFormat(size_.width(), format_, 0));
  37. mapping_ = region_.MapAt(
  38. 0, offset_ + gfx::BufferSizeForBufferFormat(size_, format_));
  39. if (!mapping_.IsValid())
  40. return false;
  41. mapped_ = true;
  42. return true;
  43. }
  44. void* memory(size_t plane) override {
  45. DCHECK(mapped_);
  46. DCHECK_LT(plane, gfx::NumberOfPlanesForLinearBufferFormat(format_));
  47. return reinterpret_cast<uint8_t*>(mapping_.memory()) + offset_ +
  48. gfx::BufferOffsetForBufferFormat(size_, format_, plane);
  49. }
  50. void Unmap() override {
  51. DCHECK(mapped_);
  52. mapping_ = base::WritableSharedMemoryMapping();
  53. mapped_ = false;
  54. }
  55. gfx::Size GetSize() const override { return size_; }
  56. gfx::BufferFormat GetFormat() const override { return format_; }
  57. int stride(size_t plane) const override {
  58. DCHECK_LT(plane, gfx::NumberOfPlanesForLinearBufferFormat(format_));
  59. return base::checked_cast<int>(gfx::RowSizeForBufferFormat(
  60. size_.width(), format_, static_cast<int>(plane)));
  61. }
  62. gfx::GpuMemoryBufferType GetType() const override {
  63. return gfx::SHARED_MEMORY_BUFFER;
  64. }
  65. gfx::GpuMemoryBufferId GetId() const override { return id_; }
  66. gfx::GpuMemoryBufferHandle CloneHandle() const override {
  67. gfx::GpuMemoryBufferHandle handle;
  68. handle.type = gfx::SHARED_MEMORY_BUFFER;
  69. handle.region = region_.Duplicate();
  70. handle.offset = base::checked_cast<uint32_t>(offset_);
  71. handle.stride = base::checked_cast<uint32_t>(stride_);
  72. return handle;
  73. }
  74. void OnMemoryDump(
  75. base::trace_event::ProcessMemoryDump* pmd,
  76. const base::trace_event::MemoryAllocatorDumpGuid& buffer_dump_guid,
  77. uint64_t tracing_process_id,
  78. int importance) const override {}
  79. private:
  80. raw_ptr<TestGpuMemoryBufferManager> manager_;
  81. gfx::GpuMemoryBufferId id_;
  82. const gfx::Size size_;
  83. gfx::BufferFormat format_;
  84. base::UnsafeSharedMemoryRegion region_;
  85. base::WritableSharedMemoryMapping mapping_;
  86. size_t offset_;
  87. size_t stride_;
  88. bool mapped_;
  89. };
  90. class GpuMemoryBufferFromClient : public gfx::GpuMemoryBuffer {
  91. public:
  92. GpuMemoryBufferFromClient(TestGpuMemoryBufferManager* manager,
  93. int id,
  94. gfx::GpuMemoryBuffer* client_buffer)
  95. : manager_(manager), id_(id), client_buffer_(client_buffer) {}
  96. ~GpuMemoryBufferFromClient() override {
  97. manager_->OnGpuMemoryBufferDestroyed(id_);
  98. }
  99. bool Map() override { return client_buffer_->Map(); }
  100. void* memory(size_t plane) override { return client_buffer_->memory(plane); }
  101. void Unmap() override { client_buffer_->Unmap(); }
  102. gfx::Size GetSize() const override { return client_buffer_->GetSize(); }
  103. gfx::BufferFormat GetFormat() const override {
  104. return client_buffer_->GetFormat();
  105. }
  106. int stride(size_t plane) const override {
  107. return client_buffer_->stride(plane);
  108. }
  109. gfx::GpuMemoryBufferId GetId() const override { return id_; }
  110. gfx::GpuMemoryBufferType GetType() const override {
  111. return client_buffer_->GetType();
  112. }
  113. gfx::GpuMemoryBufferHandle CloneHandle() const override {
  114. return client_buffer_->CloneHandle();
  115. }
  116. void OnMemoryDump(
  117. base::trace_event::ProcessMemoryDump* pmd,
  118. const base::trace_event::MemoryAllocatorDumpGuid& buffer_dump_guid,
  119. uint64_t tracing_process_id,
  120. int importance) const override {}
  121. private:
  122. raw_ptr<TestGpuMemoryBufferManager> manager_;
  123. gfx::GpuMemoryBufferId id_;
  124. raw_ptr<gfx::GpuMemoryBuffer> client_buffer_;
  125. };
  126. } // namespace
  127. TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {}
  128. TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
  129. base::AutoLock hold(lock_);
  130. DCHECK(buffers_.empty());
  131. DCHECK(clients_.empty());
  132. if (parent_gpu_memory_buffer_manager_)
  133. parent_gpu_memory_buffer_manager_->clients_.erase(client_id_);
  134. }
  135. std::unique_ptr<TestGpuMemoryBufferManager>
  136. TestGpuMemoryBufferManager::CreateClientGpuMemoryBufferManager() {
  137. base::AutoLock hold(lock_);
  138. std::unique_ptr<TestGpuMemoryBufferManager> client(
  139. new TestGpuMemoryBufferManager);
  140. client->client_id_ = ++last_client_id_;
  141. client->parent_gpu_memory_buffer_manager_ = this;
  142. clients_[client->client_id_] = client.get();
  143. return client;
  144. }
  145. void TestGpuMemoryBufferManager::OnGpuMemoryBufferDestroyed(
  146. gfx::GpuMemoryBufferId gpu_memory_buffer_id) {
  147. base::AutoLock hold(lock_);
  148. DCHECK(buffers_.find(gpu_memory_buffer_id.id) != buffers_.end());
  149. buffers_.erase(gpu_memory_buffer_id.id);
  150. }
  151. std::unique_ptr<gfx::GpuMemoryBuffer>
  152. TestGpuMemoryBufferManager::CreateGpuMemoryBuffer(
  153. const gfx::Size& size,
  154. gfx::BufferFormat format,
  155. gfx::BufferUsage usage,
  156. gpu::SurfaceHandle surface_handle,
  157. base::WaitableEvent* shutdown_event) {
  158. base::AutoLock hold(lock_);
  159. if (fail_on_create_)
  160. return nullptr;
  161. const size_t buffer_size = gfx::BufferSizeForBufferFormat(size, format);
  162. base::UnsafeSharedMemoryRegion shared_memory_region =
  163. base::UnsafeSharedMemoryRegion::Create(buffer_size);
  164. if (!shared_memory_region.IsValid())
  165. return nullptr;
  166. last_gpu_memory_buffer_id_ += 1;
  167. std::unique_ptr<gfx::GpuMemoryBuffer> result(new GpuMemoryBufferImpl(
  168. this, last_gpu_memory_buffer_id_, size, format,
  169. std::move(shared_memory_region), 0,
  170. base::checked_cast<int>(
  171. gfx::RowSizeForBufferFormat(size.width(), format, 0))));
  172. buffers_[last_gpu_memory_buffer_id_] = result.get();
  173. return result;
  174. }
  175. void TestGpuMemoryBufferManager::SetDestructionSyncToken(
  176. gfx::GpuMemoryBuffer* buffer,
  177. const gpu::SyncToken& sync_token) {}
  178. void TestGpuMemoryBufferManager::CopyGpuMemoryBufferAsync(
  179. gfx::GpuMemoryBufferHandle buffer_handle,
  180. base::UnsafeSharedMemoryRegion memory_region,
  181. base::OnceCallback<void(bool)> callback) {
  182. std::move(callback).Run(false);
  183. }
  184. bool TestGpuMemoryBufferManager::CopyGpuMemoryBufferSync(
  185. gfx::GpuMemoryBufferHandle buffer_handle,
  186. base::UnsafeSharedMemoryRegion memory_region) {
  187. return false;
  188. }
  189. } // namespace viz