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

content/browser/renderer_host/media/video_capture_controller.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.
 //
 // VideoCaptureController is the glue between a VideoCaptureDevice and all
 // VideoCaptureHosts that have connected to it. A controller exists on behalf of
 // one (and only one) VideoCaptureDevice; both are owned by the
 // VideoCaptureManager.
 //
 // The VideoCaptureController is responsible for:
@@ skipping 116 matching lines @@
   const media::VideoCaptureFormat& GetVideoCaptureFormat() const;
 
   bool has_received_frames() const { return has_received_frames_; }
 
   // Implementation of media::VideoFrameReceiver interface:
   void OnIncomingCapturedVideoFrame(
       media::VideoCaptureDevice::Client::Buffer buffer,
       scoped_refptr<media::VideoFrame> frame) override;
   void OnError() override;
   void OnLog(const std::string& message) override;
-  void OnBufferDestroyed(int buffer_id_to_drop) override;
+  void OnBufferRetired(int buffer_id) override;
 
  private:
   struct ControllerClient;
   typedef std::list<std::unique_ptr<ControllerClient>> ControllerClients;
 
-  class BufferState {
+  class BufferContext {
    public:
-    explicit BufferState(
+    explicit BufferContext(

[mcasas, 2017/02/03 23:24:22]

nit: Doesn't need to be explicit since it has > 1 argument.

[chfremer, 2017/02/06 18:16:35]

Done.

+        int buffer_context_id,
         int buffer_id,
-        int frame_feedback_id,
         media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer,
         media::FrameBufferPool* frame_buffer_pool);
-    ~BufferState();
-    BufferState(const BufferState& other);
+    ~BufferContext();
+    BufferContext(const BufferContext& other);
+    BufferContext& operator=(const BufferContext& other);
+    int buffer_context_id() const { return buffer_context_id_; }
+    int buffer_id() const { return buffer_id_; }
+    bool is_retired() const { return is_retired_; }
+    void set_is_retired() { is_retired_ = true; }
+    void set_frame_feedback_id(int id) { frame_feedback_id_ = id; }
+    void set_consumer_feedback_observer(
+        media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer) {
+      consumer_feedback_observer_ = consumer_feedback_observer;
+    }
+    void set_frame_buffer_pool(media::FrameBufferPool* frame_buffer_pool) {
+      frame_buffer_pool_ = frame_buffer_pool;
+    }
     void RecordConsumerUtilization(double utilization);
     void IncreaseConsumerCount();
     void DecreaseConsumerCount();
     bool HasZeroConsumerHoldCount();
-    void SetFrameFeedbackId(int id);
-    void SetConsumerFeedbackObserver(
-        media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer);
-    void SetFrameBufferPool(media::FrameBufferPool* frame_buffer_pool);
 
    private:
-    const int buffer_id_;
-    int frame_feedback_id_;
+    int buffer_context_id_;

[mcasas, 2017/02/03 23:24:22]

Can be const

[chfremer, 2017/02/06 18:16:35]

Assignment operator is needed for usage in std::vector<> here, which prevents
the use of const.

+    int buffer_id_;
+    bool is_retired_ = false;
+    int frame_feedback_id_ = 0;
     media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer_;
     media::FrameBufferPool* frame_buffer_pool_;
     double max_consumer_utilization_;
-    int consumer_hold_count_;
+    int consumer_hold_count_ = 0;

[mcasas, 2017/02/03 23:24:22]

In general try to initialize only once, and by
preference in the constructor, so all the default
values are together.

[chfremer, 2017/02/06 18:16:35]

Done.

   };
 
   // Find a client of |id| and |handler| in |clients|.
   ControllerClient* FindClient(VideoCaptureControllerID id,
                                VideoCaptureControllerEventHandler* handler,
                                const ControllerClients& clients);
 
   // Find a client of |session_id| in |clients|.
   ControllerClient* FindClient(int session_id,
                                const ControllerClients& clients);
 
+  std::vector<BufferContext>::iterator FindBufferContextFromBufferContextId(
+      int buffer_context_id);
+  std::vector<BufferContext>::iterator FindUnretiredBufferContextFromBufferId(
+      int buffer_id);
+
+  void OnClientFinishedConsumingBuffer(ControllerClient* client,
+                                       int buffer_id,
+                                       double consumer_resource_utilization);
+  void ReleaseBufferContext(
+      const std::vector<BufferContext>::iterator& buffer_state_iter);

[mcasas, 2017/02/03 23:24:22]

Perhaps we could make a public

using BuferContexts = std::vector<BufferContext>;

[chfremer, 2017/02/06 18:16:35]

To be honest, I am not currently a fan of the "usings" aliases for collection
types. The reason is that I always need to know the type (interface) of the
collection being used in order to work with it. A type alias whose name is just
the plural form of the element type does not contain this information, so I have
to go hunt down the alias declaration every time.

+
   std::unique_ptr<media::FrameBufferPool> frame_buffer_pool_;
 
   std::unique_ptr<media::VideoFrameConsumerFeedbackObserver>
       consumer_feedback_observer_;
 
-  std::map<int, BufferState> buffer_id_to_state_map_;
+  std::vector<BufferContext> buffer_contexts_;
 
   // All clients served by this controller.
   ControllerClients controller_clients_;
 
   // Takes on only the states 'STARTED' and 'ERROR'. 'ERROR' is an absorbing
   // state which stops the flow of data to clients.
   VideoCaptureState state_;
 
+  int next_buffer_context_id_ = 0;
+
   // True if the controller has received a video frame from the device.
   bool has_received_frames_;
 
   media::VideoCaptureFormat video_capture_format_;
 
   base::WeakPtrFactory<VideoCaptureController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureController);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_