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 "content/browser/gpu/browser_gpu_memory_buffer_manager.h" | 5 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
(...skipping 23 matching lines...) Expand all Loading... |
34 void GpuMemoryBufferDeleted( | 34 void GpuMemoryBufferDeleted( |
35 scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner, | 35 scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner, |
36 const gpu::GpuMemoryBufferImpl::DestructionCallback& destruction_callback, | 36 const gpu::GpuMemoryBufferImpl::DestructionCallback& destruction_callback, |
37 const gpu::SyncToken& sync_token) { | 37 const gpu::SyncToken& sync_token) { |
38 destruction_task_runner->PostTask( | 38 destruction_task_runner->PostTask( |
39 FROM_HERE, base::Bind(destruction_callback, sync_token)); | 39 FROM_HERE, base::Bind(destruction_callback, sync_token)); |
40 } | 40 } |
41 | 41 |
42 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr; | 42 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr; |
43 | 43 |
| 44 void X(scoped_refptr<viz::ServerGpuMemoryBufferManager> manager, |
| 45 std::unique_ptr<gfx::GpuMemoryBuffer>* memory, |
| 46 base::WaitableEvent* wait_event, |
| 47 const gfx::Size& size, |
| 48 gfx::BufferFormat format, |
| 49 gfx::BufferUsage usage, |
| 50 gpu::SurfaceHandle surface_handle, |
| 51 GpuProcessHost* host) { |
| 52 if (!host || !host->gpu_service()) { |
| 53 wait_event->Signal(); |
| 54 return; |
| 55 } |
| 56 manager->set_gpu_service(host->gpu_service()); |
| 57 *memory = manager->CreateGpuMemoryBuffer(size, format, usage, surface_handle); |
| 58 wait_event->Signal(); |
| 59 } |
| 60 |
| 61 void RunCallback( |
| 62 const base::Callback<void(const gfx::GpuMemoryBufferHandle&)>& callback, |
| 63 const gfx::GpuMemoryBufferHandle& handle) { |
| 64 callback.Run(handle); |
| 65 } |
| 66 |
44 } // namespace | 67 } // namespace |
45 | 68 |
46 struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferRequest { | 69 struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferRequest { |
47 CreateGpuMemoryBufferRequest(const gfx::Size& size, | 70 CreateGpuMemoryBufferRequest(const gfx::Size& size, |
48 gfx::BufferFormat format, | 71 gfx::BufferFormat format, |
49 gfx::BufferUsage usage, | 72 gfx::BufferUsage usage, |
50 int client_id, | 73 int client_id, |
51 gpu::SurfaceHandle surface_handle) | 74 gpu::SurfaceHandle surface_handle) |
52 : event(base::WaitableEvent::ResetPolicy::MANUAL, | 75 : event(base::WaitableEvent::ResetPolicy::MANUAL, |
53 base::WaitableEvent::InitialState::NOT_SIGNALED), | 76 base::WaitableEvent::InitialState::NOT_SIGNALED), |
(...skipping 10 matching lines...) Expand all Loading... |
64 int client_id; | 87 int client_id; |
65 gpu::SurfaceHandle surface_handle; | 88 gpu::SurfaceHandle surface_handle; |
66 std::unique_ptr<gfx::GpuMemoryBuffer> result; | 89 std::unique_ptr<gfx::GpuMemoryBuffer> result; |
67 }; | 90 }; |
68 | 91 |
69 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager( | 92 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager( |
70 int gpu_client_id, | 93 int gpu_client_id, |
71 uint64_t gpu_client_tracing_id) | 94 uint64_t gpu_client_tracing_id) |
72 : native_configurations_(gpu::GetNativeGpuMemoryBufferConfigurations()), | 95 : native_configurations_(gpu::GetNativeGpuMemoryBufferConfigurations()), |
73 gpu_client_id_(gpu_client_id), | 96 gpu_client_id_(gpu_client_id), |
74 gpu_client_tracing_id_(gpu_client_tracing_id) { | 97 gpu_client_tracing_id_(gpu_client_tracing_id), |
| 98 gmb_manager_(base::MakeRefCounted<viz::ServerGpuMemoryBufferManager>( |
| 99 nullptr, |
| 100 gpu_client_id_, |
| 101 BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) { |
75 DCHECK(!g_gpu_memory_buffer_manager); | 102 DCHECK(!g_gpu_memory_buffer_manager); |
76 g_gpu_memory_buffer_manager = this; | 103 g_gpu_memory_buffer_manager = this; |
77 } | 104 } |
78 | 105 |
79 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() { | 106 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() { |
80 g_gpu_memory_buffer_manager = nullptr; | 107 g_gpu_memory_buffer_manager = nullptr; |
81 } | 108 } |
82 | 109 |
83 // static | 110 // static |
84 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() { | 111 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() { |
(...skipping 11 matching lines...) Expand all Loading... |
96 | 123 |
97 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess( | 124 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess( |
98 gfx::GpuMemoryBufferId id, | 125 gfx::GpuMemoryBufferId id, |
99 const gfx::Size& size, | 126 const gfx::Size& size, |
100 gfx::BufferFormat format, | 127 gfx::BufferFormat format, |
101 gfx::BufferUsage usage, | 128 gfx::BufferUsage usage, |
102 int child_client_id, | 129 int child_client_id, |
103 const AllocationCallback& callback) { | 130 const AllocationCallback& callback) { |
104 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 131 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
105 | 132 |
| 133 #if 0 |
106 // Use service side allocation for native configurations. | 134 // Use service side allocation for native configurations. |
107 if (IsNativeGpuMemoryBufferConfiguration(format, usage)) { | 135 if (IsNativeGpuMemoryBufferConfiguration(format, usage)) { |
108 CreateGpuMemoryBufferOnIO(id, size, format, usage, gpu::kNullSurfaceHandle, | 136 CreateGpuMemoryBufferOnIO(id, size, format, usage, gpu::kNullSurfaceHandle, |
109 child_client_id, callback); | 137 child_client_id, callback); |
110 return; | 138 return; |
111 } | 139 } |
112 | 140 |
113 // Early out if we cannot fallback to shared memory buffer. | 141 // Early out if we cannot fallback to shared memory buffer. |
114 if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) || | 142 if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) || |
115 !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, | 143 !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, |
(...skipping 11 matching lines...) Expand all Loading... |
127 DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with " | 155 DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with " |
128 "an existing ID."; | 156 "an existing ID."; |
129 callback.Run(gfx::GpuMemoryBufferHandle()); | 157 callback.Run(gfx::GpuMemoryBufferHandle()); |
130 return; | 158 return; |
131 } | 159 } |
132 | 160 |
133 auto handle = gpu::GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer( | 161 auto handle = gpu::GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer( |
134 id, size, format); | 162 id, size, format); |
135 buffers.find(id)->second.shared_memory_guid = handle.handle.GetGUID(); | 163 buffers.find(id)->second.shared_memory_guid = handle.handle.GetGUID(); |
136 callback.Run(handle); | 164 callback.Run(handle); |
| 165 #else |
| 166 GpuProcessHost* host = GpuProcessHost::Get(); |
| 167 gmb_manager_->set_gpu_service(host->gpu_service()); |
| 168 gmb_manager_->AllocateGpuMemoryBufferHandle( |
| 169 id, child_client_id, size, format, usage, gpu::kNullSurfaceHandle, |
| 170 base::BindOnce(&RunCallback, callback)); |
| 171 #endif |
137 } | 172 } |
138 | 173 |
139 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken( | 174 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken( |
140 gfx::GpuMemoryBuffer* buffer, | 175 gfx::GpuMemoryBuffer* buffer, |
141 const gpu::SyncToken& sync_token) { | 176 const gpu::SyncToken& sync_token) { |
| 177 gmb_manager_->SetDestructionSyncToken(buffer, sync_token); |
| 178 #if 0 |
142 static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token( | 179 static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token( |
143 sync_token); | 180 sync_token); |
| 181 #endif |
144 } | 182 } |
145 | 183 |
146 bool BrowserGpuMemoryBufferManager::OnMemoryDump( | 184 bool BrowserGpuMemoryBufferManager::OnMemoryDump( |
147 const base::trace_event::MemoryDumpArgs& args, | 185 const base::trace_event::MemoryDumpArgs& args, |
148 base::trace_event::ProcessMemoryDump* pmd) { | 186 base::trace_event::ProcessMemoryDump* pmd) { |
149 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 187 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
150 | 188 |
151 for (const auto& client : clients_) { | 189 for (const auto& client : clients_) { |
152 int client_id = client.first; | 190 int client_id = client.first; |
153 | 191 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
191 } | 229 } |
192 | 230 |
193 return true; | 231 return true; |
194 } | 232 } |
195 | 233 |
196 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer( | 234 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer( |
197 gfx::GpuMemoryBufferId id, | 235 gfx::GpuMemoryBufferId id, |
198 int child_client_id, | 236 int child_client_id, |
199 const gpu::SyncToken& sync_token) { | 237 const gpu::SyncToken& sync_token) { |
200 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 238 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
201 | 239 #if 0 |
202 DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_token); | 240 DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_token); |
| 241 #else |
| 242 gmb_manager_->DestroyGpuMemoryBuffer(id, child_client_id, sync_token); |
| 243 #endif |
203 } | 244 } |
204 | 245 |
205 void BrowserGpuMemoryBufferManager::ProcessRemoved( | 246 void BrowserGpuMemoryBufferManager::ProcessRemoved( |
206 int client_id) { | 247 int client_id) { |
207 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 248 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
208 | 249 |
| 250 #if 0 |
209 ClientMap::iterator client_it = clients_.find(client_id); | 251 ClientMap::iterator client_it = clients_.find(client_id); |
210 if (client_it == clients_.end()) | 252 if (client_it == clients_.end()) |
211 return; | 253 return; |
212 | 254 |
213 for (const auto& buffer : client_it->second) { | 255 for (const auto& buffer : client_it->second) { |
214 // This might happen if buffer is currenlty in the process of being | 256 // This might happen if buffer is currenlty in the process of being |
215 // allocated. The buffer will in that case be cleaned up when allocation | 257 // allocated. The buffer will in that case be cleaned up when allocation |
216 // completes. | 258 // completes. |
217 if (buffer.second.type == gfx::EMPTY_BUFFER) | 259 if (buffer.second.type == gfx::EMPTY_BUFFER) |
218 continue; | 260 continue; |
219 | 261 |
220 GpuProcessHost* host = GpuProcessHost::FromID(buffer.second.gpu_host_id); | 262 GpuProcessHost* host = GpuProcessHost::FromID(buffer.second.gpu_host_id); |
221 if (host) | 263 if (host) |
222 host->DestroyGpuMemoryBuffer(buffer.first, client_id, gpu::SyncToken()); | 264 host->DestroyGpuMemoryBuffer(buffer.first, client_id, gpu::SyncToken()); |
223 } | 265 } |
224 | 266 |
225 clients_.erase(client_it); | 267 clients_.erase(client_it); |
| 268 #else |
| 269 gmb_manager_->DestroyAllGpuMemoryBufferForClient(client_id); |
| 270 #endif |
226 } | 271 } |
227 | 272 |
228 bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration( | 273 bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration( |
229 gfx::BufferFormat format, | 274 gfx::BufferFormat format, |
230 gfx::BufferUsage usage) const { | 275 gfx::BufferUsage usage) const { |
231 return native_configurations_.find(std::make_pair(format, usage)) != | 276 return native_configurations_.find(std::make_pair(format, usage)) != |
232 native_configurations_.end(); | 277 native_configurations_.end(); |
233 } | 278 } |
234 | 279 |
235 std::unique_ptr<gfx::GpuMemoryBuffer> | 280 std::unique_ptr<gfx::GpuMemoryBuffer> |
236 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface( | 281 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface( |
237 const gfx::Size& size, | 282 const gfx::Size& size, |
238 gfx::BufferFormat format, | 283 gfx::BufferFormat format, |
239 gfx::BufferUsage usage, | 284 gfx::BufferUsage usage, |
240 gpu::SurfaceHandle surface_handle) { | 285 gpu::SurfaceHandle surface_handle) { |
241 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); | 286 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); |
242 | 287 |
| 288 #if 0 |
243 CreateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_, | 289 CreateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_, |
244 surface_handle); | 290 surface_handle); |
245 BrowserThread::PostTask( | 291 BrowserThread::PostTask( |
246 BrowserThread::IO, FROM_HERE, | 292 BrowserThread::IO, FROM_HERE, |
247 base::Bind( | 293 base::Bind( |
248 &BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO, | 294 &BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO, |
249 base::Unretained(this), // Safe as we wait for result below. | 295 base::Unretained(this), // Safe as we wait for result below. |
250 base::Unretained(&request))); | 296 base::Unretained(&request))); |
251 | 297 |
252 // We're blocking the UI thread, which is generally undesirable. | 298 // We're blocking the UI thread, which is generally undesirable. |
253 TRACE_EVENT0( | 299 TRACE_EVENT0( |
254 "browser", | 300 "browser", |
255 "BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface"); | 301 "BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface"); |
256 base::ThreadRestrictions::ScopedAllowWait allow_wait; | 302 base::ThreadRestrictions::ScopedAllowWait allow_wait; |
257 request.event.Wait(); | 303 request.event.Wait(); |
258 return std::move(request.result); | 304 return std::move(request.result); |
| 305 #else |
| 306 std::unique_ptr<gfx::GpuMemoryBuffer> memory; |
| 307 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL, |
| 308 base::WaitableEvent::InitialState::NOT_SIGNALED); |
| 309 base::ThreadRestrictions::ScopedAllowWait allow_wait; |
| 310 GpuProcessHost::CallOnIO(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED, true, |
| 311 base::Bind(&X, gmb_manager_, &memory, &event, size, |
| 312 format, usage, surface_handle)); |
| 313 event.Wait(); |
| 314 return memory; |
| 315 #endif |
259 } | 316 } |
260 | 317 |
261 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO( | 318 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO( |
262 CreateGpuMemoryBufferRequest* request) { | 319 CreateGpuMemoryBufferRequest* request) { |
263 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 320 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
264 | 321 |
265 gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId(); | 322 gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId(); |
266 | 323 |
267 // Use service side allocation for native configurations. | 324 // Use service side allocation for native configurations. |
268 if (IsNativeGpuMemoryBufferConfiguration(request->format, request->usage)) { | 325 if (IsNativeGpuMemoryBufferConfiguration(request->format, request->usage)) { |
(...skipping 208 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
477 format(format), | 534 format(format), |
478 usage(usage), | 535 usage(usage), |
479 gpu_host_id(gpu_host_id) {} | 536 gpu_host_id(gpu_host_id) {} |
480 | 537 |
481 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) = | 538 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) = |
482 default; | 539 default; |
483 | 540 |
484 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {} | 541 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {} |
485 | 542 |
486 } // namespace content | 543 } // namespace content |
OLD | NEW |