Add MakeUnique from chromium and change StunMessage::AddAttribute to take a unique_ptr.

webrtc/p2p/base/turnport.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.
  */
 
 #include "webrtc/p2p/base/turnport.h"
 
 #include <functional>
 
-#include "webrtc/p2p/base/common.h"
-#include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/stringencode.h"
+#include "webrtc/p2p/base/common.h"
+#include "webrtc/p2p/base/stun.h"
 
 namespace cricket {
 
 // TODO(juberti): Move to stun.h when relay messages have been renamed.
 static const int TURN_ALLOCATE_REQUEST = STUN_ALLOCATE_REQUEST;
 
 // TODO(juberti): Extract to turnmessage.h
 static const int TURN_DEFAULT_PORT = 3478;
 static const int TURN_CHANNEL_NUMBER_START = 0x4000;
 static const int TURN_PERMISSION_TIMEOUT = 5 * 60 * 1000;  // 5 minutes
@@ skipping 887 matching lines @@
   return true;
 }
 
 void TurnPort::SendRequest(StunRequest* req, int delay) {
   request_manager_.SendDelayed(req, delay);
 }
 
 void TurnPort::AddRequestAuthInfo(StunMessage* msg) {
   // If we've gotten the necessary data from the server, add it to our request.
   RTC_DCHECK(!hash_.empty());
-  msg->AddAttribute(new StunByteStringAttribute(
+  msg->AddAttribute(rtc::MakeUnique<StunByteStringAttribute>(
       STUN_ATTR_USERNAME, credentials_.username));
-  msg->AddAttribute(new StunByteStringAttribute(
-      STUN_ATTR_REALM, realm_));
-  msg->AddAttribute(new StunByteStringAttribute(
-      STUN_ATTR_NONCE, nonce_));
+  msg->AddAttribute(
+      rtc::MakeUnique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
+  msg->AddAttribute(
+      rtc::MakeUnique<StunByteStringAttribute>(STUN_ATTR_NONCE, nonce_));
   const bool success = msg->AddMessageIntegrity(hash());
   RTC_DCHECK(success);
 }
 
 int TurnPort::Send(const void* data, size_t len,
                    const rtc::PacketOptions& options) {
   return socket_->SendTo(data, len, server_address_.address, options);
 }
 
 void TurnPort::UpdateHash() {
@@ skipping 155 matching lines @@
 }
 
 TurnAllocateRequest::TurnAllocateRequest(TurnPort* port)
     : StunRequest(new TurnMessage()),
       port_(port) {
 }
 
 void TurnAllocateRequest::Prepare(StunMessage* request) {
   // Create the request as indicated in RFC 5766, Section 6.1.
   request->SetType(TURN_ALLOCATE_REQUEST);
-  StunUInt32Attribute* transport_attr = StunAttribute::CreateUInt32(
-      STUN_ATTR_REQUESTED_TRANSPORT);
+  auto transport_attr =
+      StunAttribute::CreateUInt32(STUN_ATTR_REQUESTED_TRANSPORT);
   transport_attr->SetValue(IPPROTO_UDP << 24);
-  request->AddAttribute(transport_attr);
+  request->AddAttribute(std::move(transport_attr));
   if (!port_->hash().empty()) {
     port_->AddRequestAuthInfo(request);
   }
 }
 
 void TurnAllocateRequest::OnSent() {
   LOG_J(LS_INFO, port_) << "TURN allocate request sent"
                         << ", id=" << rtc::hex_encode(id());
   StunRequest::OnSent();
 }
@@ skipping 153 matching lines @@
     : StunRequest(new TurnMessage()),
       port_(port),
       lifetime_(-1) {
 }
 
 void TurnRefreshRequest::Prepare(StunMessage* request) {
   // Create the request as indicated in RFC 5766, Section 7.1.
   // No attributes need to be included.
   request->SetType(TURN_REFRESH_REQUEST);
   if (lifetime_ > -1) {
-    request->AddAttribute(new StunUInt32Attribute(
-        STUN_ATTR_LIFETIME, lifetime_));
+    request->AddAttribute(
+        rtc::MakeUnique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_));
   }
 
   port_->AddRequestAuthInfo(request);
 }
 
 void TurnRefreshRequest::OnSent() {
   LOG_J(LS_INFO, port_) << "TURN refresh request sent"
                         << ", id=" << rtc::hex_encode(id());
   StunRequest::OnSent();
 }
@@ skipping 48 matching lines @@
       port_(port),
       entry_(entry),
       ext_addr_(ext_addr) {
   entry_->SignalDestroyed.connect(
       this, &TurnCreatePermissionRequest::OnEntryDestroyed);
 }
 
 void TurnCreatePermissionRequest::Prepare(StunMessage* request) {
   // Create the request as indicated in RFC5766, Section 9.1.
   request->SetType(TURN_CREATE_PERMISSION_REQUEST);
-  request->AddAttribute(new StunXorAddressAttribute(
+  request->AddAttribute(rtc::MakeUnique<StunXorAddressAttribute>(
       STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
   port_->AddRequestAuthInfo(request);
 }
 
 void TurnCreatePermissionRequest::OnSent() {
   LOG_J(LS_INFO, port_) << "TURN create permission request sent"
                         << ", id=" << rtc::hex_encode(id());
   StunRequest::OnSent();
 }
 
@@ skipping 40 matching lines @@
       entry_(entry),
       channel_id_(channel_id),
       ext_addr_(ext_addr) {
   entry_->SignalDestroyed.connect(
       this, &TurnChannelBindRequest::OnEntryDestroyed);
 }
 
 void TurnChannelBindRequest::Prepare(StunMessage* request) {
   // Create the request as indicated in RFC5766, Section 11.1.
   request->SetType(TURN_CHANNEL_BIND_REQUEST);
-  request->AddAttribute(new StunUInt32Attribute(
+  request->AddAttribute(rtc::MakeUnique<StunUInt32Attribute>(
       STUN_ATTR_CHANNEL_NUMBER, channel_id_ << 16));
-  request->AddAttribute(new StunXorAddressAttribute(
+  request->AddAttribute(rtc::MakeUnique<StunXorAddressAttribute>(
       STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
   port_->AddRequestAuthInfo(request);
 }
 
 void TurnChannelBindRequest::OnSent() {
   LOG_J(LS_INFO, port_) << "TURN channel bind request sent"
                         << ", id=" << rtc::hex_encode(id());
   StunRequest::OnSent();
 }
 
@@ skipping 61 matching lines @@
 
 int TurnEntry::Send(const void* data, size_t size, bool payload,
                     const rtc::PacketOptions& options) {
   rtc::ByteBufferWriter buf;
   if (state_ != STATE_BOUND) {
     // If we haven't bound the channel yet, we have to use a Send Indication.
     TurnMessage msg;
     msg.SetType(TURN_SEND_INDICATION);
     msg.SetTransactionID(
         rtc::CreateRandomString(kStunTransactionIdLength));
-    msg.AddAttribute(new StunXorAddressAttribute(
+    msg.AddAttribute(rtc::MakeUnique<StunXorAddressAttribute>(
         STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
-    msg.AddAttribute(new StunByteStringAttribute(
-        STUN_ATTR_DATA, data, size));
+    msg.AddAttribute(
+        rtc::MakeUnique<StunByteStringAttribute>(STUN_ATTR_DATA, data, size));
     const bool success = msg.Write(&buf);
     RTC_DCHECK(success);
 
     // If we're sending real data, request a channel bind that we can use later.
     if (state_ == STATE_UNBOUND && payload) {
       SendChannelBindRequest(0);
       state_ = STATE_BINDING;
     }
   } else {
     // If the channel is bound, we can send the data as a Channel Message.
@@ skipping 62 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket