[Mojo Video Capture] Split OnIncomingCapturedVideoFrame() to OnNewBuffer() and OnFrameReadyInBuffer(

media/capture/video/video_frame_receiver.h

 // Copyright 2016 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 MEDIA_CAPTURE_VIDEO_VIDEO_FRAME_RECEIVER_H_
 #define MEDIA_CAPTURE_VIDEO_VIDEO_FRAME_RECEIVER_H_
 
 #include "media/capture/capture_export.h"
+#include "media/capture/mojo/video_capture_types.mojom.h"
+#include "media/capture/video/video_capture_buffer_handle.h"
 #include "media/capture/video/video_capture_device.h"
 
 namespace media {
 
 // Callback interface for VideoCaptureDeviceClient to communicate with its
 // clients.
 class CAPTURE_EXPORT VideoFrameReceiver {
  public:
   virtual ~VideoFrameReceiver(){};
 
-  virtual void OnIncomingCapturedVideoFrame(
-      media::VideoCaptureDevice::Client::Buffer buffer,
-      scoped_refptr<media::VideoFrame> frame) = 0;
-  virtual void OnError() = 0;
-  virtual void OnLog(const std::string& message) = 0;
+  // Tells the VideoFrameReceiver that the producer is going to subsequently use
+  // the provided buffer as one of possibly many for frame delivery via
+  // OnFrameReadyInBuffer(). Note, that a call to this method does not mean that
+  // the caller allows the receiver to read from or write to the buffer.
+  virtual void OnNewBufferHandle(
+      int buffer_id,
+      std::unique_ptr<VideoCaptureDevice::Client::Buffer::HandleProvider>
+          handle_provider) = 0;
+
+  // Tells the VideoFrameReceiver that a new frame is ready for consumption
+  // in the buffer with id |buffer_id| and allows it to read the data from
+  // the buffer. The producer guarantees that the buffer and its contents stay
+  // alive and unchanged until VideoFrameReceiver releases the given
+  // |buffer_read_permission|.
+  virtual void OnFrameReadyInBuffer(
+      int buffer_id,
+      int frame_feedback_id,
+      std::unique_ptr<
+          VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
+          buffer_read_permission,
+      mojom::VideoFrameInfoPtr frame_info) = 0;
 
   // Tells the VideoFrameReceiver that the producer is no longer going to use
   // the buffer with id |buffer_id| for frame delivery. This may be called even
-  // while the receiver is still consuming the buffer from a call to
-  // OnIncomingCapturedVideoFrame(). In that case, it means that the
-  // caller is asking the VideoFrameReceiver to release the buffer
-  // at its earliest convenience.
+  // while the receiver is still holding |buffer_read_permission| from a call to
+  // OnFrameReadInBuffer() for the same buffer. In that case, it means that the
+  // caller is asking the VideoFrameReceiver to release the read permission and
+  // buffer handle at its earliest convenience.
   // A producer may reuse a retired |buffer_id| immediately after this call.

[miu, 2017/02/14 00:41:27]

This sounds like the producer could write new data while a consumer is still
reading from it. But, you mean only that the ID itself might be reused, right?

[chfremer, 2017/02/14 21:15:16]

Yes, the ID would be reused with a new buffer, not the old one. I updated the
comment to make it more clear. Please check if the updated comment is an
improvement.

   virtual void OnBufferRetired(int buffer_id) = 0;
+
+  virtual void OnError() = 0;
+  virtual void OnLog(const std::string& message) = 0;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_CAPTURE_VIDEO_VIDEO_FRAME_RECEIVER_H_