Replace scoped_ptr with unique_ptr everywhere

webrtc/sdk/objc/Framework/Classes/RTCPeerConnection.mm

 /*
  *  Copyright 2015 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.
  */
 
 #import "RTCPeerConnection+Private.h"
 
 #import "NSString+StdString.h"
 #import "RTCConfiguration+Private.h"
 #import "RTCDataChannel+Private.h"
 #import "RTCIceCandidate+Private.h"
 #import "RTCMediaConstraints+Private.h"
 #import "RTCMediaStream+Private.h"
 #import "RTCPeerConnectionFactory+Private.h"
 #import "RTCRtpSender+Private.h"
 #import "RTCSessionDescription+Private.h"
 #import "RTCStatsReport+Private.h"
 #import "WebRTC/RTCLogging.h"
 
+#include <memory>
+
 #include "webrtc/base/checks.h"
 
 NSString * const kRTCPeerConnectionErrorDomain =
     @"org.webrtc.RTCPeerConnection";
 int const kRTCPeerConnnectionSessionDescriptionError = -1;
 
 namespace webrtc {
 
 class CreateSessionDescriptionObserverAdapter
     : public CreateSessionDescriptionObserver {
  public:
   CreateSessionDescriptionObserverAdapter(
       void (^completionHandler)(RTCSessionDescription *sessionDescription,
                                 NSError *error)) {
     completion_handler_ = completionHandler;
   }
 
   ~CreateSessionDescriptionObserverAdapter() {
     completion_handler_ = nil;
   }
 
   void OnSuccess(SessionDescriptionInterface *desc) override {
     RTC_DCHECK(completion_handler_);
-    rtc::scoped_ptr<webrtc::SessionDescriptionInterface> description =
-        rtc::scoped_ptr<webrtc::SessionDescriptionInterface>(desc);
+    std::unique_ptr<webrtc::SessionDescriptionInterface> description =
+        std::unique_ptr<webrtc::SessionDescriptionInterface>(desc);
     RTCSessionDescription* session =
         [[RTCSessionDescription alloc] initWithNativeDescription:
             description.get()];
     completion_handler_(session, nil);
     completion_handler_ = nil;
   }
 
   void OnFailure(const std::string& error) override {
     RTC_DCHECK(completion_handler_);
     NSString* str = [NSString stringForStdString:error];
@@ skipping 117 matching lines @@
       [[RTCIceCandidate alloc] initWithNativeCandidate:candidate];
   RTCPeerConnection *peer_connection = peer_connection_;
   [peer_connection.delegate peerConnection:peer_connection
                    didGenerateIceCandidate:iceCandidate];
 }
 }  // namespace webrtc
 
 
 @implementation RTCPeerConnection {
   NSMutableArray *_localStreams;
-  rtc::scoped_ptr<webrtc::PeerConnectionDelegateAdapter> _observer;
+  std::unique_ptr<webrtc::PeerConnectionDelegateAdapter> _observer;
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
 }
 
 @synthesize delegate = _delegate;
 
 - (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
                   configuration:(RTCConfiguration *)configuration
                     constraints:(RTCMediaConstraints *)constraints
                        delegate:(id<RTCPeerConnectionDelegate>)delegate {
   NSParameterAssert(factory);
   if (self = [super init]) {
     _observer.reset(new webrtc::PeerConnectionDelegateAdapter(self));
     webrtc::PeerConnectionInterface::RTCConfiguration config =
         configuration.nativeConfiguration;
-    rtc::scoped_ptr<webrtc::MediaConstraints> nativeConstraints =
+    std::unique_ptr<webrtc::MediaConstraints> nativeConstraints =
         constraints.nativeConstraints;
     _peerConnection =
         factory.nativeFactory->CreatePeerConnection(config,
                                                     nativeConstraints.get(),
                                                     nullptr,
                                                     nullptr,
                                                     _observer.get());
     _localStreams = [[NSMutableArray alloc] init];
     _delegate = delegate;
   }
@@ skipping 37 matching lines @@
 
 - (BOOL)setConfiguration:(RTCConfiguration *)configuration {
   return _peerConnection->SetConfiguration(configuration.nativeConfiguration);
 }
 
 - (void)close {
   _peerConnection->Close();
 }
 
 - (void)addIceCandidate:(RTCIceCandidate *)candidate {
-  rtc::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
+  std::unique_ptr<const webrtc::IceCandidateInterface> iceCandidate(
       candidate.nativeCandidate);
   _peerConnection->AddIceCandidate(iceCandidate.get());
 }
 
 - (void)addStream:(RTCMediaStream *)stream {
   if (!_peerConnection->AddStream(stream.nativeMediaStream)) {
     RTCLogError(@"Failed to add stream: %@", stream);
     return;
   }
   [_localStreams addObject:stream];
@@ skipping 226 matching lines @@
     case RTCStatsOutputLevelDebug:
       return webrtc::PeerConnectionInterface::kStatsOutputLevelDebug;
   }
 }
 
 - (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)nativePeerConnection {
   return _peerConnection;
 }
 
 @end