Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/base/port.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 "webrtc/p2p/base/port.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/network.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 
 namespace {
 
 // Determines whether we have seen at least the given maximum number of
 // pings fail to have a response.
 inline bool TooManyFailures(
     const std::vector<cricket::Connection::SentPing>& pings_since_last_response,
     uint32_t maximum_failures,
@@ skipping 236 matching lines @@
     const char* data, size_t size, const rtc::SocketAddress& addr,
     ProtocolType proto) {
   // If the user has enabled port packets, just hand this over.
   if (enable_port_packets_) {
     SignalReadPacket(this, data, size, addr);
     return;
   }
 
   // If this is an authenticated STUN request, then signal unknown address and
   // send back a proper binding response.
-  rtc::scoped_ptr<IceMessage> msg;
+  std::unique_ptr<IceMessage> msg;
   std::string remote_username;
   if (!GetStunMessage(data, size, addr, &msg, &remote_username)) {
     LOG_J(LS_ERROR, this) << "Received non-STUN packet from unknown address ("
                           << addr.ToSensitiveString() << ")";
   } else if (!msg) {
     // STUN message handled already
   } else if (msg->type() == STUN_BINDING_REQUEST) {
     LOG(LS_INFO) << "Received STUN ping "
                  << " id=" << rtc::hex_encode(msg->transaction_id())
                  << " from unknown address " << addr.ToSensitiveString();
@@ skipping 26 matching lines @@
 }
 
 size_t Port::AddPrflxCandidate(const Candidate& local) {
   candidates_.push_back(local);
   return (candidates_.size() - 1);
 }
 
 bool Port::GetStunMessage(const char* data,
                           size_t size,
                           const rtc::SocketAddress& addr,
-                          rtc::scoped_ptr<IceMessage>* out_msg,
+                          std::unique_ptr<IceMessage>* out_msg,
                           std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
   //       this probably isn't worth worrying about.
   ASSERT(out_msg != NULL);
   ASSERT(out_username != NULL);
   out_username->clear();
 
   // Don't bother parsing the packet if we can tell it's not STUN.
   // In ICE mode, all STUN packets will have a valid fingerprint.
   if (!StunMessage::ValidateFingerprint(data, size)) {
     return false;
   }
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
-  rtc::scoped_ptr<IceMessage> stun_msg(new IceMessage());
+  std::unique_ptr<IceMessage> stun_msg(new IceMessage());
   rtc::ByteBufferReader buf(data, size);
   if (!stun_msg->Read(&buf) || (buf.Length() > 0)) {
     return false;
   }
 
   if (stun_msg->type() == STUN_BINDING_REQUEST) {
     // Check for the presence of USERNAME and MESSAGE-INTEGRITY (if ICE) first.
     // If not present, fail with a 400 Bad Request.
     if (!stun_msg->GetByteString(STUN_ATTR_USERNAME) ||
         !stun_msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY)) {
@@ skipping 532 matching lines @@
       data, size, remote_candidate_.address(), options, false);
   if (err < 0) {
     LOG_J(LS_WARNING, this) << "Failed to send STUN ping "
                             << " err=" << err
                             << " id=" << rtc::hex_encode(req->id());
   }
 }
 
 void Connection::OnReadPacket(
   const char* data, size_t size, const rtc::PacketTime& packet_time) {
-  rtc::scoped_ptr<IceMessage> msg;
+  std::unique_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
   if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // This is a data packet, pass it along.
     set_receiving(true);
     last_data_received_ = rtc::Time64();
     recv_rate_tracker_.AddSamples(size);
     SignalReadPacket(this, data, size, packet_time);
 
@@ skipping 541 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket