[Mojo Video Capture] Retire buffers when Android Chromium goes to the background

media/capture/video/video_capture_device_client.cc

 // Copyright 2015 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.
 
 #include "media/capture/video/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
     : receiver_(std::move(receiver)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory),
       external_jpeg_decoder_initialized_(false),
       buffer_pool_(std::move(buffer_pool)),
       last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
+
+  for (int buffer_id : buffer_ids_known_by_receiver_)
+    receiver_->OnBufferRetired(buffer_id);
 }
 
 // static
 VideoCaptureDevice::Client::Buffer VideoCaptureDeviceClient::MakeBufferStruct(
     scoped_refptr<VideoCaptureBufferPool> buffer_pool,
     int buffer_id,
     int frame_feedback_id) {
   return Buffer(
       buffer_id, frame_feedback_id,
       base::MakeUnique<BufferPoolBufferHandleProvider>(buffer_pool, buffer_id),
@@ skipping 178 matching lines @@
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 media::VideoCaptureDevice::Client::Buffer
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage pixel_storage,
     int frame_feedback_id) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   DCHECK_GT(frame_size.width(), 0);
   DCHECK_GT(frame_size.height(), 0);
   DCHECK(IsFormatSupported(pixel_format));
 
   int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
   const int buffer_id =
       buffer_pool_->ReserveForProducer(frame_size, pixel_format, pixel_storage,
                                        frame_feedback_id, &buffer_id_to_drop);
-  if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId)
-    receiver_->OnBufferDestroyed(buffer_id_to_drop);
+  if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
+    // |buffer_pool_| has decided to release a buffer. Notify receiver in case
+    // the buffer has already been shared with it.
+    auto entry_iter =
+        std::find(buffer_ids_known_by_receiver_.begin(),
+                  buffer_ids_known_by_receiver_.end(), buffer_id_to_drop);
+    if (entry_iter != buffer_ids_known_by_receiver_.end()) {
+      buffer_ids_known_by_receiver_.erase(entry_iter);
+      receiver_->OnBufferRetired(buffer_id_to_drop);
+    }
+  }
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
   return MakeBufferStruct(buffer_pool_, buffer_id, frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   OnIncomingCapturedBufferExt(std::move(buffer), format, reference_time,
                               timestamp, gfx::Rect(format.frame_size),
                               VideoFrameMetadata());
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     gfx::Rect visible_rect,
     const VideoFrameMetadata& additional_metadata) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
+
+  if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer.id()))
+    buffer_ids_known_by_receiver_.push_back(buffer.id());
+
   auto buffer_access = buffer.handle_provider()->GetHandleForInProcessAccess();
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
           format.pixel_format,               // format
           format.frame_size,                 // coded_size
           visible_rect,                      // visible_rect
           format.frame_size,                 // natural_size
           buffer_access->data(),             // data
           buffer_access->mapped_size(),      // data_size
           base::SharedMemory::NULLHandle(),  // handle
           0u,                                // shared_memory_offset
           timestamp);                        // timestamp
   frame->metadata()->MergeMetadataFrom(&additional_metadata);
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                format.frame_rate);
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   reference_time);
 
   receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
 }
 
 media::VideoCaptureDevice::Client::Buffer
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage,
     int new_frame_feedback_id) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   const int buffer_id =
       buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
   return MakeBufferStruct(buffer_pool_, buffer_id, new_frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
@@ skipping 60 matching lines @@
   auto buffer_access = buffer.handle_provider()->GetHandleForInProcessAccess();
   memcpy(buffer_access->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(format.frame_size, format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media