Replace scoped_ptr with unique_ptr in webrtc/api/

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 508 matching lines @@
   for (const auto& sender : senders_) {
     sender->Stop();
   }
   for (const auto& receiver : receivers_) {
     receiver->Stop();
   }
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
-    rtc::scoped_ptr<cricket::PortAllocator> allocator,
-    rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+    std::unique_ptr<cricket::PortAllocator> allocator,
+    std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     PeerConnectionObserver* observer) {
   TRACE_EVENT0("webrtc", "PeerConnection::Initialize");
   RTC_DCHECK(observer != nullptr);
   if (!observer) {
     return false;
   }
   observer_ = observer;
 
   port_allocator_ = std::move(allocator);
 
@@ skipping 80 matching lines @@
   local_streams_->AddStream(local_stream);
   MediaStreamObserver* observer = new MediaStreamObserver(local_stream);
   observer->SignalAudioTrackAdded.connect(this,
                                           &PeerConnection::OnAudioTrackAdded);
   observer->SignalAudioTrackRemoved.connect(
       this, &PeerConnection::OnAudioTrackRemoved);
   observer->SignalVideoTrackAdded.connect(this,
                                           &PeerConnection::OnVideoTrackAdded);
   observer->SignalVideoTrackRemoved.connect(
       this, &PeerConnection::OnVideoTrackRemoved);
-  stream_observers_.push_back(rtc::scoped_ptr<MediaStreamObserver>(observer));
+  stream_observers_.push_back(std::unique_ptr<MediaStreamObserver>(observer));
 
   for (const auto& track : local_stream->GetAudioTracks()) {
     OnAudioTrackAdded(track.get(), local_stream);
   }
   for (const auto& track : local_stream->GetVideoTracks()) {
     OnVideoTrackAdded(track.get(), local_stream);
   }
 
   stats_->AddStream(local_stream);
   observer_->OnRenegotiationNeeded();
   return true;
 }
 
 void PeerConnection::RemoveStream(MediaStreamInterface* local_stream) {
   TRACE_EVENT0("webrtc", "PeerConnection::RemoveStream");
   for (const auto& track : local_stream->GetAudioTracks()) {
     OnAudioTrackRemoved(track.get(), local_stream);
   }
   for (const auto& track : local_stream->GetVideoTracks()) {
     OnVideoTrackRemoved(track.get(), local_stream);
   }
 
   local_streams_->RemoveStream(local_stream);
   stream_observers_.erase(
       std::remove_if(
           stream_observers_.begin(), stream_observers_.end(),
-          [local_stream](const rtc::scoped_ptr<MediaStreamObserver>& observer) {
+          [local_stream](const std::unique_ptr<MediaStreamObserver>& observer) {
             return observer->stream()->label().compare(local_stream->label()) ==
                    0;
           }),
       stream_observers_.end());
 
   if (IsClosed()) {
     return;
   }
   observer_->OnRenegotiationNeeded();
 }
@@ skipping 159 matching lines @@
   return ice_gathering_state_;
 }
 
 rtc::scoped_refptr<DataChannelInterface>
 PeerConnection::CreateDataChannel(
     const std::string& label,
     const DataChannelInit* config) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateDataChannel");
   bool first_datachannel = !HasDataChannels();
 
-  rtc::scoped_ptr<InternalDataChannelInit> internal_config;
+  std::unique_ptr<InternalDataChannelInit> internal_config;
   if (config) {
     internal_config.reset(new InternalDataChannelInit(*config));
   }
   rtc::scoped_refptr<DataChannelInterface> channel(
       InternalCreateDataChannel(label, internal_config.get()));
   if (!channel.get()) {
     return nullptr;
   }
 
   // Trigger the onRenegotiationNeeded event for every new RTP DataChannel, or
@@ skipping 1209 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