Add gfx::GpuMemoryBuffer::shared_memory_handle()

ui/gfx/gpu_memory_buffer.h

Index: ui/gfx/gpu_memory_buffer.h
diff --git a/ui/gfx/gpu_memory_buffer.h b/ui/gfx/gpu_memory_buffer.h
index 6d23c84ddc76074fc8bd5f13af1460e6b3c70531..b38253996883646d0211b170c590ef9f9778150f 100644
--- a/ui/gfx/gpu_memory_buffer.h
+++ b/ui/gfx/gpu_memory_buffer.h
@@ -62,6 +62,10 @@ 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.