Cleanup GpuMemoryBuffer

content/common/gpu/client/gpu_memory_buffer_impl_ozone.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/common/gpu/client/gpu_memory_buffer_impl.h"
 
 #include "content/common/gpu/client/gpu_memory_buffer_impl_ozone_native_buffer.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
 
 namespace content {
@@ skipping 42 matching lines @@
     return;
   }
 
   callback.Run(gfx::GpuMemoryBufferHandle());
 }
 
 // static
 void GpuMemoryBufferImpl::DeletedByChildProcess(
     gfx::GpuMemoryBufferType type,
     const gfx::GpuMemoryBufferId& id,
-    base::ProcessHandle child_process) {
+    base::ProcessHandle child_process,
+    uint32_t sync_point) {
+  switch (type) {
+    case gfx::SHARED_MEMORY_BUFFER:
+      break;
+    case gfx::OZONE_NATIVE_BUFFER:
+      GpuMemoryBufferImplOzoneNativeBuffer::DeletedByChildProcess(id,
+                                                                  sync_point);

[piman, 2014/11/03 19:36:34]

What prevents an arbitrary renderer from destroying a memory buffer belonging to
another process? Should we pass through the child id (as opposed to the
child_process which I don't think is useful), and check against id.secondary_id?
(On a per-type basis, I suppose?)

[alexst (slow to review), 2014/11/03 20:29:17]

Good point, AllocateForChildProcess takes both ProcessHandle and
child_client_id, so I added child_client_id here for symmetry and introduced the
check.

+      break;
+    default:
+      LOG(ERROR) << "Unexpected GpuMemoryBufferType";
+  }
 }
 
 // static
 scoped_ptr<GpuMemoryBufferImpl> GpuMemoryBufferImpl::CreateFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     Format format,
     const DestructionCallback& callback) {
   switch (handle.type) {
     case gfx::SHARED_MEMORY_BUFFER:
       return GpuMemoryBufferImplSharedMemory::CreateFromHandle(
           handle, size, format, callback);
     case gfx::OZONE_NATIVE_BUFFER:
       return GpuMemoryBufferImplOzoneNativeBuffer::CreateFromHandle(
           handle, size, format, callback);
     default:
       return scoped_ptr<GpuMemoryBufferImpl>();
   }
 }
 
 }  // namespace content