Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/base/relayserver_unittest.cc

 /*
  *  Copyright 2004 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 <string>
 
 #include "webrtc/p2p/base/relayserver.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/testclient.h"
@@ skipping 32 matching lines @@
     server_->AddExternalSocket(
         rtc::AsyncUDPSocket::Create(ss_.get(), server_ext_addr));
 
     client1_.reset(new rtc::TestClient(
         rtc::AsyncUDPSocket::Create(ss_.get(), client1_addr)));
     client2_.reset(new rtc::TestClient(
         rtc::AsyncUDPSocket::Create(ss_.get(), client2_addr)));
   }
 
   void Allocate() {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_ALLOCATE_REQUEST));
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST));
     AddUsernameAttr(req.get(), username_);
     AddLifetimeAttr(req.get(), LIFETIME);
     Send1(req.get());
     delete Receive1();
   }
   void Bind() {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_BINDING_REQUEST));
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST));
     AddUsernameAttr(req.get(), username_);
     Send2(req.get());
     delete Receive1();
   }
 
   void Send1(const StunMessage* msg) {
     rtc::ByteBufferWriter buf;
     msg->Write(&buf);
     SendRaw1(buf.Data(), static_cast<int>(buf.Length()));
   }
@@ skipping 82 matching lines @@
     msg->AddAttribute(attr);
   }
   static void AddDestinationAttr(StunMessage* msg, const SocketAddress& addr) {
     StunAddressAttribute* attr =
         StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
     attr->SetIP(addr.ipaddr());
     attr->SetPort(addr.port());
     msg->AddAttribute(attr);
   }
 
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<RelayServer> server_;
-  rtc::scoped_ptr<rtc::TestClient> client1_;
-  rtc::scoped_ptr<rtc::TestClient> client2_;
+  std::unique_ptr<RelayServer> server_;
+  std::unique_ptr<rtc::TestClient> client1_;
+  std::unique_ptr<rtc::TestClient> client2_;
   std::string username_;
   std::string password_;
 };
 
 // Send a complete nonsense message and verify that it is eaten.
 TEST_F(RelayServerTest, TestBadRequest) {
   SendRaw1(bad, static_cast<int>(strlen(bad)));
   ASSERT_TRUE(Receive1Fails());
 }
 
 // Send an allocate request without a username and verify it is rejected.
 TEST_F(RelayServerTest, TestAllocateNoUsername) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_ALLOCATE_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(4, err->eclass());
   EXPECT_EQ(32, err->number());
   EXPECT_EQ("Missing Username", err->reason());
 }
 
 // Send a binding request and verify that it is rejected.
 TEST_F(RelayServerTest, TestBindingRequest) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 }
 
 // Send an allocate request and verify that it is accepted.
 TEST_F(RelayServerTest, TestAllocate) {
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
   AddLifetimeAttr(req.get(), LIFETIME);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunAddressAttribute* mapped_addr =
       res->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   ASSERT_TRUE(mapped_addr != NULL);
   EXPECT_EQ(1, mapped_addr->family());
   EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
   EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
 
   const StunUInt32Attribute* res_lifetime_attr =
       res->GetUInt32(STUN_ATTR_LIFETIME);
   ASSERT_TRUE(res_lifetime_attr != NULL);
   EXPECT_EQ(LIFETIME, res_lifetime_attr->value());
 }
 
 // Send a second allocate request and verify that it is also accepted, though
 // the lifetime should be ignored.
 TEST_F(RelayServerTest, TestReallocate) {
   Allocate();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST)),
+      res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_ALLOCATE_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunAddressAttribute* mapped_addr =
       res->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   ASSERT_TRUE(mapped_addr != NULL);
   EXPECT_EQ(1, mapped_addr->family());
   EXPECT_EQ(server_ext_addr.port(), mapped_addr->port());
   EXPECT_EQ(server_ext_addr.ipaddr(), mapped_addr->ipaddr());
 
   const StunUInt32Attribute* lifetime_attr =
       res->GetUInt32(STUN_ATTR_LIFETIME);
   ASSERT_TRUE(lifetime_attr != NULL);
   EXPECT_EQ(LIFETIME, lifetime_attr->value());
 }
 
 // Send a request from another client and see that it arrives at the first
 // client in the binding.
 TEST_F(RelayServerTest, TestRemoteBind) {
   Allocate();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddUsernameAttr(req.get(), username_);
 
   Send2(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_DATA_INDICATION, res->type());
 
   const StunByteStringAttribute* recv_data =
       res->GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(recv_data != NULL);
 
   rtc::ByteBufferReader buf(recv_data->bytes(), recv_data->length());
-  rtc::scoped_ptr<StunMessage> res2(new StunMessage());
+  std::unique_ptr<StunMessage> res2(new StunMessage());
   EXPECT_TRUE(res2->Read(&buf));
   EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());
   EXPECT_EQ(req->transaction_id(), res2->transaction_id());
 
   const StunAddressAttribute* src_addr =
       res->GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
   ASSERT_TRUE(src_addr != NULL);
   EXPECT_EQ(1, src_addr->family());
   EXPECT_EQ(client2_addr.ipaddr(), src_addr->ipaddr());
   EXPECT_EQ(client2_addr.port(), src_addr->port());
@@ skipping 10 matching lines @@
   SendRaw1(bad, static_cast<int>(strlen(bad)));
   EXPECT_TRUE(Receive1Fails());
   EXPECT_TRUE(Receive2Fails());
 }
 
 // Send a send request without a username and verify it is rejected.
 TEST_F(RelayServerTest, TestSendRequestMissingUsername) {
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(4, err->eclass());
   EXPECT_EQ(32, err->number());
   EXPECT_EQ("Missing Username", err->reason());
 }
 
 // Send a send request with the wrong username and verify it is rejected.
 TEST_F(RelayServerTest, TestSendRequestBadUsername) {
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), "foobarbizbaz");
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(4, err->eclass());
   EXPECT_EQ(30, err->number());
   EXPECT_EQ("Stale Credentials", err->reason());
 }
 
 // Send a send request without a destination address and verify that it is
 // rejected.
 TEST_F(RelayServerTest, TestSendRequestNoDestinationAddress) {
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(4, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Bad Request", err->reason());
 }
 
 // Send a send request without data and verify that it is rejected.
 TEST_F(RelayServerTest, TestSendRequestNoData) {
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
   AddDestinationAttr(req.get(), client2_addr);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(4, err->eclass());
   EXPECT_EQ(00, err->number());
   EXPECT_EQ("Bad Request", err->reason());
 }
 
 // Send a binding request after an allocate and verify that it is rejected.
 TEST_F(RelayServerTest, TestSendRequestWrongType) {
   Allocate();
   Bind();
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_BINDING_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_BINDING_REQUEST)),
+      res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res);
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, res->type());
   EXPECT_EQ(req->transaction_id(), res->transaction_id());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 }
 
 // Verify that we can send traffic back and forth between the clients after a
 // successful allocate and bind.
 TEST_F(RelayServerTest, TestSendRaw) {
   Allocate();
   Bind();
 
   for (int i = 0; i < 10; i++) {
-    rtc::scoped_ptr<StunMessage> req(
-        CreateStunMessage(STUN_SEND_REQUEST)), res;
+    std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
     AddMagicCookieAttr(req.get());
     AddUsernameAttr(req.get(), username_);
     AddDestinationAttr(req.get(), client2_addr);
 
     StunByteStringAttribute* send_data =
         StunAttribute::CreateByteString(STUN_ATTR_DATA);
     send_data->CopyBytes(msg1);
     req->AddAttribute(send_data);
 
     Send1(req.get());
@@ skipping 21 matching lines @@
 
 // Verify that a binding expires properly, and rejects send requests.
 // Flaky, see https://code.google.com/p/webrtc/issues/detail?id=4134
 TEST_F(RelayServerTest, DISABLED_TestExpiration) {
   Allocate();
   Bind();
 
   // Wait twice the lifetime to make sure the server has expired the binding.
   rtc::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
 
-  rtc::scoped_ptr<StunMessage> req(
-      CreateStunMessage(STUN_SEND_REQUEST)), res;
+  std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
   AddDestinationAttr(req.get(), client2_addr);
 
   StunByteStringAttribute* data_attr =
       StunAttribute::CreateByteString(STUN_ATTR_DATA);
   data_attr->CopyBytes(msg1);
   req->AddAttribute(data_attr);
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res.get() != NULL);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 
   // Also verify that traffic from the external client is ignored.
   SendRaw2(msg2, static_cast<int>(strlen(msg2)));
   EXPECT_TRUE(ReceiveRaw1().empty());
 }