VideoCapture: add support for GpuMemoryBuffer allocation and lifetime mgmt in VideoCaptureBufferPool

media/video/capture/video_capture_device.h

 // 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.
 //
 // VideoCaptureDevice is the abstract base class for realizing video capture
 // device support in Chromium. It provides the interface for OS dependent
 // implementations.
 // The class is created and functions are invoked on a thread owned by
 // VideoCaptureManager. Capturing is done on other threads, depending on the OS
 // specific implementation.
 
 #ifndef MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_H_
 #define MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_H_
 
 #include <list>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "media/base/media_export.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 
 namespace media {
 
 class MEDIA_EXPORT VideoCaptureDevice {
  public:
   // Represents a capture device name and ID.
   // You should not create an instance of this class directly by e.g. setting
   // various properties directly.  Instead use
   // VideoCaptureDevice::GetDeviceNames to do this for you and if you need to
   // cache your own copy of a name, you can do so via the copy constructor.
@@ skipping 155 matching lines @@
    // Interface defining the methods that clients of VideoCapture must have. It
    // is actually two-in-one: clients may implement OnIncomingCapturedData() or
    // ReserveOutputBuffer() + OnIncomingCapturedVideoFrame(), or all of them.
    // All clients must implement OnError().
    class MEDIA_EXPORT Client {
    public:
     // Memory buffer returned by Client::ReserveOutputBuffer().
     class Buffer : public base::RefCountedThreadSafe<Buffer> {
      public:
       virtual int id() const = 0;
-      virtual void* data() const = 0;
       virtual size_t size() const = 0;
+      virtual scoped_ptr<DataHandle> GetDataHandle() = 0;

[miu, 2015/04/15 19:12:40]

Having a second level of acquiring a buffer seems overly-complicated to me.  All
callers of ReserveOutputBuffer() will just immediately call GetDataHandle(), so
can we make a Buffer already provide a pointer to mapped memory?  The memory
could be unnmapped when the Buffer is passed back to the VCDClient.

I see that Buffers are ref-counted.  Would it be possible to get rid of the
ref-counting, and instead pass ownership to the caller of ReserveOutputBuffer(),
then pass ownership back to the VCDClient when calling OnIncomingCapturedXXX()? 
When ReserveOutputBuffer() is called, VCDClient can map the memory before
returning.  When OnIncomingCapturedXXX() is called, the memory can be unmapped.

Since Buffer pooling is a concern, you may want to make sure that Buffers
destroyed external to the VCDClient don't actually destroy their underlying
memory, but just return it to the pool.

WDYT of these ideas?

[mcasas, 2015/04/16 03:11:22]

SG, with that assumption in mind and after double checking
with GMB folks, it seems reasonable that the Buffer's 
underlying BufferHandle stays Map()ed for the duration of
the client loop ReserveOutputBuffer()-OnIncomingCapturedX().

+      virtual ClientBuffer AsClientBuffer() = 0;
 
      protected:
       friend class base::RefCountedThreadSafe<Buffer>;
       virtual ~Buffer() {}
     };
 
     virtual ~Client() {}
 
     // Captured a new video frame, data for which is pointed to by |data|.
     //
@@ skipping 27 matching lines @@
     // zero; in which case the returned Buffer does not guarantee memory
     // backing, but functions as a reservation for external input for the
     // purposes of buffer throttling.
     //
     // The output buffer stays reserved for use until the Buffer object is
     // destroyed.
     virtual scoped_refptr<Buffer> ReserveOutputBuffer(
         media::VideoPixelFormat format,
         const gfx::Size& dimensions) = 0;
 
-    // Captured a new video frame, held in |frame|.
+    // Captured new video data, held in |frame| or |buffer|, respectively for
+    // OnIncomingCapturedVideoFrame() and  OnIncomingCapturedBuffer().
     //
-    // As the frame is backed by a reservation returned by
+    // In both cases, as the frame is backed by a reservation returned by
     // ReserveOutputBuffer(), delivery is guaranteed and will require no
     // additional copies in the browser process.
+    virtual void OnIncomingCapturedBuffer(
+        const scoped_refptr<Buffer>& buffer,
+        const VideoCaptureFormat& frame_format,
+        const base::TimeTicks& timestamp) = 0;
     virtual void OnIncomingCapturedVideoFrame(
         const scoped_refptr<Buffer>& buffer,
-        const scoped_refptr<media::VideoFrame>& frame,
+        const scoped_refptr<VideoFrame>& frame,
         const base::TimeTicks& timestamp) = 0;
 
     // An error has occurred that cannot be handled and VideoCaptureDevice must
     // be StopAndDeAllocate()-ed. |reason| is a text description of the error.
     virtual void OnError(const std::string& reason) = 0;
 
     // VideoCaptureDevice requests the |message| to be logged.
     virtual void OnLog(const std::string& message) {}
   };
 
@@ skipping 23 matching lines @@
   int GetPowerLineFrequencyForLocation() const;
 
  protected:
   static const int kPowerLine50Hz = 50;
   static const int kPowerLine60Hz = 60;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_VIDEO_CAPTURE_VIDEO_CAPTURE_DEVICE_H_