Report if video capturing meets output protection requirement.

content/renderer/media/media_stream_video_source.cc

 // 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.
 
 #include "content/renderer/media/media_stream_video_source.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 299 matching lines @@
   return std::find(kSupportedConstraints,
                    kSupportedConstraints + arraysize(kSupportedConstraints),
                    name) !=
          kSupportedConstraints + arraysize(kSupportedConstraints);
 }
 
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW),
       track_adapter_(
           new VideoTrackAdapter(ChildProcess::current()->io_task_runner())),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
   DCHECK(CalledOnValidThread());
 }
 
 void MediaStreamVideoSource::AddTrack(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!constraints.isNull());
   DCHECK(std::find(tracks_.begin(), tracks_.end(), track) == tracks_.end());
   tracks_.push_back(track);
+  secure_tracker_.Add(track, true);
 
   track_descriptors_.push_back(
       TrackDescriptor(track, frame_callback, constraints, callback));
 
   switch (state_) {
     case NEW: {
       // Tab capture and Screen capture needs the maximum requested height
       // and width to decide on the resolution.
       int max_requested_width = 0;
       if (constraints.basic().width.hasMax())
@@ skipping 30 matching lines @@
     }
   }
 }
 
 void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
   DCHECK(CalledOnValidThread());
   std::vector<MediaStreamVideoTrack*>::iterator it =
       std::find(tracks_.begin(), tracks_.end(), video_track);
   DCHECK(it != tracks_.end());
   tracks_.erase(it);
+  secure_tracker_.Remove(video_track);
 
   for (std::vector<TrackDescriptor>::iterator it = track_descriptors_.begin();
        it != track_descriptors_.end(); ++it) {
     if (it->track == video_track) {
       track_descriptors_.erase(it);
       break;
     }
   }
 
   // Call |frame_adapter_->RemoveTrack| here even if adding the track has
   // failed and |frame_adapter_->AddCallback| has not been called.
   track_adapter_->RemoveTrack(video_track);
 
   if (tracks_.empty())
     StopSource();
 }
 
+void MediaStreamVideoSource::UpdateCapturingLinkSecure(
+    MediaStreamVideoTrack* track,
+    bool is_secure) {
+  secure_tracker_.Update(track, is_secure);
+  SetCapturingLinkSecured(secure_tracker_.is_capturing_secure());
+}
+
 base::SingleThreadTaskRunner* MediaStreamVideoSource::io_task_runner() const {
   DCHECK(CalledOnValidThread());
   return track_adapter_->io_task_runner();
 }
 
 const media::VideoCaptureFormat*
     MediaStreamVideoSource::GetCurrentFormat() const {
   DCHECK(CalledOnValidThread());
   if (state_ == STARTING || state_ == STARTED)
     return &current_format_;
@@ skipping 175 matching lines @@
       callback(callback) {
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     const TrackDescriptor& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content