Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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 "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/p2p/client/fakeportallocator.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/firewallsocketserver.h"
 #include "webrtc/base/gunit.h"
@@ skipping 183 matching lines @@
       if (!ch_packets_.empty()) {
         std::string packet =  ch_packets_.front();
         ret = (packet == std::string(data, len));
         ch_packets_.pop_front();
       }
       return ret;
     }
 
     std::string name_;  // TODO - Currently not used.
     std::list<std::string> ch_packets_;
-    rtc::scoped_ptr<cricket::P2PTransportChannel> ch_;
+    std::unique_ptr<cricket::P2PTransportChannel> ch_;
   };
 
   struct CandidatesData : public rtc::MessageData {
     CandidatesData(cricket::TransportChannel* ch, const cricket::Candidate& c)
         : channel(ch), candidates(1, c) {}
     CandidatesData(cricket::TransportChannel* ch,
                    const std::vector<cricket::Candidate>& cc)
         : channel(ch), candidates(cc) {}
     cricket::TransportChannel* channel;
     cricket::Candidates candidates;
@@ skipping 23 matching lines @@
     void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
     bool role_conflict() { return role_conflict_; }
     void SetAllocationStepDelay(uint32_t delay) {
       allocator_->set_step_delay(delay);
     }
     void SetAllowTcpListen(bool allow_tcp_listen) {
       allocator_->set_allow_tcp_listen(allow_tcp_listen);
     }
 
     rtc::FakeNetworkManager network_manager_;
-    rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+    std::unique_ptr<cricket::BasicPortAllocator> allocator_;
     ChannelData cd1_;
     ChannelData cd2_;
     cricket::IceRole role_;
     uint64_t tiebreaker_;
     bool role_conflict_;
     bool save_candidates_;
     std::vector<CandidatesData*> saved_candidates_;
   };
 
   ChannelData* GetChannelData(cricket::TransportChannel* channel) {
@@ skipping 426 matching lines @@
     for (; it != ed->saved_candidates_.end(); ++it) {
       main_->Post(this, MSG_ADD_CANDIDATES, *it);
     }
     ed->saved_candidates_.clear();
     ed->save_candidates_ = false;
   }
 
   void OnMessage(rtc::Message* msg) {
     switch (msg->message_id) {
       case MSG_ADD_CANDIDATES: {
-        rtc::scoped_ptr<CandidatesData> data(
+        std::unique_ptr<CandidatesData> data(
             static_cast<CandidatesData*>(msg->pdata));
         cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
         for (auto& c : data->candidates) {
           if (clear_remote_candidates_ufrag_pwd_) {
             c.set_username("");
             c.set_password("");
           }
           LOG(LS_INFO) << "Candidate(" << data->channel->component() << "->"
                        << rch->component() << "): " << c.ToString();
           rch->AddRemoteCandidate(c);
         }
         break;
       }
       case MSG_REMOVE_CANDIDATES: {
-        rtc::scoped_ptr<CandidatesData> data(
+        std::unique_ptr<CandidatesData> data(
             static_cast<CandidatesData*>(msg->pdata));
         cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
         for (cricket::Candidate& c : data->candidates) {
           LOG(LS_INFO) << "Removed remote candidate " << c.ToString();
           rch->RemoveRemoteCandidate(c);
         }
         break;
       }
     }
   }
@@ skipping 59 matching lines @@
   void set_clear_remote_candidates_ufrag_pwd(bool clear) {
     clear_remote_candidates_ufrag_pwd_ = clear;
   }
 
   void set_force_relay(bool relay) {
     force_relay_ = relay;
   }
 
  private:
   rtc::Thread* main_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
-  rtc::scoped_ptr<rtc::NATSocketServer> nss_;
-  rtc::scoped_ptr<rtc::FirewallSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::NATSocketServer> nss_;
+  std::unique_ptr<rtc::FirewallSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<cricket::TestStunServer> stun_server_;
+  std::unique_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestTurnServer turn_server_;
   cricket::TestRelayServer relay_server_;
   rtc::SocksProxyServer socks_server1_;
   rtc::SocksProxyServer socks_server2_;
   Endpoint ep1_;
   Endpoint ep2_;
   bool clear_remote_candidates_ufrag_pwd_;
   bool force_relay_;
 };
 
@@ skipping 1171 matching lines @@
   }
 
   cricket::CandidatePairInterface* last_selected_candidate_pair() {
     return last_selected_candidate_pair_;
   }
   int last_sent_packet_id() { return last_sent_packet_id_; }
   bool channel_ready_to_send() { return channel_ready_to_send_; }
   void reset_channel_ready_to_send() { channel_ready_to_send_ = false; }
 
  private:
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::SocketServerScope ss_scope_;
   cricket::CandidatePairInterface* last_selected_candidate_pair_ = nullptr;
   int last_sent_packet_id_ = -1;
   bool channel_ready_to_send_ = false;
 };
 
 TEST_F(P2PTransportChannelPingTest, TestTriggeredChecks) {
   cricket::FakePortAllocator pa(rtc::Thread::Current(), nullptr);
   cricket::P2PTransportChannel ch("trigger checks", 1, &pa);
   PrepareChannel(&ch);
@@ skipping 624 matching lines @@
   cricket::Candidate CreateRelayCandidate(const std::string& ip,
                                           int port,
                                           int priority,
                                           const std::string& ufrag = "") {
     cricket::Candidate c = CreateHostCandidate(ip, port, priority, ufrag);
     c.set_type(cricket::RELAY_PORT_TYPE);
     return c;
   }
 
  private:
-  rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+  std::unique_ptr<cricket::BasicPortAllocator> allocator_;
   rtc::FakeNetworkManager network_manager_;
   cricket::TestTurnServer turn_server_;
-  rtc::scoped_ptr<cricket::P2PTransportChannel> channel_;
+  std::unique_ptr<cricket::P2PTransportChannel> channel_;
 };
 
 // Test that Relay/Relay connections will be pinged first when no other
 // connections have been pinged yet, unless we need to ping a trigger check or
 // we have a best connection.
 TEST_F(P2PTransportChannelMostLikelyToWorkFirstTest,
        TestRelayRelayFirstWhenNothingPingedYet) {
   const int max_strong_interval = 100;
   cricket::P2PTransportChannel& ch =
       StartTransportChannel(true, max_strong_interval);
@@ skipping 138 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(cricket::RELAY_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE,
                                cricket::TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(cricket::LOCAL_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE);
 }