Replace SetCapturer and SetCaptureDevice by SetSource.

webrtc/api/peerconnection.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 671 matching lines @@
   // TODO(deadbeef): Support adding a track to two different senders.
   if (FindSenderForTrack(track) != senders_.end()) {
     LOG(LS_ERROR) << "Sender for track " << track->id() << " already exists.";
     return nullptr;
   }
 
   // TODO(deadbeef): Support adding a track to multiple streams.
   rtc::scoped_refptr<RtpSenderInterface> new_sender;
   if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxy::Create(
-        signaling_thread(),
+        signaling_thread(), nullptr,
         new AudioRtpSender(static_cast<AudioTrackInterface*>(track),
                            session_.get(), stats_.get()));
     if (!streams.empty()) {
       new_sender->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_audio_tracks_, new_sender->stream_id(), track->id());
     if (track_info) {
       new_sender->SetSsrc(track_info->ssrc);
     }
   } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxy::Create(
-        signaling_thread(),
+        signaling_thread(), nullptr,
         new VideoRtpSender(static_cast<VideoTrackInterface*>(track),
                            session_.get()));
     if (!streams.empty()) {
       new_sender->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_video_tracks_, new_sender->stream_id(), track->id());
     if (track_info) {
       new_sender->SetSsrc(track_info->ssrc);
     }
@@ skipping 36 matching lines @@
     LOG(LS_ERROR) << "CreateDtmfSender is called with a non local audio track.";
     return NULL;
   }
 
   rtc::scoped_refptr<DtmfSenderInterface> sender(
       DtmfSender::Create(track, signaling_thread(), session_.get()));
   if (!sender.get()) {
     LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
     return NULL;
   }
-  return DtmfSenderProxy::Create(signaling_thread(), sender.get());
+  return DtmfSenderProxy::Create(signaling_thread(), nullptr, sender.get());
 }
 
 rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
     const std::string& kind,
     const std::string& stream_id) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateSender");
   rtc::scoped_refptr<RtpSenderInterface> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxy::Create(
-        signaling_thread(), new AudioRtpSender(session_.get(), stats_.get()));
+        signaling_thread(), nullptr,
+        new AudioRtpSender(session_.get(), stats_.get()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
-    new_sender = RtpSenderProxy::Create(signaling_thread(),
+    new_sender = RtpSenderProxy::Create(signaling_thread(), nullptr,
                                         new VideoRtpSender(session_.get()));
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return new_sender;
   }
   if (!stream_id.empty()) {
     new_sender->set_stream_id(stream_id);
   }
   senders_.push_back(new_sender);
   return new_sender;
@@ skipping 59 matching lines @@
   if (!channel.get()) {
     return nullptr;
   }
 
   // Trigger the onRenegotiationNeeded event for every new RTP DataChannel, or
   // the first SCTP DataChannel.
   if (session_->data_channel_type() == cricket::DCT_RTP || first_datachannel) {
     observer_->OnRenegotiationNeeded();
   }
 
-  return DataChannelProxy::Create(signaling_thread(), channel.get());
+  return DataChannelProxy::Create(signaling_thread(), nullptr, channel.get());
 }
 
 void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer,
                                  const MediaConstraintsInterface* constraints) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateOffer");
   if (!VERIFY(observer != nullptr)) {
     LOG(LS_ERROR) << "CreateOffer - observer is NULL.";
     return;
   }
   RTCOfferAnswerOptions options;
