Mac Zero Copy Capture: Remove OnIncomingCapturedExternalBuffer access

The ScopedAccessPermission argument to OnIncomingCapturedExternalBuffer
is no longer used, now that GpuMemoryBufferTrackerMac keeps the buffer
from being reused via its gfx::ScopedInUseIOSurface. Remove the argument
and its many entrails.

Bug: 1125879
Change-Id: I58c7a74621f09a0bbb4524f55ee2a740179e14de
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2505457Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Markus Handell <handellm@google.com>
Commit-Queue: ccameron <ccameron@chromium.org>
Cr-Commit-Position: refs/heads/master@{#822541}

content/browser/media/capture/screen_capture_device_android_unittest.cc

@@ -34,10 +34,8 @@ class MockDeviceClient : public media::VideoCaptureDevice::Client {
                     base::TimeTicks reference_time,
                     base::TimeDelta timestamp,
                     int frame_feedback_id));
-  MOCK_METHOD6(OnIncomingCapturedExternalBuffer,
+  MOCK_METHOD5(OnIncomingCapturedExternalBuffer,
                void(gfx::GpuMemoryBufferHandle handle,
-                    std::unique_ptr<Buffer::ScopedAccessPermission>
-                        read_access_permission,
                     const media::VideoCaptureFormat& format,
                     const gfx::ColorSpace& color_space,
                     base::TimeTicks reference_time,

media/capture/video/chromeos/mock_video_capture_client.cc

@@ -69,7 +69,6 @@ void MockVideoCaptureClient::OnIncomingCapturedGfxBuffer(
 
 void MockVideoCaptureClient::OnIncomingCapturedExternalBuffer(
     gfx::GpuMemoryBufferHandle handle,
-    std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
     const VideoCaptureFormat& format,
     const gfx::ColorSpace& color_space,
     base::TimeTicks reference_time,

media/capture/video/chromeos/mock_video_capture_client.h

@@ -56,7 +56,6 @@ class MockVideoCaptureClient : public VideoCaptureDevice::Client {
                                    int frame_feedback_id = 0) override;
   void OnIncomingCapturedExternalBuffer(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
       const VideoCaptureFormat& format,
       const gfx::ColorSpace& color_space,
       base::TimeTicks reference_time,

media/capture/video/fuchsia/video_capture_device_fuchsia_test.cc

@@ -164,7 +164,6 @@ class TestVideoCaptureClient : public VideoCaptureDevice::Client {
   }
   void OnIncomingCapturedExternalBuffer(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
       const VideoCaptureFormat& format,
       const gfx::ColorSpace& color_space,
       base::TimeTicks reference_time,

media/capture/video/mac/test/mock_video_capture_device_avfoundation_frame_receiver_mac.h

@@ -30,9 +30,6 @@ class MockVideoCaptureDeviceAVFoundationFrameReceiver
   MOCK_METHOD(void,
               ReceiveExternalGpuMemoryBufferFrame,
               (gfx::GpuMemoryBufferHandle handle,
-               std::unique_ptr<
-                   VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-                   read_access_permission,
                const VideoCaptureFormat& frame_format,
                const gfx::ColorSpace color_space,
                base::TimeDelta timestamp),

media/capture/video/mac/video_capture_device_avfoundation_mac.mm

@@ -48,17 +48,6 @@ base::TimeDelta GetCMSampleBufferTimestamp(CMSampleBufferRef sampleBuffer) {
   return timestamp;
 }
 
-class CMSampleBufferScopedAccessPermission
-    : public media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission {
- public:
-  CMSampleBufferScopedAccessPermission(CMSampleBufferRef buffer)
-      : buffer_(buffer, base::scoped_policy::RETAIN) {}
-  ~CMSampleBufferScopedAccessPermission() override { buffer_.reset(); }
-
- private:
-  base::ScopedCFTypeRef<CMSampleBufferRef> buffer_;
-};
-
 }  // anonymous namespace
 
 namespace media {
@@ -608,7 +597,6 @@ AVCaptureDeviceFormat* FindBestCaptureFormat(
   _lock.AssertAcquired();
   _frameReceiver->ReceiveExternalGpuMemoryBufferFrame(
       std::move(handle),
-      std::make_unique<CMSampleBufferScopedAccessPermission>(sampleBuffer),
       captureFormat, colorSpace, timestamp);
   return YES;
 }

media/capture/video/mac/video_capture_device_avfoundation_protocol_mac.h

@@ -36,9 +36,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceAVFoundationFrameReceiver {
   // AVFoundation.
   virtual void ReceiveExternalGpuMemoryBufferFrame(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<
-          VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-          read_access_permission,
       const VideoCaptureFormat& frame_format,
       const gfx::ColorSpace color_space,
       base::TimeDelta timestamp) = 0;

media/capture/video/mac/video_capture_device_mac.h

@@ -82,9 +82,6 @@ class VideoCaptureDeviceMac
                     base::TimeDelta timestamp) override;
   void ReceiveExternalGpuMemoryBufferFrame(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<
-          VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-          read_access_permission,
       const VideoCaptureFormat& frame_format,
       const gfx::ColorSpace color_space,
       base::TimeDelta timestamp) override;

media/capture/video/mac/video_capture_device_mac.mm

@@ -804,8 +804,6 @@ void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
 
 void VideoCaptureDeviceMac::ReceiveExternalGpuMemoryBufferFrame(
     gfx::GpuMemoryBufferHandle handle,
-    std::unique_ptr<VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-        read_access_permission,
     const VideoCaptureFormat& format,
     const gfx::ColorSpace color_space,
     base::TimeDelta timestamp) {
@@ -816,9 +814,9 @@ void VideoCaptureDeviceMac::ReceiveExternalGpuMemoryBufferFrame(
                      ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
-  client_->OnIncomingCapturedExternalBuffer(
-      std::move(handle), std::move(read_access_permission), format, color_space,
-      base::TimeTicks::Now(), timestamp);
+  client_->OnIncomingCapturedExternalBuffer(std::move(handle), format,
+                                            color_space, base::TimeTicks::Now(),
+                                            timestamp);
 }
 
 void VideoCaptureDeviceMac::OnPhotoTaken(const uint8_t* image_data,

media/capture/video/mock_video_capture_device_client.h

@@ -35,10 +35,8 @@ class MockVideoCaptureDeviceClient : public VideoCaptureDevice::Client {
                     base::TimeTicks reference_time,
                     base::TimeDelta timestamp,
                     int frame_feedback_id));
-  MOCK_METHOD6(OnIncomingCapturedExternalBuffer,
+  MOCK_METHOD5(OnIncomingCapturedExternalBuffer,
                void(gfx::GpuMemoryBufferHandle handle,
-                    std::unique_ptr<Buffer::ScopedAccessPermission>
-                        read_access_permission,
                     const VideoCaptureFormat& format,
                     const gfx::ColorSpace& color_space,
                     base::TimeTicks reference_time,

media/capture/video/video_capture_device.h

@@ -179,11 +179,14 @@ class CAPTURE_EXPORT VideoCaptureDevice
         int frame_feedback_id = 0) = 0;
 
     // Captured a new video frame. The data for this frame is in |handle|,
-    // which is owned by the platform-specific capture device, and is kept valid
-    // by |read_access_permission|.
+    // which is owned by the platform-specific capture device. It is the
+    // responsibilty of the implementation to prevent the buffer in |handle|
+    // from being reused by the external capturer. In practice, this is used
+    // only on macOS, the external capturer maintains a CVPixelBufferPool, and
+    // gfx::ScopedInUseIOSurface is used to prevent reuse of buffers until all
+    // consumers have consumed them.
     virtual void OnIncomingCapturedExternalBuffer(
         gfx::GpuMemoryBufferHandle handle,
-        std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
         const VideoCaptureFormat& format,
         const gfx::ColorSpace& color_space,
         base::TimeTicks reference_time,

media/capture/video/video_capture_device_client.cc

@@ -466,8 +466,6 @@ void VideoCaptureDeviceClient::OnIncomingCapturedGfxBuffer(
 
 void VideoCaptureDeviceClient::OnIncomingCapturedExternalBuffer(
     gfx::GpuMemoryBufferHandle handle,
-    std::unique_ptr<VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-        scoped_access_permission_to_wrap,
     const VideoCaptureFormat& format,
     const gfx::ColorSpace& color_space,
     base::TimeTicks reference_time,

media/capture/video/video_capture_device_client.h

@@ -82,7 +82,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceClient
                                    int frame_feedback_id = 0) override;
   void OnIncomingCapturedExternalBuffer(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
       const VideoCaptureFormat& format,
       const gfx::ColorSpace& color_space,
       base::TimeTicks reference_time,

media/capture/video/win/video_capture_device_mf_win_unittest.cc

@@ -68,7 +68,6 @@ class MockClient : public VideoCaptureDevice::Client {
 
   void OnIncomingCapturedExternalBuffer(
       gfx::GpuMemoryBufferHandle handle,
-      std::unique_ptr<Buffer::ScopedAccessPermission> read_access_permission,
       const VideoCaptureFormat& format,
       const gfx::ColorSpace& color_space,
       base::TimeTicks reference_time,