content: Fix lost context handling when using native GpuMemoryBuffers.

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/atomic_sequence_num.h"
 #include "base/bind.h"
+#include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gpu/client/gpu_memory_buffer_factory_host.h"
+#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
+#include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
+#include "content/common/gpu/gpu_memory_buffer_factory_shared_memory.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/content_switches.h"
+#include "gpu/GLES2/gl2extchromium.h"
+
+#if defined(OS_MACOSX)
+#include "content/common/gpu/gpu_memory_buffer_factory_io_surface.h"
+#endif
+
+#if defined(OS_ANDROID)
+#include "content/common/gpu/gpu_memory_buffer_factory_surface_texture.h"
+#endif
+
+#if defined(USE_OZONE)
+#include "content/common/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
+#endif
 
 namespace content {
 namespace {
 
-BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
+bool IsGpuMemoryBufferFactoryConfigurationSupported(
+    gfx::GpuMemoryBufferType type,
+    const GpuMemoryBufferFactory::Configuration& configuration) {
+  switch (type) {
+    case gfx::SHARED_MEMORY_BUFFER:
+      return GpuMemoryBufferFactorySharedMemory::
+          IsGpuMemoryBufferConfigurationSupported(configuration.format,
+                                                  configuration.usage);
+#if defined(OS_MACOSX)
+    case gfx::IO_SURFACE_BUFFER:
+      return GpuMemoryBufferFactoryIOSurface::
+          IsGpuMemoryBufferConfigurationSupported(configuration.format,
+                                                  configuration.usage);
+#endif
+#if defined(OS_ANDROID)
+    case gfx::SURFACE_TEXTURE_BUFFER:
+      return GpuMemoryBufferFactorySurfaceTexture::
+          IsGpuMemoryBufferConfigurationSupported(configuration.format,
+                                                  configuration.usage);
+#endif
+#if defined(USE_OZONE)
+    case gfx::OZONE_NATIVE_BUFFER:
+      return GpuMemoryBufferFactoryOzoneNativeBuffer::
+          IsGpuMemoryBufferConfigurationSupported(configuration.format,
+                                                  configuration.usage);
+#endif
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+gfx::GpuMemoryBufferType GetGpuMemoryBufferFactoryType() {
+  std::vector<gfx::GpuMemoryBufferType> supported_types;
+  GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
+  DCHECK(!supported_types.empty());
+
+  // The GPU service will always use the preferred type.
+  return supported_types[0];
+}
 
 // Global atomic to generate gpu memory buffer unique IDs.
 base::StaticAtomicSequenceNumber g_next_gpu_memory_buffer_id;
 
 const char kMemoryAllocatorName[] = "gpumemorybuffer";
 
+base::LazyInstance<BrowserGpuMemoryBufferManager>::Leaky

[piman, 2015/06/19 19:29:48]

I'm not crazy about leaving this Leaky, because it stops working after we stop
the IO thread, so we have a clear place to release it.

[reveman, 2015/06/22 17:09:12]

Makes sense. Done.

+    g_gpu_memory_buffer_manager = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferRequest {
   AllocateGpuMemoryBufferRequest(const gfx::Size& size,
                                  gfx::GpuMemoryBuffer::Format format,
                                  gfx::GpuMemoryBuffer::Usage usage,
                                  int client_id,
                                  int surface_id)
       : event(true, false),
         size(size),
         format(format),
         usage(usage),
         client_id(client_id),
         surface_id(surface_id) {}
   ~AllocateGpuMemoryBufferRequest() {}
   base::WaitableEvent event;
   gfx::Size size;
   gfx::GpuMemoryBuffer::Format format;
   gfx::GpuMemoryBuffer::Usage usage;
   int client_id;
   int surface_id;
   scoped_ptr<gfx::GpuMemoryBuffer> result;
 };
 
-BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
-    GpuMemoryBufferFactoryHost* gpu_memory_buffer_factory_host,
-    int gpu_client_id)
-    : gpu_memory_buffer_factory_host_(gpu_memory_buffer_factory_host),
-      gpu_client_id_(gpu_client_id),
-      weak_ptr_factory_(this) {
-  DCHECK(!g_gpu_memory_buffer_manager);
-  g_gpu_memory_buffer_manager = this;
+BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager()
+    : factory_type_(GetGpuMemoryBufferFactoryType()),
+      supported_configurations_(
+          GetSupportedGpuMemoryBufferConfigurations(factory_type_)),
+      gpu_host_id_(0) {
 }
 
 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() {
-  g_gpu_memory_buffer_manager = nullptr;
 }
 
 // static
 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() {
-  return g_gpu_memory_buffer_manager;
+  return g_gpu_memory_buffer_manager.Pointer();
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage) {
-  return AllocateGpuMemoryBufferCommon(size, format, usage, 0);
+  return AllocateGpuMemoryBufferForSurface(size, format, usage, 0);
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForScanout(
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     int32 surface_id) {
   DCHECK_GT(surface_id, 0);
-  return AllocateGpuMemoryBufferCommon(
+  return AllocateGpuMemoryBufferForSurface(
       size, format, gfx::GpuMemoryBuffer::SCANOUT, surface_id);
 }
 
-scoped_ptr<gfx::GpuMemoryBuffer>
-BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferCommon(
-    const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage,
-    int32 surface_id) {
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // Fallback to shared memory buffer if |format| and |usage| are not supported
-  // by factory.
-  if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
-          format, usage)) {
-    DCHECK(GpuMemoryBufferImplSharedMemory::IsFormatSupported(format))
-        << format;
-    DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage)) << usage;
-    return GpuMemoryBufferImplSharedMemory::Create(
-        g_next_gpu_memory_buffer_id.GetNext(), size, format);
-  }
-
-  AllocateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_,
-                                         surface_id);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO,
-                 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::AllocateGpuMemoryBuffer");
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
-  request.event.Wait();
-  return request.result.Pass();
-}
-
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
 
+  // Use service side allocation if this is a supported configuration.
+  if (IsGpuMemoryBufferConfigurationSupported(format, usage)) {
+    AllocateGpuMemoryBufferOnIO(new_id, size, format, usage, child_client_id, 0,
+                                callback);
+    return;
+  }
+
+  // Early out if we cannot fallback to shared memory buffer.
+  if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
+      !GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
+      !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format)) {
+    callback.Run(gfx::GpuMemoryBufferHandle());
+    return;
+  }
+
   BufferMap& buffers = clients_[child_client_id];
   DCHECK(buffers.find(new_id) == buffers.end());
 
