Add gfx::GpuMemoryBuffer::shared_memory_handle()

ui/gfx/gpu_memory_buffer.h

 // Copyright 2013 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.
 
 #ifndef UI_GFX_GPU_MEMORY_BUFFER_H_
 #define UI_GFX_GPU_MEMORY_BUFFER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 44 matching lines @@
 #endif
 };
 
 // This interface typically correspond to a type of shared memory that is also
 // shared with the GPU. A GPU memory buffer can be written to directly by
 // regular CPU code, but can also be read by the GPU.
 class GFX_EXPORT GpuMemoryBuffer {
  public:
   virtual ~GpuMemoryBuffer() {}
 
+  // Returns the shared memory's handle when the back end is base::SharedMemory.
+  // Otherwise, this returns an invalid handle.
+  virtual base::SharedMemoryHandle shared_memory_handle() const;

[reveman, 2017/05/30 21:37:01]

I don't like to expose implementation specific functions in this API. Why is
this needed?

[ssid, 2017/05/31 03:35:45]

We now have a shared memory tracker which records memory usage in tracing. This
method is required because GpuMemoryBufferClient::OnMemoryDump needs to know
which of the shared memory segments in tracing is the buffer allocated from.
The GpuMemoryBufferClient::OnMemoryDump will call
SharedMemory::GetSegmentNameForTracing (to say that the backing for current
segment has this id in trace).
If not this method we would need something like GetSharedMemoryIdForTracing or
similar, which would still be implementation specific, in sense that it will be
specific to shared memory backing.

Another idea that comes to my mind here is to have a function that says:
// Called during tracing for creating tracing suballocation edges
// to appropriate memory backing of the buffer.
CreateSuballocationEdgesForTracing(MemoryAllocatorDumpGuid guid, int
edge_importance);
guid of the dump created by the buffer impl in OnMemoryDump, importance to
specify if the current process owns the memory (refer
ProcessMemoryDump::AddOwnershipEdge.

This function creates edges instead of exposing the handle here.

[reveman, 2017/06/01 14:13:45]

I prefer this latter approach as it's something that can potentially be used by
other implementation types. Most importantly, I like it as it avoids adding
functions that allow the client to determine what type an instance is of as
that's easily abused and results in code that is hard to maintain and change in
the future.

If it could also be combined with the GetGUIDForTracing function below someone
then even better.

+
   // Maps each plane of the buffer into the client's address space so it can be
   // written to by the CPU. This call may block, for instance if the GPU needs
   // to finish accessing the buffer or if CPU caches need to be synchronized.
   // Returns false on failure.
   virtual bool Map() = 0;
 
   // Returns a pointer to the memory address of a plane. Buffer must have been
   // successfully mapped using a call to Map() before calling this function.
   virtual void* memory(size_t plane) = 0;
 
@@ skipping 31 matching lines @@
 
 // Returns an instance of |handle| which can be sent over IPC. This duplicates
 // the file-handles as appropriate, so that the IPC code take ownership of them,
 // without invalidating |handle| itself.
 GFX_EXPORT GpuMemoryBufferHandle
 CloneHandleForIPC(const GpuMemoryBufferHandle& handle);
 
 }  // namespace gfx
 
 #endif  // UI_GFX_GPU_MEMORY_BUFFER_H_