Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/quic/quictransportchannel.h

 /*
  *  Copyright 2016 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.
  */
 
 #ifndef WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "net/quic/quic_crypto_client_stream.h"
 #include "net/quic/quic_packet_writer.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/p2p/quic/quicconnectionhelper.h"
@@ skipping 86 matching lines @@
   // this extracts the keys negotiated during the QUIC handshake, for use
   // in external encryption such as for extracting SRTP keys.
   bool ExportKeyingMaterial(const std::string& label,
                             const uint8_t* context,
                             size_t context_len,
                             bool use_context,
                             uint8_t* result,
                             size_t result_len) override;
   // TODO(mikescarlett): Remove this method once TransportChannel does not
   // require defining it.
-  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const override {
     return nullptr;
   }
 
   // TransportChannelImpl overrides that we forward to the wrapped transport.
   void SetIceRole(IceRole role) override { channel_->SetIceRole(role); }
   IceRole GetIceRole() const override { return channel_->GetIceRole(); }
   int SetOption(rtc::Socket::Option opt, int value) override {
     return channel_->SetOption(opt, value);
   }
@@ skipping 139 matching lines @@
 
   // Everything should occur on this thread.
   rtc::Thread* worker_thread_;
   // Underlying channel which is responsible for connecting with the remote peer
   // and sending/receiving packets across the network.
   TransportChannelImpl* const channel_;
   // Connectivity state of QuicTransportChannel.
   QuicTransportState quic_state_ = QUIC_TRANSPORT_NEW;
   // QUIC session which establishes the crypto handshake and converts data
   // to/from QUIC packets.
-  rtc::scoped_ptr<QuicSession> quic_;
+  std::unique_ptr<QuicSession> quic_;
   // Non-crypto config for |quic_|.
   net::QuicConfig config_;
   // Helper for net::QuicConnection that provides timing and
   // random number generation.
   QuicConnectionHelper helper_;
   // This peer's role in the QUIC crypto handshake. SSL_CLIENT implies this peer
   // initiates the handshake, while SSL_SERVER implies the remote peer initiates
   // the handshake. This must be set before we start QUIC.
   rtc::Optional<rtc::SSLRole> ssl_role_;
   // Config for QUIC crypto client stream, used when |ssl_role_| is SSL_CLIENT.
-  rtc::scoped_ptr<net::QuicCryptoClientConfig> quic_crypto_client_config_;
+  std::unique_ptr<net::QuicCryptoClientConfig> quic_crypto_client_config_;
   // Config for QUIC crypto server stream, used when |ssl_role_| is SSL_SERVER.
-  rtc::scoped_ptr<net::QuicCryptoServerConfig> quic_crypto_server_config_;
+  std::unique_ptr<net::QuicCryptoServerConfig> quic_crypto_server_config_;
   // This peer's certificate.
   rtc::scoped_refptr<rtc::RTCCertificate> local_certificate_;
   // Fingerprint of the remote peer. This must be set before we start QUIC.
   rtc::Optional<RemoteFingerprint> remote_fingerprint_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(QuicTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_