-  // Fallback to shared memory buffer if |format| and |usage| are not supported
-  // by factory.
-  if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
-          format, usage)) {
-    // Early out if we cannot fallback to shared memory buffer.
-    if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
-        !GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
-        !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format)) {
-      callback.Run(gfx::GpuMemoryBufferHandle());
-      return;
-    }
-
-    buffers[new_id] = BufferInfo(size, format, gfx::SHARED_MEMORY_BUFFER);
-    callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
-        new_id, size, format, child_process_handle));
-    return;
-  }
-
-  // Note: Handling of cases where the child process is removed before the
-  // allocation completes is less subtle if we set the buffer type to
-  // EMPTY_BUFFER here and verify that this has not changed when allocation
-  // completes.
-  buffers[new_id] = BufferInfo(size, format, gfx::EMPTY_BUFFER);
-
-  gpu_memory_buffer_factory_host_->CreateGpuMemoryBuffer(
-      new_id, size, format, usage, child_client_id, 0,
-      base::Bind(&BrowserGpuMemoryBufferManager::
-                     GpuMemoryBufferAllocatedForChildProcess,
-                 weak_ptr_factory_.GetWeakPtr(), new_id, child_client_id,
-                 callback));
+  // Allocate shared memory buffer as fallback.
+  buffers[new_id] = BufferInfo(size, format, gfx::SHARED_MEMORY_BUFFER, 0);
+  callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
+      new_id, size, format, child_process_handle));
 }
 
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncPoint(
     gfx::GpuMemoryBuffer* buffer,
@@ skipping 26 matching lines @@
 
       dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                       base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                       buffer_size_in_bytes);
     }
   }
 
   return true;
 }
 
