Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/webrtcsdp_unittest.cc

 /*
  *  Copyright 2011 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.
  */
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/jsepsessiondescription.h"
 #ifdef WEBRTC_ANDROID
 #include "webrtc/api/test/androidtestinitializer.h"
 #endif
 #include "webrtc/api/webrtcsdp.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslfingerprint.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/engine/webrtcvideoengine2.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/pc/mediasession.h"
 
 using cricket::AudioCodec;
@@ skipping 1353 matching lines @@
     if (!jdesc_no_candidates.Initialize(desc_.Copy(), kSessionId,
                                         kSessionVersion)) {
       return false;
     }
     std::string message = webrtc::SdpSerialize(jdesc_no_candidates, false);
     EXPECT_EQ(new_sdp, message);
     return true;
   }
 
   void AddSctpDataChannel() {
-    rtc::scoped_ptr<DataContentDescription> data(
-        new DataContentDescription());
+    std::unique_ptr<DataContentDescription> data(new DataContentDescription());
     data_desc_ = data.get();
     data_desc_->set_protocol(cricket::kMediaProtocolDtlsSctp);
     DataCodec codec(cricket::kGoogleSctpDataCodecId,
                     cricket::kGoogleSctpDataCodecName);
     codec.SetParam(cricket::kCodecParamPort, kDefaultSctpPort);
     data_desc_->AddCodec(codec);
     desc_.AddContent(kDataContentName, NS_JINGLE_DRAFT_SCTP, data.release());
     EXPECT_TRUE(desc_.AddTransportInfo(TransportInfo(
         kDataContentName, TransportDescription(kUfragData, kPwdData))));
   }
 
   void AddRtpDataChannel() {
-    rtc::scoped_ptr<DataContentDescription> data(
-        new DataContentDescription());
+    std::unique_ptr<DataContentDescription> data(new DataContentDescription());
     data_desc_ = data.get();
 
     data_desc_->AddCodec(DataCodec(101, "google-data"));
     StreamParams data_stream;
     data_stream.id = kDataChannelMsid;
     data_stream.cname = kDataChannelCname;
     data_stream.sync_label = kDataChannelLabel;
     data_stream.ssrcs.push_back(kDataChannelSsrc);
     data_desc_->AddStream(data_stream);
     data_desc_->AddCrypto(CryptoParams(
@@ skipping 249 matching lines @@
     EXPECT_TRUE(webrtc::SdpDeserialize(message, &jdesc_output_des, &error));
     EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_output_des));
   }
 
  protected:
   SessionDescription desc_;
   AudioContentDescription* audio_desc_;
   VideoContentDescription* video_desc_;
   DataContentDescription* data_desc_;
   Candidates candidates_;
-  rtc::scoped_ptr<IceCandidateInterface> jcandidate_;
+  std::unique_ptr<IceCandidateInterface> jcandidate_;
   JsepSessionDescription jdesc_;
 };
 
 void TestMismatch(const std::string& string1, const std::string& string2) {
   int position = 0;
   for (size_t i = 0; i < string1.length() && i < string2.length(); ++i) {
     if (string1.c_str()[i] != string2.c_str()[i]) {
       position = static_cast<int>(i);
       break;
     }
@@ skipping 382 matching lines @@
 }
 
 // TODO(mallinath) : Enable this test once WebRTCSdp capable of parsing
 // RFC 6544.
 TEST_F(WebRtcSdpTest, SerializeTcpCandidates) {
   Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
                       rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
                       "", "", LOCAL_PORT_TYPE, kCandidateGeneration,
                       kCandidateFoundation1);
   candidate.set_tcptype(cricket::TCPTYPE_ACTIVE_STR);
-  rtc::scoped_ptr<IceCandidateInterface> jcandidate(
-    new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
+  std::unique_ptr<IceCandidateInterface> jcandidate(
+      new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
 
   std::string message = webrtc::SdpSerializeCandidate(*jcandidate);
   EXPECT_EQ(std::string(kSdpTcpActiveCandidate), message);
 }
 
 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithH264) {
   if (!webrtc::H264Encoder::IsSupported())
     return;
   for (const auto& codec : cricket::DefaultVideoCodecList()) {
     video_desc_->AddCodec(codec);
@@ skipping 301 matching lines @@
   EXPECT_TRUE(jcandidate.candidate().IsEquivalent(expected));
   EXPECT_EQ(9, jcandidate.candidate().network_cost());
 
   sdp = kSdpTcpActiveCandidate;
   EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
   // Make a cricket::Candidate equivalent to kSdpTcpCandidate string.
   Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
                       rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
                       "", "", LOCAL_PORT_TYPE, kCandidateGeneration,
                       kCandidateFoundation1);
-  rtc::scoped_ptr<IceCandidateInterface> jcandidate_template(
-    new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
+  std::unique_ptr<IceCandidateInterface> jcandidate_template(
+      new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
   EXPECT_TRUE(jcandidate.candidate().IsEquivalent(
                     jcandidate_template->candidate()));
   sdp = kSdpTcpPassiveCandidate;
   EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
   sdp = kSdpTcpSOCandidate;
   EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
 }
 
 // This test verifies the deserialization of candidate-attribute
 // as per RFC 5245. Candiate-attribute will be of the format
@@ skipping 724 matching lines @@
   EXPECT_TRUE(
       SdpDeserialize(kUnifiedPlanSdpFullString, &deserialized_description));
 
   EXPECT_TRUE(CompareSessionDescription(jdesc_, deserialized_description));
 }
 
 TEST_F(WebRtcSdpTest, SerializeUnifiedPlanSessionDescription) {
   MakeUnifiedPlanDescription();
   TestSerialize(jdesc_, true);
 }