Cleanup GpuMemoryBuffer

content/common/gpu/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 "content/common/gpu/client/command_buffer_proxy_impl.h"
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 290 matching lines @@
 
 int32_t CommandBufferProxyImpl::CreateImage(ClientBuffer buffer,
                                             size_t width,
                                             size_t height,
                                             unsigned internalformat) {
   if (last_state_.error != gpu::error::kNoError)
     return -1;
 
   int32 new_id = channel_->ReserveImageId();
 
+  gpu::GpuMemoryBufferManager* memory_buffer_manager =
+      channel_->gpu_memory_buffer_manager();
   gfx::GpuMemoryBuffer* gpu_memory_buffer =
-      channel_->gpu_memory_buffer_manager()->GpuMemoryBufferFromClientBuffer(
-          buffer);
+      memory_buffer_manager->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
   // 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.
   gfx::GpuMemoryBufferHandle handle =
       channel_->ShareGpuMemoryBufferToGpuProcess(

[reveman, 2014/10/31 11:39:36]

Maybe you can pass a route_id_ or an InserSyncPointCallback to this function so
it can easily use
GpuMemoryBufferManager::SetGpuMemoryBufferDestructionSyncPointCallback as I
suggested in my other comment.

           gpu_memory_buffer->GetHandle());
 
   DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
   if (!Send(new GpuCommandBufferMsg_CreateImage(route_id_,
                                                 new_id,
                                                 handle,
                                                 gfx::Size(width, height),
                                                 gpu_memory_buffer->GetFormat(),
                                                 internalformat))) {
     return -1;
   }
 
+  if (memory_buffer_manager->NeedsDestructionSyncPoint(handle.type)) {
+    memory_buffer_manager->RecordDestructionSyncPoint(buffer,
+                                                      InsertSyncPoint());
+  }
+
   return new_id;
 }
 
 void CommandBufferProxyImpl::DestroyImage(int32 id) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_DestroyImage(route_id_, id));
 }
 
@@ skipping 181 matching lines @@
     if (!ui::LatencyInfo::Verify(
             latency_info, "CommandBufferProxyImpl::OnSwapBuffersCompleted")) {
       swap_buffers_completion_callback_.Run(std::vector<ui::LatencyInfo>());
       return;
     }
     swap_buffers_completion_callback_.Run(latency_info);
   }
 }
 
 }  // namespace content