+uint32 BrowserGpuMemoryBufferManager::GetImageTextureTarget(
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage) const {
+  if (!IsGpuMemoryBufferConfigurationSupported(format, usage))
+    return GL_TEXTURE_2D;
+
+  switch (factory_type_) {
+    case gfx::SURFACE_TEXTURE_BUFFER:
+    case gfx::OZONE_NATIVE_BUFFER:
+      // GPU memory buffers that are shared with the GL using EGLImages require
+      // TEXTURE_EXTERNAL_OES.
+      return GL_TEXTURE_EXTERNAL_OES;
+    case gfx::IO_SURFACE_BUFFER:
+      // IOSurface backed images require GL_TEXTURE_RECTANGLE_ARB.
+      return GL_TEXTURE_RECTANGLE_ARB;
+    default:
+      return GL_TEXTURE_2D;
+  }
+}
+
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     uint32 sync_point) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(clients_.find(child_client_id) != clients_.end());
 
-  BufferMap& buffers = clients_[child_client_id];
-
-  BufferMap::iterator buffer_it = buffers.find(id);
-  if (buffer_it == buffers.end()) {
-    LOG(ERROR) << "Invalid GpuMemoryBuffer ID for child process.";
-    return;
-  }
-
-  // This can happen if a child process managed to trigger a call to 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;
-  }
-
-  // Buffers allocated using the factory need to be destroyed through the
-  // factory.
-  if (buffer_it->second.type != gfx::SHARED_MEMORY_BUFFER) {
-    gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(id,
-                                                            child_client_id,
-                                                            sync_point);
-  }
-
-  buffers.erase(buffer_it);
+  DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_point);
 }
 
 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;
 
-    // Skip shared memory buffers as they were not allocated using the factory.
-    if (buffer.second.type == gfx::SHARED_MEMORY_BUFFER)
-      continue;
-
-    gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(buffer.first,
-                                                            client_id, 0);
+    GpuProcessHost* host = GpuProcessHost::FromID(buffer.second.gpu_host_id);
+    if (host)
+      host->DestroyGpuMemoryBuffer(buffer.first, client_id, 0);
   }
 
   clients_.erase(client_it);
 }
 
