Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/webrtcsession.h

 /*
  *  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 135 matching lines @@
   // These are const to allow them to be called from const methods.
   rtc::Thread* signaling_thread() const { return signaling_thread_; }
   rtc::Thread* worker_thread() const { return worker_thread_; }
   cricket::PortAllocator* port_allocator() const { return port_allocator_; }
 
   // The ID of this session.
   const std::string& id() const { return sid_; }
 
   bool Initialize(
       const PeerConnectionFactoryInterface::Options& options,
-      rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+      std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
       const PeerConnectionInterface::RTCConfiguration& rtc_configuration);
   // Deletes the voice, video and data channel and changes the session state
   // to STATE_CLOSED.
   void Close();
 
   // Returns true if we were the initial offerer.
   bool initial_offerer() const { return initial_offerer_; }
 
   // Returns the current state of the session. See the enum above for details.
   // Each time the state changes, we will fire this signal.
@@ skipping 70 matching lines @@
   virtual bool GetRemoteTrackIdBySsrc(uint32_t ssrc, std::string* track_id);
 
   // AudioMediaProviderInterface implementation.
   void SetAudioPlayout(uint32_t ssrc, bool enable) override;
   void SetAudioSend(uint32_t ssrc,
                     bool enable,
                     const cricket::AudioOptions& options,
                     cricket::AudioSource* source) override;
   void SetAudioPlayoutVolume(uint32_t ssrc, double volume) override;
   void SetRawAudioSink(uint32_t ssrc,
-                       rtc::scoped_ptr<AudioSinkInterface> sink) override;
+                       std::unique_ptr<AudioSinkInterface> sink) override;
 
   RtpParameters GetAudioRtpParameters(uint32_t ssrc) const override;
   bool SetAudioRtpParameters(uint32_t ssrc,
                              const RtpParameters& parameters) override;
 
   // Implements VideoMediaProviderInterface.
   bool SetSource(
       uint32_t ssrc,
       rtc::VideoSourceInterface<cricket::VideoFrame>* source) override;
   void SetVideoPlayout(
@@ skipping 214 matching lines @@
   rtc::Thread* const worker_thread_;
   cricket::PortAllocator* const port_allocator_;
 
   State state_ = STATE_INIT;
   Error error_ = ERROR_NONE;
   std::string error_desc_;
 
   const std::string sid_;
   bool initial_offerer_ = false;
 
-  rtc::scoped_ptr<cricket::TransportController> transport_controller_;
+  std::unique_ptr<cricket::TransportController> transport_controller_;
   MediaControllerInterface* media_controller_;
-  rtc::scoped_ptr<cricket::VoiceChannel> voice_channel_;
-  rtc::scoped_ptr<cricket::VideoChannel> video_channel_;
-  rtc::scoped_ptr<cricket::DataChannel> data_channel_;
+  std::unique_ptr<cricket::VoiceChannel> voice_channel_;
+  std::unique_ptr<cricket::VideoChannel> video_channel_;
+  std::unique_ptr<cricket::DataChannel> data_channel_;
   cricket::ChannelManager* channel_manager_;
   IceObserver* ice_observer_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
   bool ice_connection_receiving_;
-  rtc::scoped_ptr<SessionDescriptionInterface> local_desc_;
-  rtc::scoped_ptr<SessionDescriptionInterface> remote_desc_;
+  std::unique_ptr<SessionDescriptionInterface> local_desc_;
+  std::unique_ptr<SessionDescriptionInterface> remote_desc_;
   // If the remote peer is using a older version of implementation.
   bool older_version_remote_peer_;
   bool dtls_enabled_;
   // Specifies which kind of data channel is allowed. This is controlled
   // by the chrome command-line flag and constraints:
   // 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
   // constraint kEnableDtlsSrtp is true, and constaint kEnableRtpDataChannels is
   // not set or false, SCTP is allowed (DCT_SCTP);
   // 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
   // 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
   cricket::DataChannelType data_channel_type_;
   // List of content names for which the remote side triggered an ICE restart.
   std::set<std::string> pending_ice_restarts_;
 
-  rtc::scoped_ptr<WebRtcSessionDescriptionFactory>
-      webrtc_session_desc_factory_;
+  std::unique_ptr<WebRtcSessionDescriptionFactory> webrtc_session_desc_factory_;
 
   // Member variables for caching global options.
   cricket::AudioOptions audio_options_;
   cricket::VideoOptions video_options_;
   MetricsObserverInterface* metrics_observer_;
 
   // Declares the bundle policy for the WebRTCSession.
   PeerConnectionInterface::BundlePolicy bundle_policy_;
 
   // Declares the RTCP mux policy for the WebRTCSession.
   PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_WEBRTCSESSION_H_