Video Capture: Allow suspension of individual devices.

content/renderer/media/media_stream_video_source.h

 // Copyright 2014 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 CONTENT_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 53 matching lines @@
   static MediaStreamVideoSource* GetVideoSource(
       const blink::WebMediaStreamSource& source);
 
   // Puts |track| in the registered tracks list.
   void AddTrack(MediaStreamVideoTrack* track,
                 const VideoCaptureDeliverFrameCB& frame_callback,
                 const blink::WebMediaConstraints& constraints,
                 const ConstraintsCallback& callback);
   void RemoveTrack(MediaStreamVideoTrack* track);
 
+  // Called by |track| to notify the source whether it has any paths to a
+  // consuming endpoint.
+  void UpdateHasConsumers(MediaStreamVideoTrack* track, bool has_consumers);

[chfremer, 2016/09/27 00:54:59]

As a reader unfamiliar with this class, I am confused about the two methods
UpdateHasConsumers() and SetHasConsumers() that based on their name to serve the
same purpose. The comment saying that one of the methods is called by someone
particular (|track|) seems to indicate that different clients of this class
interface with different subsets of the public methods. 

If that is the case, it may be helpful to expose separate interfaces for these
different types of clients in order to make the interactions between the
instances more clear.

Could it be that SetHasConsumers() is only called by the implementation of
UpdateHasConsumers() itself?
If that is the case, does it need to be part of this interface or could it
become a private methods?

[miu, 2016/09/27 23:42:23]

Done. Made the SetXXX() methods protected, renamed them to OnXXX(), and modified
method comments to better indicate they are meant to be optionally overridden by
subclasses.

+
   void UpdateCapturingLinkSecure(MediaStreamVideoTrack* track, bool is_secure);
 
   // Request underlying source to capture a new frame.
   virtual void RequestRefreshFrame() {}
 
+  // Notify the underlying source whether there are one or more consumers
+  // present. When none are present, the source can stop delivering frames,
+  // giving it the option of running in an "idle" state to minimize resource
+  // usage.
+  virtual void SetHasConsumers(bool has_consumers) {}
+
   // Notify underlying source if the capturing link is secure.
   virtual void SetCapturingLinkSecured(bool is_secure) {}
 
   // Returns the task runner where video frames will be delivered on.
   base::SingleThreadTaskRunner* io_task_runner() const;
 
   const media::VideoCaptureFormat* GetCurrentFormat() const;
 
   base::WeakPtr<MediaStreamVideoSource> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
@@ skipping 87 matching lines @@
   std::vector<TrackDescriptor> track_descriptors_;
 
   media::VideoCaptureFormats supported_formats_;
 
   // |track_adapter_| delivers video frames to the tracks on the IO-thread.
   const scoped_refptr<VideoTrackAdapter> track_adapter_;
 
   // Tracks that currently are connected to this source.
   std::vector<MediaStreamVideoTrack*> tracks_;
 
+  // Tracks that have no paths to a consuming endpoint, and so do not need
+  // frames delivered from the source.
+  std::vector<MediaStreamVideoTrack*> suspended_tracks_;
+
   // This is used for tracking if all connected video sinks are secure.
   SecureDisplayLinkTracker<MediaStreamVideoTrack> secure_tracker_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaStreamVideoSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamVideoSource);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_