-void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO(
-    AllocateGpuMemoryBufferRequest* request) {
-  // Note: Unretained is safe as this is only used for synchronous allocation
-  // from a non-IO thread.
-  gpu_memory_buffer_factory_host_->CreateGpuMemoryBuffer(
-      g_next_gpu_memory_buffer_id.GetNext(), request->size, request->format,
-      request->usage, request->client_id, request->surface_id,
-      base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO,
-                 base::Unretained(this), base::Unretained(request)));
+// static
+std::vector<GpuMemoryBufferFactory::Configuration>
+BrowserGpuMemoryBufferManager::GetSupportedGpuMemoryBufferConfigurations(
+    gfx::GpuMemoryBufferType type) {
+  std::vector<GpuMemoryBufferFactory::Configuration> configurations;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableNativeGpuMemoryBuffers)) {
+    const GpuMemoryBufferFactory::Configuration kNativeConfigurations[] = {
+        {gfx::GpuMemoryBuffer::R_8, gfx::GpuMemoryBuffer::MAP},
+        {gfx::GpuMemoryBuffer::R_8, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
+        {gfx::GpuMemoryBuffer::RGBA_4444, gfx::GpuMemoryBuffer::MAP},
+        {gfx::GpuMemoryBuffer::RGBA_4444, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
+        {gfx::GpuMemoryBuffer::RGBA_8888, gfx::GpuMemoryBuffer::MAP},
+        {gfx::GpuMemoryBuffer::RGBA_8888, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
+        {gfx::GpuMemoryBuffer::BGRA_8888, gfx::GpuMemoryBuffer::MAP},
+        {gfx::GpuMemoryBuffer::BGRA_8888,
+         gfx::GpuMemoryBuffer::PERSISTENT_MAP}};
+    for (auto& configuration : kNativeConfigurations) {
+      if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
+        configurations.push_back(configuration);
+    }
+  }
+
+#if defined(USE_OZONE)
+  const GpuMemoryBufferFactory::Configuration kScanoutConfigurations[] = {
+      {gfx::GpuMemoryBuffer::BGRA_8888, gfx::GpuMemoryBuffer::SCANOUT},
+      {gfx::GpuMemoryBuffer::RGBX_8888, gfx::GpuMemoryBuffer::SCANOUT}};
+  for (auto& configuration : kScanoutConfigurations) {
+    if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
+      configurations.push_back(configuration);
+  }
+#endif
+
+  return configurations;
 }
 
-void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO(
+scoped_ptr<gfx::GpuMemoryBuffer>
+BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface(
+    const gfx::Size& size,
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage,
+    int32 surface_id) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  AllocateGpuMemoryBufferRequest request(
+      size, format, usage,
+      BrowserGpuChannelHostFactory::instance()->GetGpuChannelId(), surface_id);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO,
+          base::Unretained(this), 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 request.result.Pass();
+}
+
+void BrowserGpuMemoryBufferManager::GpuMemoryBufferDeleted(
+    gfx::GpuMemoryBufferId id,
+    int client_id,
+    uint32 sync_point) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
+                 base::Unretained(this), id, client_id, sync_point));
+}
+
+bool BrowserGpuMemoryBufferManager::IsGpuMemoryBufferConfigurationSupported(
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage) const {
+  for (auto& configuration : supported_configurations_) {
+    if (configuration.format == format && configuration.usage == usage)
+      return true;
+  }
+  return false;
+}
+
+void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO(
+    AllocateGpuMemoryBufferRequest* request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
+
+  // Use service side allocation if this is a supported configuration.
+  if (IsGpuMemoryBufferConfigurationSupported(request->format,
+                                              request->usage)) {
+    AllocateGpuMemoryBufferOnIO(
+        new_id, request->size, request->format, request->usage,
+        request->client_id, request->surface_id,
+        base::Bind(&BrowserGpuMemoryBufferManager::
+                       GpuMemoryBufferAllocatedForSurfaceOnIO,
+                   base::Unretained(this), base::Unretained(request)));
+    return;
+  }
+
+  DCHECK(GpuMemoryBufferImplSharedMemory::IsFormatSupported(request->format))
+      << request->format;
+  DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
+      << request->usage;
+
+  BufferMap& buffers = clients_[request->client_id];
+  DCHECK(buffers.find(new_id) == buffers.end());
+
+  // Allocate shared memory buffer as fallback.
+  buffers[new_id] =
+      BufferInfo(request->size, request->format, gfx::SHARED_MEMORY_BUFFER, 0);
+  request->result = GpuMemoryBufferImplSharedMemory::Create(
+      new_id, request->size, request->format);
+  request->event.Signal();
+}
+
+void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForSurfaceOnIO(
     AllocateGpuMemoryBufferRequest* request,
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Early out if factory failed to allocate the buffer.
   if (handle.is_null()) {
     request->event.Signal();
     return;
   }
 
-  DCHECK_NE(handle.type, gfx::SHARED_MEMORY_BUFFER);
   request->result = GpuMemoryBufferImpl::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferDeleted,
-                 weak_ptr_factory_.GetWeakPtr(), handle.id,
-                 request->client_id));
+                 base::Unretained(this), handle.id, request->client_id));
   request->event.Signal();
 }
 
