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

content/browser/renderer_host/media/video_capture_manager.cc

 // 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.
 
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 160 matching lines @@
 // Phase 1: When first created (in GetOrCreateDeviceEntry()), this consists of
 // only the |video_capture_controller|. Clients can already connect to the
 // controller, but there is no |buffer_pool| or |video_capture_device| present.
 // Phase 2: When a request to "start" the entry comes in (via
 // HandleQueuedStartRequest()), |buffer_pool| is created and creation of
 // |video_capture_device| is scheduled to run asynchronously on the Device
 // Thread.
 // Phase 3: As soon as the creation of the VideoCaptureDevice is complete, this
 // newly created VideoCaptureDevice instance is connected to the
 // VideoCaptureController via SetConsumerFeedbackObserver(). Furthermore, the
-// |buffer_pool| is connected to the |video_capture_controller| as a
+// |buffer_pool| is moved to the |video_capture_controller| as a
 // FrameBufferPool via SetFrameBufferPool().
 // Phase 4: This phase can only be reached on Android. When the application goes
 // to the background, the |video_capture_device| is asynchronously stopped and
-// released on the Device Thread. The existing |buffer_pool| is kept alive, and
-// all clients of |video_capture_controller| stay connected. When the
-// application is resumed, we transition to Phase 2, except that the existing
-// |buffer_pool| get reused instead of creating a new one.
+// released on the Device Thread. When the application is resumed, we
+// transition to Phase 2.
 struct VideoCaptureManager::DeviceEntry {
  public:
   DeviceEntry(MediaStreamType stream_type,
               const std::string& id,
               const media::VideoCaptureParams& params);
   ~DeviceEntry();
   std::unique_ptr<media::VideoCaptureDevice::Client> CreateDeviceClient();
   std::unique_ptr<media::FrameBufferPool> CreateFrameBufferPool();
 
   const int serial_id;
@@ skipping 77 matching lines @@
   DCHECK(video_capture_device == nullptr);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client>
 VideoCaptureManager::DeviceEntry::CreateDeviceClient() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const int max_buffers = stream_type == MEDIA_TAB_VIDEO_CAPTURE
                               ? kMaxNumberOfBuffersForTabCapture
                               : kMaxNumberOfBuffers;
-  if (!buffer_pool) {
-    buffer_pool = new media::VideoCaptureBufferPoolImpl(
-        base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
-        max_buffers);
-  }
+  buffer_pool = new media::VideoCaptureBufferPoolImpl(
+      base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
+      max_buffers);
 
   return base::MakeUnique<media::VideoCaptureDeviceClient>(
       base::MakeUnique<VideoFrameReceiverOnIOThread>(
           video_capture_controller.GetWeakPtrForIOThread()),
       buffer_pool,
       base::Bind(
           &CreateGpuJpegDecoder,
           base::Bind(&media::VideoFrameReceiver::OnIncomingCapturedVideoFrame,
                      video_capture_controller.GetWeakPtrForIOThread())));
 }
 
 std::unique_ptr<media::FrameBufferPool>
 VideoCaptureManager::DeviceEntry::CreateFrameBufferPool() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(buffer_pool);
-  return base::MakeUnique<BufferPoolFrameBufferPool>(buffer_pool);
+  return base::MakeUnique<BufferPoolFrameBufferPool>(std::move(buffer_pool));
 }
 
 VideoCaptureManager::DeviceInfo::DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     media::VideoCaptureDeviceDescriptor descriptor)
     : descriptor(descriptor) {}
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     const VideoCaptureManager::DeviceInfo& other) = default;
@@ skipping 1025 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content