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

webrtc/p2p/base/relayport.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 <algorithm>
@@ skipping 558 matching lines @@
   // Otherwise, we must wrap the given data in a STUN SEND request so that we
   // can communicate the destination address to the server.
   //
   // Note that we do not use a StunRequest here.  This is because there is
   // likely no reason to resend this packet. If it is late, we just drop it.
   // The next send to this address will try again.
 
   RelayMessage request;
   request.SetType(STUN_SEND_REQUEST);
 
-  StunByteStringAttribute* magic_cookie_attr =
+  auto magic_cookie_attr =
       StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
   magic_cookie_attr->CopyBytes(TURN_MAGIC_COOKIE_VALUE,
                                sizeof(TURN_MAGIC_COOKIE_VALUE));
-  request.AddAttribute(magic_cookie_attr);
+  request.AddAttribute(std::move(magic_cookie_attr));
 
-  StunByteStringAttribute* username_attr =
-      StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+  auto username_attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   username_attr->CopyBytes(port_->username_fragment().c_str(),
                            port_->username_fragment().size());
-  request.AddAttribute(username_attr);
+  request.AddAttribute(std::move(username_attr));
 
-  StunAddressAttribute* addr_attr =
-      StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+  auto addr_attr = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   addr_attr->SetIP(addr.ipaddr());
   addr_attr->SetPort(addr.port());
-  request.AddAttribute(addr_attr);
+  request.AddAttribute(std::move(addr_attr));
 
   // Attempt to lock
   if (ext_addr_ == addr) {
-    StunUInt32Attribute* options_attr =
-      StunAttribute::CreateUInt32(STUN_ATTR_OPTIONS);
+    auto options_attr = StunAttribute::CreateUInt32(STUN_ATTR_OPTIONS);
     options_attr->SetValue(0x1);
-    request.AddAttribute(options_attr);
+    request.AddAttribute(std::move(options_attr));
   }
 
-  StunByteStringAttribute* data_attr =
-      StunAttribute::CreateByteString(STUN_ATTR_DATA);
+  auto data_attr = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   data_attr->CopyBytes(data, size);
-  request.AddAttribute(data_attr);
+  request.AddAttribute(std::move(data_attr));
 
   // TODO: compute the HMAC.
 
   rtc::ByteBufferWriter buf;
   request.Write(&buf);
 
   return SendPacket(buf.Data(), buf.Length(), options);
 }
 
 void RelayEntry::ScheduleKeepAlive() {
@@ skipping 161 matching lines @@
                                  RelayConnection* connection)
     : StunRequest(new RelayMessage()),
       entry_(entry),
       connection_(connection) {
   start_time_ = rtc::TimeMillis();
 }
 
 void AllocateRequest::Prepare(StunMessage* request) {
   request->SetType(STUN_ALLOCATE_REQUEST);
 
-  StunByteStringAttribute* username_attr =
-      StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+  auto username_attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   username_attr->CopyBytes(
       entry_->port()->username_fragment().c_str(),
       entry_->port()->username_fragment().size());
-  request->AddAttribute(username_attr);
+  request->AddAttribute(std::move(username_attr));
 }
 
 void AllocateRequest::OnSent() {
   count_ += 1;
   if (count_ == 5)
     timeout_ = true;
 }
 
 int AllocateRequest::resend_delay() {
   if (count_ == 0) {
@@ skipping 33 matching lines @@
   if (rtc::TimeMillis() - start_time_ <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
 void AllocateRequest::OnTimeout() {
   LOG(INFO) << "Allocate request timed out";
   entry_->HandleConnectFailure(connection_->socket());
 }
 
 }  // namespace cricket