-void BrowserGpuMemoryBufferManager::GpuMemoryBufferDeleted(
+void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO(
+    gfx::GpuMemoryBufferId id,
+    const gfx::Size& size,
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage,
+    int client_id,
+    int surface_id,
+    const AllocationCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  BufferMap& buffers = clients_[client_id];
+  DCHECK(buffers.find(id) == buffers.end());
+
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+                               CAUSE_FOR_GPU_LAUNCH_GPU_MEMORY_BUFFER_ALLOCATE);
+    if (!host) {
+      LOG(ERROR) << "Failed to launch GPU process.";
+      callback.Run(gfx::GpuMemoryBufferHandle());
+      return;
+    }
+    gpu_host_id_ = host->host_id();
+  }
+
+  // Note: Handling of cases where the client is removed before the allocation
+  // completes is less subtle if we set the buffer type to EMPTY_BUFFER here
+  // and verify that this has not changed when allocation completes.
+  buffers[id] = BufferInfo(size, format, gfx::EMPTY_BUFFER, 0);
+
+  host->CreateGpuMemoryBuffer(
+      id, size, format, usage, client_id, surface_id,
+      base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO,
+                 base::Unretained(this), id, client_id, gpu_host_id_,
+                 callback));
+}
+
+void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO(
     gfx::GpuMemoryBufferId id,
     int client_id,
-    uint32 sync_point) {
-  gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(id,
-                                                          client_id,
-                                                          sync_point);
-}
-
-void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForChildProcess(
-    gfx::GpuMemoryBufferId id,
-    int child_client_id,
+    int gpu_host_id,
     const AllocationCallback& callback,
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  ClientMap::iterator client_it = clients_.find(child_client_id);
+  ClientMap::iterator client_it = clients_.find(client_id);
 
-  // This can happen if the child process is removed while the buffer is being
-  // allocated.
+  // This can happen if client is removed while the buffer is being allocated.
   if (client_it == clients_.end()) {
     if (!handle.is_null()) {
-      gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(
-          handle.id, child_client_id, 0);
+      GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id);
+      if (host)
+        host->DestroyGpuMemoryBuffer(handle.id, client_id, 0);
     }
     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);
 
   // If the handle isn't valid, that means that the GPU process crashed or is
   // misbehaving so we remove the buffer entry and run the allocation callback
   // with an empty handle to indicate failure.
-  bool valid_handle = !handle.is_null() && handle.id == id &&
-                      handle.type != gfx::SHARED_MEMORY_BUFFER;
+  bool valid_handle = !handle.is_null() && handle.id == id;
   if (!valid_handle) {

[piman, 2015/06/19 19:29:48]

Do you need retry logic, like we do for the channel in
BrowserGpuChannelHostFactory?
The problem is that when you get a host in GpuProcessHost::FromID, you don't
know if it's dead or not (because it's fundamentally racy, it could die between
when you got the GpuProcessHost* and when you send the message). So if the GPU
process was previously dead, you will fail to create a GMB, instead of creating
a new GPU process.

[reveman, 2015/06/22 17:09:12]

Good point. Added retry logic to latest patch.

Note that there's still a problem with clients not being able to tell if a
buffer was lost. It happens to work right now as clients tend to check for
contexts being lost and re-allocate all buffers in that case. I think ideally
we'd have a different mechanism to tell if a buffer is lost. My current plan for
this is to implement it as part of adding support for discardable gpu memory
buffers.

     buffers.erase(buffer_it);
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
-  // Store the type of this buffer so it can be cleaned up if the child
-  // process is removed.
+  // Store the type and host id of this buffer so it can be cleaned up if the
+  // 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) {
+  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);
+
+  buffers.erase(buffer_it);
+}
+
 }  // namespace content