mus: Get GpuMemoryBuffer from gpu process when possible.

services/ui/common/mus_gpu_memory_buffer_manager.cc

 // Copyright 2016 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 "services/ui/common/mus_gpu_memory_buffer_manager.h"
 
 #include "base/logging.h"
 #include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "gpu/ipc/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "services/ui/gpu/interfaces/gpu_service_internal.mojom.h"
 
 namespace ui {
 
 MusGpuMemoryBufferManager::MusGpuMemoryBufferManager(
     mojom::GpuServiceInternal* gpu_service,
     int client_id)
     : gpu_service_(gpu_service), client_id_(client_id), weak_factory_(this) {}
 
 MusGpuMemoryBufferManager::~MusGpuMemoryBufferManager() {}
 
+gfx::GpuMemoryBufferHandle
+MusGpuMemoryBufferManager::CreateGpuMemoryBufferHandle(
+    gfx::GpuMemoryBufferId id,
+    int client_id,
+    const gfx::Size& size,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
+    gpu::SurfaceHandle surface_handle) {
+  DCHECK(CalledOnValidThread());
+  if (gpu::GetNativeGpuMemoryBufferType() == gfx::EMPTY_BUFFER)
+    return gfx::GpuMemoryBufferHandle();
+  const bool is_native =
+      gpu::IsNativeGpuMemoryBufferConfigurationSupported(format, usage);
+  if (is_native) {
+    gfx::GpuMemoryBufferHandle handle;
+    gpu_service_->CreateGpuMemoryBuffer(id, size, format, usage, client_id,
+                                        surface_handle, &handle);
+    if (!handle.is_null())
+      native_buffers_[client_id].insert(handle.id);
+    return handle;
+  }
+
+  DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage))
+      << static_cast<int>(usage);
+  return gpu::GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer(id, size,
+                                                                     format);
+}
+
 std::unique_ptr<gfx::GpuMemoryBuffer>
 MusGpuMemoryBufferManager::CreateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
-  DCHECK(CalledOnValidThread());
   gfx::GpuMemoryBufferId id(next_gpu_memory_id_++);
-  const bool is_native =
-      gpu::IsNativeGpuMemoryBufferConfigurationSupported(format, usage);
-  if (is_native) {
-    gfx::GpuMemoryBufferHandle handle;
-    gpu_service_->CreateGpuMemoryBuffer(id, size, format, usage, client_id_,
-                                        surface_handle, &handle);
-    if (handle.is_null())
-      return nullptr;
-    return gpu::GpuMemoryBufferImpl::CreateFromHandle(
-        handle, size, format, usage,
-        base::Bind(&MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer,
-                   weak_factory_.GetWeakPtr(), id, client_id_, is_native));
-  }
-
-  DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage))
-      << static_cast<int>(usage);
-  return gpu::GpuMemoryBufferImplSharedMemory::Create(
-      id, size, format,
+  gfx::GpuMemoryBufferHandle handle = CreateGpuMemoryBufferHandle(
+      id, client_id_, size, format, usage, surface_handle);
+  if (handle.is_null())
+    return nullptr;
+  return gpu::GpuMemoryBufferImpl::CreateFromHandle(
+      handle, size, format, usage,
       base::Bind(&MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer,
-                 weak_factory_.GetWeakPtr(), id, client_id_, is_native));
+                 weak_factory_.GetWeakPtr(), id, client_id_));
 }
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 MusGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format) {
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 void MusGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   DCHECK(CalledOnValidThread());
   static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
       sync_token);
 }
 
 void MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id,
-    bool is_native,
     const gpu::SyncToken& sync_token) {
   DCHECK(CalledOnValidThread());
-  if (is_native) {
-    gpu_service_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
-  }
+  if (!native_buffers_.count(client_id) ||

[reveman, 2016/11/30 17:32:45]

Can we avoid iterating over all buffers? Finding the first is sufficient here.

[sadrul, 2016/11/30 19:54:31]

Not totally sure what you mean here. This is checking whether there's a native
memory buffer associated with (id, client_id).

[reveman, 2016/12/02 19:12:50]

I was referring to count() being less efficient than find() and in this case
find() is sufficient and more properly match the intent of the code. Anyhow,
looks like this count() call is not needed at all in latest patch unless I'm
missing something.

+      !native_buffers_[client_id].erase(id))
+    return;
+  if (native_buffers_[client_id].empty())

[reveman, 2016/11/30 17:32:45]

Can the manager be notified when the client is gone instead of having to handle
this special case here each time we destroy a buffer? Notifying also allows to
to make sure that all native buffers are properly destroyed on the gpu service
side when a client goes away.

[sadrul, 2016/11/30 19:54:31]

Oh good point. I have added the callback to notify this manager when a client
goes away.

But, is it possible for a client to destroy some memory buffer it had previously
allocated without freeing all such memory buffers?

+    native_buffers_.erase(client_id);
+  gpu_service_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
 }
 
 }  // namespace ui