Deprecate NonThreadSafe in content/renderer/media in favor of SequenceChecker.

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 <memory>
 #include <string>
@@ skipping 315 matching lines @@
   return static_cast<MediaStreamVideoSource*>(source.GetExtraData());
 }
 
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW),
       track_adapter_(
           new VideoTrackAdapter(ChildProcess::current()->io_task_runner())),
       weak_factory_(this) {}
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void MediaStreamVideoSource::AddTrackLegacy(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(IsOldVideoConstraints());
   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_) {
@@ skipping 35 matching lines @@
       FinalizeAddTrackLegacy();
     }
   }
 }
 
 void MediaStreamVideoSource::AddTrack(
     MediaStreamVideoTrack* track,
     const VideoTrackAdapterSettings& track_adapter_settings,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const ConstraintsCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   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,
       base::MakeUnique<VideoTrackAdapterSettings>(track_adapter_settings),
       callback));
 
   switch (state_) {
@@ skipping 14 matching lines @@
     }
     case ENDED:
     case STARTED: {
       // Currently, reconfiguring the source is not supported.
       FinalizeAddTrack();
     }
   }
 }
 
 void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   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::UpdateHasConsumers(MediaStreamVideoTrack* track,
                                                 bool has_consumers) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const auto it =
       std::find(suspended_tracks_.begin(), suspended_tracks_.end(), track);
   if (has_consumers) {
     if (it != suspended_tracks_.end())
       suspended_tracks_.erase(it);
   } else {
     if (it == suspended_tracks_.end())
       suspended_tracks_.push_back(track);
   }
   OnHasConsumers(suspended_tracks_.size() < tracks_.size());
 }
 
 void MediaStreamVideoSource::UpdateCapturingLinkSecure(
     MediaStreamVideoTrack* track, bool is_secure) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   secure_tracker_.Update(track, is_secure);
   OnCapturingLinkSecured(secure_tracker_.is_capturing_secure());
 }
 
 base::SingleThreadTaskRunner* MediaStreamVideoSource::io_task_runner() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return track_adapter_->io_task_runner();
 }
 
 base::Optional<media::VideoCaptureFormat>
 MediaStreamVideoSource::GetCurrentFormat() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (IsOldVideoConstraints()) {
     if (state_ == STARTING || state_ == STARTED)
       return current_format_;
     return base::Optional<media::VideoCaptureFormat>();
   } else {
     return GetCurrentFormatImpl();
   }
 }
 
 base::Optional<media::VideoCaptureFormat>
 MediaStreamVideoSource::GetCurrentFormatImpl() const {
   return base::Optional<media::VideoCaptureFormat>();
 }
 
 void MediaStreamVideoSource::DoStopSource() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << "DoStopSource()";
   if (state_ == ENDED)
     return;
   track_adapter_->StopFrameMonitoring();
   StopSourceImpl();
   state_ = ENDED;
   SetReadyState(blink::WebMediaStreamSource::kReadyStateEnded);
 }
 
 void MediaStreamVideoSource::OnSupportedFormats(
     const media::VideoCaptureFormats& formats) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(IsOldVideoConstraints());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
   supported_formats_ = formats;
   blink::WebMediaConstraints fulfilled_constraints;
   if (!FindBestFormatWithConstraints(supported_formats_,
                                      &current_format_,
                                      &fulfilled_constraints)) {
     SetReadyState(blink::WebMediaStreamSource::kReadyStateEnded);
     DVLOG(3) << "OnSupportedFormats failed to find an usable format";
@@ skipping 10 matching lines @@
   StartSourceImpl(
       current_format_,
       fulfilled_constraints,
       base::Bind(&VideoTrackAdapter::DeliverFrameOnIO, track_adapter_));
 }
 
 bool MediaStreamVideoSource::FindBestFormatWithConstraints(
     const media::VideoCaptureFormats& formats,
     media::VideoCaptureFormat* best_format,
     blink::WebMediaConstraints* fulfilled_constraints) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << "MediaStreamVideoSource::FindBestFormatWithConstraints "
            << "with " << formats.size() << " formats";
   // Find the first track descriptor that can fulfil the constraints.
   for (const auto& track : track_descriptors_) {
     const blink::WebMediaConstraints& track_constraints = track.constraints;
 
     // If the source doesn't support capability enumeration it is still ok if
     // no mandatory constraints have been specified. That just means that
     // we will start with whatever format is native to the source.
     if (formats.empty() && !HasMandatoryConstraints(track_constraints)) {
@@ skipping 17 matching lines @@
 
     *best_format = best_format_candidate;
     DVLOG(3) << "Found a track that matches the constraints";
     return true;
   }
   DVLOG(3) << "No usable format found";
   return false;
 }
 
 void MediaStreamVideoSource::OnStartDone(MediaStreamRequestResult result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << "OnStartDone({result =" << result << "})";
   if (result == MEDIA_DEVICE_OK) {
     DCHECK_EQ(STARTING, state_);
     state_ = STARTED;
     SetReadyState(blink::WebMediaStreamSource::kReadyStateLive);
     double frame_rate =
         GetCurrentFormat() ? GetCurrentFormat()->frame_rate : 0.0;
     track_adapter_->StartFrameMonitoring(
         frame_rate, base::Bind(&MediaStreamVideoSource::SetMutedState,
                                weak_factory_.GetWeakPtr()));
   } else {
     StopSource();
   }
 
   // This object can be deleted after calling FinalizeAddTrack. See comment in
   // the header file.
   if (IsOldVideoConstraints())
     FinalizeAddTrackLegacy();
   else
     FinalizeAddTrack();
 }
 
 void MediaStreamVideoSource::FinalizeAddTrackLegacy() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(IsOldVideoConstraints());
   const media::VideoCaptureFormats formats(1, current_format_);
 
   std::vector<TrackDescriptor> track_descriptors;
   track_descriptors.swap(track_descriptors_);
   for (const auto& track : track_descriptors) {
     MediaStreamRequestResult result = MEDIA_DEVICE_OK;
     std::string unsatisfied_constraint;
 
     if (HasMandatoryConstraints(track.constraints) &&
@@ skipping 40 matching lines @@
 
     DVLOG(3) << "FinalizeAddTrackLegacy() result " << result;
 
     if (!track.callback.is_null())
       track.callback.Run(this, result,
                          blink::WebString::FromUTF8(unsatisfied_constraint));
   }
 }
 
 void MediaStreamVideoSource::FinalizeAddTrack() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!IsOldVideoConstraints());
   std::vector<TrackDescriptor> track_descriptors;
   track_descriptors.swap(track_descriptors_);
   for (const auto& track : track_descriptors) {
     MediaStreamRequestResult result = MEDIA_DEVICE_OK;
     if (state_ != STARTED)
       result = MEDIA_DEVICE_TRACK_START_FAILURE;
 
     if (result == MEDIA_DEVICE_OK) {
       track_adapter_->AddTrack(track.track, track.frame_callback,
@@ skipping 17 matching lines @@
     }
 
     if (!track.callback.is_null())
       track.callback.Run(this, result, blink::WebString());
   }
 }
 
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!Owner().IsNull())
     Owner().SetReadyState(state);
   for (auto* track : tracks_)
     track->OnReadyStateChanged(state);
 }
 
 void MediaStreamVideoSource::SetMutedState(bool muted_state) {
   DVLOG(3) << "MediaStreamVideoSource::SetMutedState state=" << muted_state;
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!Owner().IsNull()) {
     Owner().SetReadyState(muted_state
                               ? blink::WebMediaStreamSource::kReadyStateMuted
                               : blink::WebMediaStreamSource::kReadyStateLive);
   }
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
@@ skipping 21 matching lines @@
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     TrackDescriptor&& other) = default;
 MediaStreamVideoSource::TrackDescriptor&
 MediaStreamVideoSource::TrackDescriptor::operator=(
     MediaStreamVideoSource::TrackDescriptor&& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content