Converted video frame and image callbacks to use new sync tokens.

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 49 matching lines @@
     gfx::BufferUsage usage,
     int client_id,
     const BrowserGpuMemoryBufferManager::CreateCallback& callback) {
   host->CreateGpuMemoryBufferFromHandle(handle, id, size, format, client_id,
                                         callback);
 }
 
 void GpuMemoryBufferDeleted(
     scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner,
     const GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   destruction_task_runner->PostTask(
-      FROM_HERE, base::Bind(destruction_callback, sync_point));
+      FROM_HERE, base::Bind(destruction_callback, sync_token));
 }
 
 bool IsNativeGpuMemoryBufferFactoryConfigurationSupported(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   switch (GpuMemoryBufferFactory::GetNativeType()) {
     case gfx::SHARED_MEMORY_BUFFER:
       return false;
 #if defined(OS_MACOSX)
     case gfx::IO_SURFACE_BUFFER:
@@ skipping 251 matching lines @@
   callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       id, size, format, child_process_handle));
 }
 
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
-void BrowserGpuMemoryBufferManager::SetDestructionSyncPoint(
+void BrowserGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   static_cast<GpuMemoryBufferImpl*>(buffer)
-      ->set_destruction_sync_point(sync_point);
+      ->set_destruction_sync_token(sync_token);
 }
 
 bool BrowserGpuMemoryBufferManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& client : clients_) {
     int client_id = client.first;
 
@@ skipping 28 matching lines @@
     }
   }
 
   return true;
 }
 
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     base::ProcessHandle child_process_handle,
     int child_client_id,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_point);
+  DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_token);
 }
 
 void BrowserGpuMemoryBufferManager::ProcessRemoved(
     base::ProcessHandle process_handle,
     int client_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ClientMap::iterator client_it = clients_.find(client_id);
   if (client_it == clients_.end())
     return;
 
   for (const auto& buffer : client_it->second) {
     // This might happen if buffer is currenlty in the process of being
     // allocated. The buffer will in that case be cleaned up when allocation
     // completes.
     if (buffer.second.type == gfx::EMPTY_BUFFER)
       continue;
 
     GpuProcessHost* host = GpuProcessHost::FromID(buffer.second.gpu_host_id);
     if (host)
-      host->DestroyGpuMemoryBuffer(buffer.first, client_id, 0);
+      host->DestroyGpuMemoryBuffer(buffer.first, client_id, gpu::SyncToken());
   }
 
   clients_.erase(client_it);
 }
 
 bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) const {
   return native_configurations_.find(std::make_pair(format, usage)) !=
          native_configurations_.end();
@@ skipping 214 matching lines @@
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ClientMap::iterator client_it = clients_.find(client_id);
 
   // This can happen if client is removed while the buffer is being allocated.
   if (client_it == clients_.end()) {
     if (!handle.is_null()) {
       GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id);
       if (host)
-        host->DestroyGpuMemoryBuffer(handle.id, client_id, 0);
+        host->DestroyGpuMemoryBuffer(handle.id, client_id, gpu::SyncToken());
     }
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   BufferMap& buffers = client_it->second;
 
   BufferMap::iterator buffer_it = buffers.find(id);
   DCHECK(buffer_it != buffers.end());
   DCHECK_EQ(buffer_it->second.type, gfx::EMPTY_BUFFER);
@@ skipping 31 matching lines @@
   // client is removed.
   buffer_it->second.type = handle.type;
   buffer_it->second.gpu_host_id = gpu_host_id;
 
   callback.Run(handle);
 }
 
 void BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO(
     gfx::GpuMemoryBufferId id,
     int client_id,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(clients_.find(client_id) != clients_.end());
 
   BufferMap& buffers = clients_[client_id];
 
   BufferMap::iterator buffer_it = buffers.find(id);
   if (buffer_it == buffers.end()) {
     LOG(ERROR) << "Invalid GpuMemoryBuffer ID for client.";
     return;
   }
 
   // This can happen if a client managed to call this while a buffer is in the
   // process of being allocated.
   if (buffer_it->second.type == gfx::EMPTY_BUFFER) {
     LOG(ERROR) << "Invalid GpuMemoryBuffer type.";
     return;
   }
 
   GpuProcessHost* host = GpuProcessHost::FromID(buffer_it->second.gpu_host_id);
   if (host)
-    host->DestroyGpuMemoryBuffer(id, client_id, sync_point);
+    host->DestroyGpuMemoryBuffer(id, client_id, sync_token);
 
   buffers.erase(buffer_it);
 }
 
 uint64_t BrowserGpuMemoryBufferManager::ClientIdToTracingProcessId(
     int client_id) const {
   if (client_id == gpu_client_id_) {
     // The gpu_client uses a fixed tracing ID.
     return gpu_client_tracing_id_;
   }
 
   // In normal cases, |client_id| is a child process id, so we can perform
   // the standard conversion.
   return ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId(
       client_id);
 }
 
 }  // namespace content