Don't call the Pass methods of rtc::Buffer, rtc::scoped_ptr, and rtc::ScopedVector

talk/app/webrtc/peerconnection_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 12 matching lines @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "talk/app/webrtc/dtmfsender.h"
 #include "talk/app/webrtc/fakemetricsobserver.h"
 #include "talk/app/webrtc/fakeportallocatorfactory.h"
 #include "talk/app/webrtc/localaudiosource.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/peerconnection.h"
 #include "talk/app/webrtc/peerconnectionfactory.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
@@ skipping 101 matching lines @@
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
                                  public ObserverInterface {
  public:
   static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
       rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
     PeerConnectionTestClient* client(new PeerConnectionTestClient(id));
-    if (!client->Init(constraints, options, dtls_identity_store.Pass())) {
+    if (!client->Init(constraints, options, std::move(dtls_identity_store))) {
       delete client;
       return nullptr;
     }
     return client;
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options) {
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
 
     return CreateClientWithDtlsIdentityStore(id, constraints, options,
-                                             dtls_identity_store.Pass());
+                                             std::move(dtls_identity_store));
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
 
   void Negotiate(bool audio, bool video) {
     rtc::scoped_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(offer.use()));
@@ skipping 573 matching lines @@
         rtc::Thread::Current(), rtc::Thread::Current(),
         fake_audio_capture_module_, fake_video_encoder_factory_,
         fake_video_decoder_factory_);
     if (!peer_connection_factory_) {
       return false;
     }
     if (options) {
       peer_connection_factory_->SetOptions(*options);
     }
     peer_connection_ = CreatePeerConnection(
-        allocator_factory_.get(), constraints, dtls_identity_store.Pass());
+        allocator_factory_.get(), constraints, std::move(dtls_identity_store));
     return peer_connection_.get() != nullptr;
   }
 
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
       webrtc::PortAllocatorFactoryInterface* factory,
       const MediaConstraintsInterface* constraints,
       rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
     // CreatePeerConnection with IceServers.
     webrtc::PeerConnectionInterface::IceServers ice_servers;
     webrtc::PeerConnectionInterface::IceServer ice_server;
     ice_server.uri = "stun:stun.l.google.com:19302";
     ice_servers.push_back(ice_server);
 
     return peer_connection_factory_->CreatePeerConnection(
-        ice_servers, constraints, factory, dtls_identity_store.Pass(), this);
+        ice_servers, constraints, factory, std::move(dtls_identity_store),
+        this);
   }
 
   void HandleIncomingOffer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingOffer ";
     if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) {
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
     }
     rtc::scoped_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("offer", msg, nullptr));
@@ skipping 332 matching lines @@
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
 
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
     dtls_identity_store->use_alternate_key();
 
     // Make sure the new client is using a different certificate.
     return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore(
-        "New Peer: ", &setup_constraints, nullptr, dtls_identity_store.Pass());
+        "New Peer: ", &setup_constraints, nullptr,
+        std::move(dtls_identity_store));
   }
 
   void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) {
     // Messages may get lost on the unreliable DataChannel, so we send multiple
     // times to avoid test flakiness.
     static const size_t kSendAttempts = 5;
 
     for (size_t i = 0; i < kSendAttempts; ++i) {
       dc->Send(DataBuffer(data));
     }
@@ skipping 844 matching lines @@
   server.urls.push_back("stun:hostname");
   server.urls.push_back("turn:hostname");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_configurations_,
                                       &turn_configurations_));
   EXPECT_EQ(1U, stun_configurations_.size());
   EXPECT_EQ(1U, turn_configurations_.size());
 }
 
 #endif // if !defined(THREAD_SANITIZER)