Helpers in peer connection unit tests: Use scoped_ptr instead of raw pointers

webrtc/api/peerconnectioninterface_unittest.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 619 matching lines @@
             audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
     stream->AddTrack(audio_track.get());
     scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(video_track_label, NULL));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
-  bool DoCreateOfferAnswer(SessionDescriptionInterface** desc,
+  bool DoCreateOfferAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
                            bool offer,
                            MediaConstraintsInterface* constraints) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
       pc_->CreateOffer(observer, constraints);
     } else {
       pc_->CreateAnswer(observer, constraints);
     }
     EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
-    *desc = observer->release_desc();
+    desc->reset(observer->release_desc());
     return observer->result();
   }
 
-  bool DoCreateOffer(SessionDescriptionInterface** desc,
+  bool DoCreateOffer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
                      MediaConstraintsInterface* constraints) {
     return DoCreateOfferAnswer(desc, true, constraints);
   }
 
-  bool DoCreateAnswer(SessionDescriptionInterface** desc,
+  bool DoCreateAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
                       MediaConstraintsInterface* constraints) {
     return DoCreateOfferAnswer(desc, false, constraints);
   }
 
   bool DoSetSessionDescription(SessionDescriptionInterface* desc, bool local) {
     rtc::scoped_refptr<MockSetSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockSetSessionDescriptionObserver>());
     if (local) {
       pc_->SetLocalDescription(observer, desc);
@@ skipping 41 matching lines @@
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
 
     desc = cricket::GetFirstVideoContentDescription(
         pc_->remote_description()->description());
     ASSERT_TRUE(desc != NULL);
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
   }
 
   void CreateOfferAsRemoteDescription() {
     rtc::scoped_ptr<SessionDescriptionInterface> offer;
-    ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+    ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAndSetRemoteOffer(const std::string& sdp) {
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp, nullptr);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAnswerAsLocalDescription() {
     scoped_ptr<SessionDescriptionInterface> answer;
-    ASSERT_TRUE(DoCreateAnswer(answer.use(), nullptr));
+    ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     SessionDescriptionInterface* new_answer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetLocalDescription(new_answer));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePrAnswerAsLocalDescription() {
     scoped_ptr<SessionDescriptionInterface> answer;
-    ASSERT_TRUE(DoCreateAnswer(answer.use(), nullptr));
+    ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     SessionDescriptionInterface* pr_answer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer,
                                          sdp, NULL);
     EXPECT_TRUE(DoSetLocalDescription(pr_answer));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
   }
 
   void CreateOfferReceiveAnswer() {
     CreateOfferAsLocalDescription();
     std::string sdp;
     EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
     CreateAnswerAsRemoteDescription(sdp);
   }
 
   void CreateOfferAsLocalDescription() {
     rtc::scoped_ptr<SessionDescriptionInterface> offer;
-    ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+    ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     SessionDescriptionInterface* new_offer =
@@ skipping 46 matching lines @@
     CreateOfferAsLocalDescription();
     std::string sdp;
     EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
     SetSsrcToZero(&sdp);
     CreateAnswerAsRemoteDescription(sdp);
   }
 
   // This function creates a MediaStream with label kStreams[0] and
   // |number_of_audio_tracks| and |number_of_video_tracks| tracks and the
   // corresponding SessionDescriptionInterface. The SessionDescriptionInterface
-  // is returned in |desc| and the MediaStream is stored in
+  // is returned and the MediaStream is stored in
   // |reference_collection_|
-  void CreateSessionDescriptionAndReference(
-      size_t number_of_audio_tracks,
-      size_t number_of_video_tracks,
-      SessionDescriptionInterface** desc) {
-    ASSERT_TRUE(desc != nullptr);
-    ASSERT_LE(number_of_audio_tracks, 2u);
-    ASSERT_LE(number_of_video_tracks, 2u);
+  rtc::scoped_ptr<SessionDescriptionInterface>
+  CreateSessionDescriptionAndReference(size_t number_of_audio_tracks,
+                                       size_t number_of_video_tracks) {
+    EXPECT_LE(number_of_audio_tracks, 2u);
+    EXPECT_LE(number_of_video_tracks, 2u);
 
     reference_collection_ = StreamCollection::Create();
     std::string sdp_ms1 = std::string(kSdpStringInit);
 
     std::string mediastream_label = kStreams[0];
 
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
         webrtc::MediaStream::Create(mediastream_label));
     reference_collection_->AddStream(stream);
 
@@ skipping 10 matching lines @@
     if (number_of_video_tracks > 0) {
       sdp_ms1 += std::string(kSdpStringVideo);
       sdp_ms1 += std::string(kSdpStringMs1Video0);
       AddVideoTrack(kVideoTracks[0], stream);
     }
     if (number_of_video_tracks > 1) {
       sdp_ms1 += kSdpStringMs1Video1;
       AddVideoTrack(kVideoTracks[1], stream);
     }
 
-    *desc = webrtc::CreateSessionDescription(
-        SessionDescriptionInterface::kOffer, sdp_ms1, nullptr);
+    return rtc::scoped_ptr<SessionDescriptionInterface>(
+        webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
+                                         sdp_ms1, nullptr));
   }
 
   void AddAudioTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(track_id, nullptr));
     ASSERT_TRUE(stream->AddTrack(audio_track));
   }
 
   void AddVideoTrack(const std::string& track_id,
@@ skipping 42 matching lines @@
   // Remove the first stream.
   pc_->RemoveStream(pc_->local_streams()->at(0));
   EXPECT_EQ(0u, pc_->local_streams()->count());
 }
 
 // Test that the created offer includes streams we added.
 TEST_F(PeerConnectionInterfaceTest, AddedStreamsPresentInOffer) {
   CreatePeerConnection();
   AddAudioVideoStream(kStreamLabel1, "audio_track", "video_track");
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::ContentInfo* audio_content =
       cricket::GetFirstAudioContent(offer->description());
   const cricket::AudioContentDescription* audio_desc =
       static_cast<const cricket::AudioContentDescription*>(
           audio_content->description);
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
       static_cast<const cricket::VideoContentDescription*>(
           video_content->description);
   EXPECT_TRUE(
       ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track"));
 
   // Add another stream and ensure the offer includes both the old and new
   // streams.
   AddAudioVideoStream(kStreamLabel2, "audio_track2", "video_track2");
-  ASSERT_TRUE(DoCreateOffer(offer.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   audio_content = cricket::GetFirstAudioContent(offer->description());
   audio_desc = static_cast<const cricket::AudioContentDescription*>(
       audio_content->description);
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel2, "audio_track2"));
 
   video_content = cricket::GetFirstVideoContent(offer->description());
@@ skipping 32 matching lines @@
   auto video_sender = pc_->AddTrack(video_track, stream_list);
   EXPECT_EQ(kStreamLabel1, audio_sender->stream_id());
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ(kStreamLabel1, video_sender->stream_id());
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
 
   // Now create an offer and check for the senders.
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::ContentInfo* audio_content =
       cricket::GetFirstAudioContent(offer->description());
   const cricket::AudioContentDescription* audio_desc =
       static_cast<const cricket::AudioContentDescription*>(
           audio_content->description);
   EXPECT_TRUE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
       static_cast<const cricket::VideoContentDescription*>(
           video_content->description);
   EXPECT_TRUE(
       ContainsTrack(video_desc->streams(), kStreamLabel1, "video_track"));
 
   EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
   // Now try removing the tracks.
   EXPECT_TRUE(pc_->RemoveTrack(audio_sender));
   EXPECT_TRUE(pc_->RemoveTrack(video_sender));
 
   // Create a new offer and ensure it doesn't contain the removed senders.
-  ASSERT_TRUE(DoCreateOffer(offer.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   audio_content = cricket::GetFirstAudioContent(offer->description());
   audio_desc = static_cast<const cricket::AudioContentDescription*>(
       audio_content->description);
   EXPECT_FALSE(
       ContainsTrack(audio_desc->streams(), kStreamLabel1, "audio_track"));
 
   video_content = cricket::GetFirstVideoContent(offer->description());
   video_desc = static_cast<const cricket::VideoContentDescription*>(
       video_content->description);
@@ skipping 90 matching lines @@
   CreateOfferReceiveAnswer();
   EXPECT_EQ(0u, pc_->remote_streams()->count());
 }
 
 // Test that candidates are generated and that we can parse our own candidates.
 TEST_F(PeerConnectionInterfaceTest, IceCandidates) {
   CreatePeerConnection();
 
   EXPECT_FALSE(pc_->AddIceCandidate(observer_.last_candidate_.get()));
   // SetRemoteDescription takes ownership of offer.
-  SessionDescriptionInterface* offer = NULL;
+  rtc::scoped_ptr<SessionDescriptionInterface> offer;
   AddVideoStream(kStreamLabel1);
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
-  EXPECT_TRUE(DoSetRemoteDescription(offer));
+  EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
 
   // SetLocalDescription takes ownership of answer.
-  SessionDescriptionInterface* answer = NULL;
+  rtc::scoped_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
-  EXPECT_TRUE(DoSetLocalDescription(answer));
+  EXPECT_TRUE(DoSetLocalDescription(answer.release()));
 
   EXPECT_TRUE_WAIT(observer_.last_candidate_.get() != NULL, kTimeout);
   EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout);
 
   EXPECT_TRUE(pc_->AddIceCandidate(observer_.last_candidate_.get()));
 }
 
 // Test that CreateOffer and CreateAnswer will fail if the track labels are
 // not unique.
 TEST_F(PeerConnectionInterfaceTest, CreateOfferAnswerWithInvalidStream) {
   CreatePeerConnection();
   // Create a regular offer for the CreateAnswer test later.
-  SessionDescriptionInterface* offer = NULL;
+  rtc::scoped_ptr<SessionDescriptionInterface> offer;
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
-  EXPECT_TRUE(offer != NULL);
-  delete offer;
-  offer = NULL;
+  EXPECT_TRUE(offer);
+  offer.reset();
 
   // Create a local stream with audio&video tracks having same label.
   AddAudioVideoStream(kStreamLabel1, "track_label", "track_label");
 
   // Test CreateOffer
   EXPECT_FALSE(DoCreateOffer(&offer, nullptr));
 
   // Test CreateAnswer
-  SessionDescriptionInterface* answer = NULL;
+  rtc::scoped_ptr<SessionDescriptionInterface> answer;
   EXPECT_FALSE(DoCreateAnswer(&answer, nullptr));
 }
 
 // Test that we will get different SSRCs for each tracks in the offer and answer
 // we created.
 TEST_F(PeerConnectionInterfaceTest, SsrcInOfferAnswer) {
   CreatePeerConnection();
   // Create a local stream with audio&video tracks having different labels.
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
 
   // Test CreateOffer
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
   int audio_ssrc = 0;
   int video_ssrc = 0;
   EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(offer->description()),
                            &audio_ssrc));
   EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(offer->description()),
                            &video_ssrc));
   EXPECT_NE(audio_ssrc, video_ssrc);
 
   // Test CreateAnswer
   EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
   scoped_ptr<SessionDescriptionInterface> answer;
-  ASSERT_TRUE(DoCreateAnswer(answer.use(), nullptr));
+  ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
   audio_ssrc = 0;
   video_ssrc = 0;
   EXPECT_TRUE(GetFirstSsrc(GetFirstAudioContent(answer->description()),
                            &audio_ssrc));
   EXPECT_TRUE(GetFirstSsrc(GetFirstVideoContent(answer->description()),
                            &video_ssrc));
   EXPECT_NE(audio_ssrc, video_ssrc);
 }
 
 // Test that it's possible to call AddTrack on a MediaStream after adding
 // the stream to a PeerConnection.
 // TODO(deadbeef): Remove this test once this behavior is no longer supported.
 TEST_F(PeerConnectionInterfaceTest, AddTrackAfterAddStream) {
   CreatePeerConnection();
   // Create audio stream and add to PeerConnection.
   AddVoiceStream(kStreamLabel1);
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Add video track to the audio-only stream.
   scoped_refptr<VideoTrackInterface> video_track(
       pc_factory_->CreateVideoTrack("video_label", nullptr));
   stream->AddTrack(video_track.get());
 
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc != nullptr);
 }
 
 // Test that it's possible to call RemoveTrack on a MediaStream after adding
 // the stream to a PeerConnection.
 // TODO(deadbeef): Remove this test once this behavior is no longer supported.
 TEST_F(PeerConnectionInterfaceTest, RemoveTrackAfterAddStream) {
   CreatePeerConnection();
   // Create audio/video stream and add to PeerConnection.
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Remove the video track.
   stream->RemoveTrack(stream->GetVideoTracks()[0]);
 
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc == nullptr);
 }
 
 // Test creating a sender with a stream ID, and ensure the ID is populated
 // in the offer.
 TEST_F(PeerConnectionInterfaceTest, CreateSenderWithStream) {
   CreatePeerConnection();
   pc_->CreateSender("video", kStreamLabel1);
 
   scoped_ptr<SessionDescriptionInterface> offer;
-  ASSERT_TRUE(DoCreateOffer(offer.use(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   ASSERT_TRUE(video_desc != nullptr);
   ASSERT_EQ(1u, video_desc->streams().size());
   EXPECT_EQ(kStreamLabel1, video_desc->streams()[0].sync_label);
 }
 
 // Test that we can specify a certain track that we want statistics about.
 TEST_F(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) {
@@ skipping 437 matching lines @@
 TEST_F(PeerConnectionInterfaceTest, CreateSubsequentRecvOnlyOffer) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   CreateAnswerAsLocalDescription();
 
   // At this point we should be receiving stream 1, but not sending anything.
   // A new offer should be recvonly.
-  SessionDescriptionInterface* offer;
+  rtc::scoped_ptr<SessionDescriptionInterface> offer;
   DoCreateOffer(&offer, nullptr);
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
       static_cast<const cricket::VideoContentDescription*>(
           video_content->description);
   ASSERT_EQ(cricket::MD_RECVONLY, video_desc->direction());
 
   const cricket::ContentInfo* audio_content =
@@ skipping 11 matching lines @@
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   CreateAnswerAsLocalDescription();
 
   // At this point we should be receiving stream 1, but not sending anything.
   // A new offer would be recvonly, but we'll set the "no receive" constraints
   // to make it inactive.
-  SessionDescriptionInterface* offer;
+  rtc::scoped_ptr<SessionDescriptionInterface> offer;
   FakeConstraints offer_constraints;
   offer_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveVideo, false);
   offer_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveAudio, false);
   DoCreateOffer(&offer, &offer_constraints);
 
   const cricket::ContentInfo* video_content =
       cricket::GetFirstVideoContent(offer->description());
   const cricket::VideoContentDescription* video_desc =
@@ skipping 74 matching lines @@
   rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
       pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0]));
   EXPECT_TRUE(NULL == dtmf_sender);  // local stream has been removed.
 
   EXPECT_TRUE(pc_->CreateDataChannel("test", NULL) == NULL);
 
   EXPECT_TRUE(pc_->local_description() != NULL);
   EXPECT_TRUE(pc_->remote_description() != NULL);
 
   rtc::scoped_ptr<SessionDescriptionInterface> offer;
-  EXPECT_TRUE(DoCreateOffer(offer.use(), nullptr));
+  EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
   rtc::scoped_ptr<SessionDescriptionInterface> answer;
-  EXPECT_TRUE(DoCreateAnswer(answer.use(), nullptr));
+  EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
 
   std::string sdp;
   ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
   SessionDescriptionInterface* remote_offer =
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL);
   EXPECT_FALSE(DoSetRemoteDescription(remote_offer));
 
   ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
   SessionDescriptionInterface* local_offer =
@@ skipping 39 matching lines @@
 }
 
 // This test verifies that when remote tracks are added/removed from SDP, the
 // created remote streams are updated appropriately.
 TEST_F(PeerConnectionInterfaceTest,
        AddRemoveTrackFromExistingRemoteMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1;
-  CreateSessionDescriptionAndReference(1, 1, desc_ms1.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1 =
+      CreateSessionDescriptionAndReference(1, 1);
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms1.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
 
   // Add extra audio and video tracks to the same MediaStream.
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1_two_tracks;
-  CreateSessionDescriptionAndReference(2, 2, desc_ms1_two_tracks.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1_two_tracks =
+      CreateSessionDescriptionAndReference(2, 2);
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms1_two_tracks.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
 
   // Remove the extra audio and video tracks.
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms2;
-  CreateSessionDescriptionAndReference(1, 1, desc_ms2.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms2 =
+      CreateSessionDescriptionAndReference(1, 1);
   EXPECT_TRUE(DoSetRemoteDescription(desc_ms2.release()));
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_));
 }
 
 // This tests that remote tracks are ended if a local session description is set
 // that rejects the media content type.
 TEST_F(PeerConnectionInterfaceTest, RejectMediaContent) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // First create and set a remote offer, then reject its video content in our
   // answer.
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
   ASSERT_EQ(1u, observer_.remote_streams()->count());
   MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
   ASSERT_EQ(1u, remote_stream->GetVideoTracks().size());
   ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
 
   rtc::scoped_refptr<webrtc::VideoTrackInterface> remote_video =
       remote_stream->GetVideoTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_video->state());
   rtc::scoped_refptr<webrtc::AudioTrackInterface> remote_audio =
       remote_stream->GetAudioTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
 
   rtc::scoped_ptr<SessionDescriptionInterface> local_answer;
-  EXPECT_TRUE(DoCreateAnswer(local_answer.accept(), nullptr));
+  EXPECT_TRUE(DoCreateAnswer(&local_answer, nullptr));
   cricket::ContentInfo* video_info =
       local_answer->description()->GetContentByName("video");
   video_info->rejected = true;
   EXPECT_TRUE(DoSetLocalDescription(local_answer.release()));
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, remote_video->state());
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
 
   // Now create an offer where we reject both video and audio.
   rtc::scoped_ptr<SessionDescriptionInterface> local_offer;
-  EXPECT_TRUE(DoCreateOffer(local_offer.accept(), nullptr));
+  EXPECT_TRUE(DoCreateOffer(&local_offer, nullptr));
   video_info = local_offer->description()->GetContentByName("video");
   ASSERT_TRUE(video_info != nullptr);
   video_info->rejected = true;
   cricket::ContentInfo* audio_info =
       local_offer->description()->GetContentByName("audio");
   ASSERT_TRUE(audio_info != nullptr);
   audio_info->rejected = true;
   EXPECT_TRUE(DoSetLocalDescription(local_offer.release()));
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, remote_video->state());
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, remote_audio->state());
@@ skipping 178 matching lines @@
 // TODO(deadbeef): This test and the one below it need to be updated when
 // an RtpSender's lifetime isn't determined by when a local description is set.
 TEST_F(PeerConnectionInterfaceTest, LocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
   rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(throwaway.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
-  CreateSessionDescriptionAndReference(2, 2, desc_1.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_1 =
+      CreateSessionDescriptionAndReference(2, 2);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 
   // Remove an audio and video track.
   pc_->RemoveStream(reference_collection_->at(0));
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_2;
-  CreateSessionDescriptionAndReference(1, 1, desc_2.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_2 =
+      CreateSessionDescriptionAndReference(1, 1);
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc_2.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_FALSE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_FALSE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that an RtpSender is created when the local description is set
 // before adding a local stream.
 TEST_F(PeerConnectionInterfaceTest,
        AddLocalStreamAfterLocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
   rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(throwaway.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
-  CreateSessionDescriptionAndReference(2, 2, desc_1.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_1 =
+      CreateSessionDescriptionAndReference(2, 2);
 
   EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(0u, senders.size());
 
   pc_->AddStream(reference_collection_->at(0));
   senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that the expected behavior occurs if the SSRC on a local track is
 // changed when SetLocalDescription is called.
 TEST_F(PeerConnectionInterfaceTest,
        ChangeSsrcOnTrackInLocalSessionDescription) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
   rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(throwaway.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc;
-  CreateSessionDescriptionAndReference(1, 1, desc.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc =
+      CreateSessionDescriptionAndReference(1, 1);
   std::string sdp;
   desc->ToString(&sdp);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
@@ skipping 22 matching lines @@
 // This tests that the expected behavior occurs if a new session description is
 // set with the same tracks, but on a different MediaStream.
 TEST_F(PeerConnectionInterfaceTest, SignalSameTracksInSeparateMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   // Create an offer just to ensure we have an identity before we manually
   // call SetLocalDescription.
   rtc::scoped_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(throwaway.accept(), nullptr));
+  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> desc;
-  CreateSessionDescriptionAndReference(1, 1, desc.accept());
+  rtc::scoped_ptr<SessionDescriptionInterface> desc =
+      CreateSessionDescriptionAndReference(1, 1);
   std::string sdp;
   desc->ToString(&sdp);
 
   pc_->AddStream(reference_collection_->at(0));
   EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
@@ skipping 298 matching lines @@
   FakeConstraints updated_answer_c;
   answer_c.SetMandatoryReceiveAudio(false);
   answer_c.SetMandatoryReceiveVideo(false);
 
   cricket::MediaSessionOptions updated_answer_options;
   EXPECT_TRUE(
       ParseConstraintsForAnswer(&updated_answer_c, &updated_answer_options));
   EXPECT_TRUE(updated_answer_options.has_audio());
   EXPECT_TRUE(updated_answer_options.has_video());
 }