@@ skipping 411 matching lines @@
     default:
       RTC_DCHECK(false && "Not implemented");
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
   receivers_.push_back(RtpReceiverProxy::Create(
-      signaling_thread(),
+      signaling_thread(), nullptr,
       new AudioRtpReceiver(stream, track_id, ssrc, session_.get())));
 }
 
 void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
   receivers_.push_back(RtpReceiverProxy::Create(
-      signaling_thread(),
+      signaling_thread(), nullptr,
       new VideoRtpReceiver(stream, track_id, factory_->worker_thread(), ssrc,
                            session_.get())));
 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
 void PeerConnection::DestroyReceiver(const std::string& track_id) {
   auto it = FindReceiverForTrack(track_id);
   if (it == receivers_.end()) {
     LOG(LS_WARNING) << "RtpReceiver for track with id " << track_id
@@ skipping 74 matching lines @@
   auto sender = FindSenderForTrack(track);
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
-      signaling_thread(),
+      signaling_thread(), nullptr,
       new AudioRtpSender(track, stream->label(), session_.get(), stats_.get()));
   senders_.push_back(new_sender);
   // If the sender has already been configured in SDP, we call SetSsrc,
   // which will connect the sender to the underlying transport. This can
   // occur if a local session description that contains the ID of the sender
   // is set before AddStream is called. It can also occur if the local
   // session description is not changed and RemoveStream is called, and
   // later AddStream is called again with the same stream.
   const TrackInfo* track_info =
       FindTrackInfo(local_audio_tracks_, stream->label(), track->id());
@@ skipping 21 matching lines @@
   auto sender = FindSenderForTrack(track);
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
-      signaling_thread(),
+      signaling_thread(), nullptr,
       new VideoRtpSender(track, stream->label(), session_.get()));
   senders_.push_back(new_sender);
   const TrackInfo* track_info =
       FindTrackInfo(local_video_tracks_, stream->label(), track->id());
   if (track_info) {
     new_sender->SetSsrc(track_info->ssrc);
   }
 }
 
 void PeerConnection::OnVideoTrackRemoved(VideoTrackInterface* track,
@@ skipping 150 matching lines @@
     // The sync_label is the MediaStream label and the |stream.id| is the
     // track id.
     const std::string& stream_label = params.sync_label;
     const std::string& track_id = params.id;
     uint32_t ssrc = params.first_ssrc();
 
     rtc::scoped_refptr<MediaStreamInterface> stream =
         remote_streams_->find(stream_label);
     if (!stream) {
       // This is a new MediaStream. Create a new remote MediaStream.
-      stream = MediaStreamProxy::Create(rtc::Thread::Current(),
+      stream = MediaStreamProxy::Create(rtc::Thread::Current(), nullptr,
                                         MediaStream::Create(stream_label));
       remote_streams_->AddStream(stream);
       new_streams->AddStream(stream);
     }
 
     const TrackInfo* track_info =
         FindTrackInfo(*current_tracks, stream_label, track_id);
     if (!track_info) {
       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
       OnRemoteTrackSeen(stream_label, track_id, ssrc, media_type);
     }
   }
 
   // Add default track if necessary.
   if (default_track_needed) {
     rtc::scoped_refptr<MediaStreamInterface> default_stream =
         remote_streams_->find(kDefaultStreamLabel);
     if (!default_stream) {
       // Create the new default MediaStream.
       default_stream = MediaStreamProxy::Create(
-          rtc::Thread::Current(), MediaStream::Create(kDefaultStreamLabel));
+          rtc::Thread::Current(), nullptr,
+          MediaStream::Create(kDefaultStreamLabel));
       remote_streams_->AddStream(default_stream);
       new_streams->AddStream(default_stream);
     }
     std::string default_track_id = (media_type == cricket::MEDIA_TYPE_AUDIO)
                                        ? kDefaultAudioTrackLabel
                                        : kDefaultVideoTrackLabel;
     const TrackInfo* default_track_info =
         FindTrackInfo(*current_tracks, kDefaultStreamLabel, default_track_id);
     if (!default_track_info) {
       current_tracks->push_back(
@@ skipping 224 matching lines @@
                                                 uint32_t remote_ssrc) {
   rtc::scoped_refptr<DataChannel> channel(
       InternalCreateDataChannel(label, nullptr));
   if (!channel.get()) {
     LOG(LS_WARNING) << "Remote peer requested a DataChannel but"
                     << "CreateDataChannel failed.";
     return;
   }
   channel->SetReceiveSsrc(remote_ssrc);
   observer_->OnDataChannel(
-      DataChannelProxy::Create(signaling_thread(), channel));
+      DataChannelProxy::Create(signaling_thread(), nullptr, channel));
 }
 
 rtc::scoped_refptr<DataChannel> PeerConnection::InternalCreateDataChannel(
     const std::string& label,
     const InternalDataChannelInit* config) {
   if (IsClosed()) {
     return nullptr;
   }
   if (session_->data_channel_type() == cricket::DCT_NONE) {
     LOG(LS_ERROR)
@@ skipping 110 matching lines @@
     const std::string& label,
     const InternalDataChannelInit& config) {
   rtc::scoped_refptr<DataChannel> channel(
       InternalCreateDataChannel(label, &config));
   if (!channel.get()) {
     LOG(LS_ERROR) << "Failed to create DataChannel from the OPEN message.";
     return;
   }
 
   observer_->OnDataChannel(
-      DataChannelProxy::Create(signaling_thread(), channel));
+      DataChannelProxy::Create(signaling_thread(), nullptr, channel));
 }
 
 RtpSenderInterface* PeerConnection::FindSenderById(const std::string& id) {
   auto it =
       std::find_if(senders_.begin(), senders_.end(),
                    [id](const rtc::scoped_refptr<RtpSenderInterface>& sender) {
                      return sender->id() == id;
                    });
   return it != senders_.end() ? it->get() : nullptr;
 }
@@ skipping 48 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc