gpu: Refactor memory buffer handling code out of content.

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 136 matching lines @@
   ~CreateGpuMemoryBufferFromHandleRequest() {}
   gfx::GpuMemoryBufferHandle handle;
 };
 
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
     int gpu_client_id,
     uint64_t gpu_client_tracing_id)
     : native_configurations_(GetNativeGpuMemoryBufferConfigurations()),
       gpu_client_id_(gpu_client_id),
       gpu_client_tracing_id_(gpu_client_tracing_id),
+      gpu_memory_buffer_manager_(new gpu::GpuHostMemoryBufferManager()),
       gpu_host_id_(0) {
   DCHECK(!g_gpu_memory_buffer_manager);
   g_gpu_memory_buffer_manager = this;
+  gpu_memory_buffer_manager_->SetIO(BrowserThread::GetTaskRunnerForThread(
+      BrowserThread::IO));
 }
 
 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() {
   g_gpu_memory_buffer_manager = nullptr;
 }
 
 // static
 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() {
   return g_gpu_memory_buffer_manager;
 }
@@ skipping 52 matching lines @@
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
   return AllocateGpuMemoryBufferForSurface(size, format, usage, surface_handle);
 }
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format) {
+#if 0
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   CreateGpuMemoryBufferFromHandleRequest request(handle, size, format,
                                                  gpu_client_id_);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BrowserGpuMemoryBufferManager::
                      HandleCreateGpuMemoryBufferFromHandleOnIO,
                  base::Unretained(this),  // Safe as we wait for result below.
                  base::Unretained(&request)));
 
   // We're blocking the UI thread, which is generally undesirable.
   TRACE_EVENT0(
       "browser",
       "BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return std::move(request.result);
+#else
+  return gpu_memory_buffer_manager_->CreateGpuMemoryBufferFromHandle(handle,
+                                                                     size,
+                                                                     format);
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(format, usage)) {
     CreateGpuMemoryBufferOnIO(
         base::Bind(&HostCreateGpuMemoryBuffer, gpu::kNullSurfaceHandle), id,
         size, format, usage, child_client_id, false, callback);
     return;
   }
 
+#if 0
   // Early out if we cannot fallback to shared memory buffer.
   if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
       !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size,
                                                                   format)) {
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   BufferMap& buffers = clients_[child_client_id];
 
   // Allocate shared memory buffer as fallback.
   auto insert_result = buffers.insert(std::make_pair(
       id, BufferInfo(size, gfx::SHARED_MEMORY_BUFFER, format, usage, 0)));
   if (!insert_result.second) {
     DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with "
                    "an existing ID.";
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   callback.Run(gpu::GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       id, size, format, child_process_handle));
+#else
+  gpu_memory_buffer_manager_->AllocateGpuMemoryBufferForClient(id, size, format,
+                                                               usage,
+                                                               child_client_id,
+                                                               callback);
+#endif
 }
 
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return gpu::GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->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);
-
+#if 0
   for (const auto& client : clients_) {
     int client_id = client.first;
 
     for (const auto& buffer : client.second) {
       if (buffer.second.type == gfx::EMPTY_BUFFER)
         continue;
 
       gfx::GpuMemoryBufferId buffer_id = buffer.first;
       base::trace_event::MemoryAllocatorDump* dump =
           pmd->CreateAllocatorDump(base::StringPrintf(
@@ skipping 14 matching lines @@
       uint64_t client_tracing_process_id =
           ClientIdToTracingProcessId(client_id);
 
       base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
           gfx::GetGpuMemoryBufferGUIDForTracing(client_tracing_process_id,
                                                 buffer_id);
       pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
       pmd->AddOwnershipEdge(dump->guid(), shared_buffer_guid);
     }
   }
-
+#endif
   return true;
 }
 
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_token);
 }
 
 void BrowserGpuMemoryBufferManager::ProcessRemoved(
     base::ProcessHandle process_handle,
     int client_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+#if 0  // XXX
   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, gpu::SyncToken());
   }
 
   clients_.erase(client_it);
+#endif
 }
 
 bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) const {
   return native_configurations_.find(std::make_pair(format, usage)) !=
          native_configurations_.end();
 }
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
+  return gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(size, format,
+                                                             usage,
+                                                             surface_handle);
+#if 0
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   CreateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_,
                                        surface_handle);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO,
           base::Unretained(this),  // Safe as we wait for result below.
           base::Unretained(&request)));
 
   // We're blocking the UI thread, which is generally undesirable.
   TRACE_EVENT0(
       "browser",
       "BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return std::move(request.result);
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO(
     CreateGpuMemoryBufferRequest* request) {
+#if 0
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
 
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(request->format, request->usage)) {
     // Note: Unretained is safe as this is only used for synchronous allocation
     // from a non-IO thread.
     CreateGpuMemoryBufferOnIO(
         base::Bind(&HostCreateGpuMemoryBuffer, request->surface_handle), new_id,
@@ skipping 19 matching lines @@
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
   request->result = gpu::GpuMemoryBufferImplSharedMemory::Create(
       new_id, request->size, request->format,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferFromHandleOnIO(
     CreateGpuMemoryBufferFromHandleRequest* request) {
+#if 0
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
 
   BufferMap& buffers = clients_[request->client_id];
   auto insert_result = buffers.insert(std::make_pair(
       new_id, BufferInfo(request->size, request->handle.type,
                          request->format, request->usage, 0)));
   DCHECK(insert_result.second);
 
   gfx::GpuMemoryBufferHandle handle = request->handle;
   handle.id = new_id;
 
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
   request->result = gpu::GpuMemoryBufferImpl::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO(
     CreateGpuMemoryBufferRequest* request,
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Early out if factory failed to create the buffer.
   if (handle.is_null()) {
     request->event.Signal();
@@ skipping 133 matching lines @@
   buffer_it->second.gpu_host_id = gpu_host_id;
 
   callback.Run(handle);
 }
 
 void BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO(
     gfx::GpuMemoryBufferId id,
     int client_id,
     const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (clients_.find(client_id) == clients_.end())
+    return;
+
   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;
   }
 
@@ skipping 37 matching lines @@
       format(format),
       usage(usage),
       gpu_host_id(gpu_host_id) {}
 
 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
     default;
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content