CommandBufferProxyImpl holds on to GpuMemoryBuffers while they are in use.

gpu/ipc/client/command_buffer_proxy_impl.cc

 // Copyright (c) 2012 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 "gpu/ipc/client/command_buffer_proxy_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 441 matching lines @@
     return -1;
 
   int32_t new_id = channel_->ReserveImageId();
 
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       channel_->gpu_memory_buffer_manager();
   gfx::GpuMemoryBuffer* gpu_memory_buffer =
       gpu_memory_buffer_manager->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
-  DCHECK(image_gmb_ids_map_.find(new_id) == image_gmb_ids_map_.end());
-  image_gmb_ids_map_[new_id] = gpu_memory_buffer->GetId().id;
+  DCHECK(image_gmb_map_.find(new_id) == image_gmb_map_.end());
+  image_gmb_map_[new_id].gpu_memory_buffer_id = gpu_memory_buffer->GetId().id;
 
   // This handle is owned by the GPU process and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // sending of the CreateImage IPC below.
   bool requires_sync_token = false;
   gfx::GpuMemoryBufferHandle handle =
       channel_->ShareGpuMemoryBufferToGpuProcess(gpu_memory_buffer->GetHandle(),
                                                  &requires_sync_token);
 
   uint64_t image_fence_sync = 0;
@@ skipping 34 matching lines @@
   }
 
   return new_id;
 }
 
 void CommandBufferProxyImpl::DestroyImage(int32_t id) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
-  auto it = image_gmb_ids_map_.find(id);
-  if (it != image_gmb_ids_map_.end())
-    image_gmb_ids_map_.erase(it);
+  auto it = image_gmb_map_.find(id);
+  if (it != image_gmb_map_.end())
+    image_gmb_map_.erase(it);
   Send(new GpuCommandBufferMsg_DestroyImage(route_id_, id));
 }
 
 int32_t CommandBufferProxyImpl::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internal_format,
     unsigned usage) {
   CheckLock();
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       channel_->gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::DefaultBufferFormatForImageFormat(internal_format),
           gfx::BufferUsage::SCANOUT, gpu::kNullSurfaceHandle));
   if (!buffer)
     return -1;
 
-  return CreateImage(buffer->AsClientBuffer(), width, height, internal_format);
+  int32_t result =
+      CreateImage(buffer->AsClientBuffer(), width, height, internal_format);
+  if (result != -1)
+    image_gmb_map_[result].owned_gpu_memory_buffer = std::move(buffer);
+  return result;
 }
 
 int32_t CommandBufferProxyImpl::GetImageGpuMemoryBufferId(unsigned image_id) {
   CheckLock();
-  auto it = image_gmb_ids_map_.find(image_id);
-  if (it != image_gmb_ids_map_.end())
-    return it->second;
+  auto it = image_gmb_map_.find(image_id);
+  if (it != image_gmb_map_.end())
+    return it->second.gpu_memory_buffer_id;
   return -1;
 }
 
 uint32_t CommandBufferProxyImpl::CreateStreamTexture(uint32_t texture_id) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return 0;
 
   int32_t stream_id = channel_->GenerateRouteID();
   bool succeeded = false;
@@ skipping 309 matching lines @@
   if (!channel_)
     return;
   channel_->FlushPendingStream(stream_id_);
   channel_->Send(new GpuChannelMsg_DestroyCommandBuffer(route_id_));
   channel_->RemoveRoute(route_id_);
   channel_ = nullptr;
   if (gpu_control_client_)
     gpu_control_client_->OnGpuControlLostContext();
 }
 
+CommandBufferProxyImpl::ImageInfo::ImageInfo() {}
+CommandBufferProxyImpl::ImageInfo::~ImageInfo() {}
+CommandBufferProxyImpl::ImageInfo::ImageInfo(ImageInfo&& other) = default;
+CommandBufferProxyImpl::ImageInfo& CommandBufferProxyImpl::ImageInfo::operator=(
+    ImageInfo&& other) = default;
+
 }  // namespace gpu