content: Add GpuMemoryBuffer MemoryDumpProvider implementation.

content/common/gpu/client/gpu_memory_buffer_impl.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 CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_IMPL_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_IMPL_H_
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
@@ skipping 18 matching lines @@
       const gfx::Size& size,
       Format format,
       const DestructionCallback& callback);
 
   // Type-checking upcast routine. Returns an NULL on failure.
   static GpuMemoryBufferImpl* FromClientBuffer(ClientBuffer buffer);
 
   // Returns the number of planes based on the format of the buffer.
   static size_t NumberOfPlanesForGpuMemoryBufferFormat(Format format);
 
-  // Calculates the number of bytes that an implementation must use to store
-  // one row of pixel data.
-  static bool StrideInBytes(size_t width,
-                            Format format,
-                            int plane,
-                            size_t* stride_in_bytes);
-
   // Returns the subsampling factor applied to the given zero-indexed |plane| of
   // the |format| both horizontally and vertically.
   static size_t SubsamplingFactor(Format format, int plane);
 
+  // Returns the number of bytes used to store a row of the given zero-indexed
+  // |plane| of |format|.
+  // Note: This is an approximation and the exact size used by an implementation
+  // might be different.
+  static bool RowSizeInBytes(size_t width,
+                             Format format,
+                             int plane,
+                             size_t* size_in_bytes);
+
+  // Returns the number of bytes used to store all the planes of a given
+  // |format|.
+  // Note: This is an approximation and the exact size used by an implementation
+  // might be different.
+  static bool BufferSizeInBytes(const gfx::Size& size,

[Daniele Castagna, 2015/04/27 19:07:47]

What about keeping GpuMemoryBufferImplSharedMemory::BufferSizeInBytes. This
method could be GpuMemoryBufferImpl::EstimateBufferSizeInBytes and would just
call GpuMemoryBufferImplSharedMemory::BufferSizeInBytes?
It'd make explicit what's going on.

[reveman, 2015/04/27 19:30:30]

I don't think we should have the base class depend on a derived class. I should
be able to remove GpuMemoryBufferImplSharedMemory without breaking the base
class..

[Daniele Castagna, 2015/04/27 19:43:56]

With this patch there might not be an explicit code dependency but logically the
base class is still depending on a particular implementation, hence why you
moved BufferSizeInBytes from GpuMemoryBufferImplSharedMemory to
GpuMemoryBufferImpl.

I'm completely fine with this code, I was just suggesting a way to make more
explicit what's going on.

[reveman, 2015/04/27 20:28:08]

That's not the case. BufferSizeInBytes returns a minimal size for the buffer. An
implementation can chose to use this or not. The SharedMemory implementation
does but it doesn't have to. Other implementations might use more memory (hence
the comment in the memorydumpprovider implementation about adding a factory
interface if necessary).
Seems like a naming issue. Maybe MinimalBufferSizeInBytes/MinimalRowSizeInBytes
is better?

Note that "RowSize" is different from "stride" as "stride" can be negative but
"RowSize" cannot.

+                                Format format,
+                                size_t* size_in_bytes);
+
   // Overridden from gfx::GpuMemoryBuffer:
   bool IsMapped() const override;
   Format GetFormat() const override;
   ClientBuffer AsClientBuffer() override;
 
   void set_destruction_sync_point(uint32 sync_point) {
     destruction_sync_point_ = sync_point;
   }
 
  protected:
   GpuMemoryBufferImpl(gfx::GpuMemoryBufferId id,
                       const gfx::Size& size,
                       Format format,
                       const DestructionCallback& callback);
 
   const gfx::GpuMemoryBufferId id_;
   const gfx::Size size_;
   const Format format_;
   const DestructionCallback callback_;
   bool mapped_;
   uint32 destruction_sync_point_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GpuMemoryBufferImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_IMPL_H_