gpu: Remove GPU service side GMB creation from handle.

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 24 matching lines @@
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     const BrowserGpuMemoryBufferManager::CreateCallback& callback) {
   host->CreateGpuMemoryBuffer(id, size, format, usage, client_id, surface_id,
                               callback);
 }
 
-void HostCreateGpuMemoryBufferFromHandle(
-    const gfx::GpuMemoryBufferHandle& handle,
-    GpuProcessHost* host,
-    gfx::GpuMemoryBufferId id,
-    const gfx::Size& size,
-    gfx::BufferFormat format,
-    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,
     const gpu::SyncToken& sync_token) {
   destruction_task_runner->PostTask(
       FROM_HERE, base::Bind(destruction_callback, sync_token));
 }
 
 bool IsNativeGpuMemoryBufferFactoryConfigurationSupported(
     gfx::BufferFormat format,
@@ skipping 425 matching lines @@
 
   // Use service side allocation for native types.
   if (request->handle.type != gfx::SHARED_MEMORY_BUFFER) {
     // Early out if service side allocation is not supported.
     if (request->handle.type != gpu::GetNativeGpuMemoryBufferType() ||
         !IsNativeGpuMemoryBufferConfiguration(request->format,
                                               request->usage)) {
       request->event.Signal();
       return;
     }
-    // Note: Unretained is safe as this is only used for synchronous allocation
-    // from a non-IO thread.
-    CreateGpuMemoryBufferOnIO(
-        base::Bind(&HostCreateGpuMemoryBufferFromHandle, request->handle),
-        new_id, request->size, request->format, request->usage,
-        request->client_id, false,
+
+    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 = GpuMemoryBufferImpl::CreateFromHandle(
+        handle, request->size, request->format, request->usage,
         base::Bind(
-            &BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO,
-            base::Unretained(this), base::Unretained(request)));
+            &GpuMemoryBufferDeleted,
+            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+            base::Bind(
+                &BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
+                base::Unretained(this), handle.id, request->client_id)));
+    request->event.Signal();
     return;
   }
 
   DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
       << static_cast<int>(request->usage);
 
   BufferMap& buffers = clients_[request->client_id];
 
   // Allocate shared memory buffer.
   auto insert_result = buffers.insert(std::make_pair(
@@ skipping 202 matching lines @@
     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