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

webrtc/p2p/base/stun.h

 /*
  *  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.
  */
 
@@ skipping 141 matching lines @@
   const StunAddressAttribute* GetAddress(int type) const;
   const StunUInt32Attribute* GetUInt32(int type) const;
   const StunUInt64Attribute* GetUInt64(int type) const;
   const StunByteStringAttribute* GetByteString(int type) const;
 
   // Gets these specific attribute values.
   const StunErrorCodeAttribute* GetErrorCode() const;
   const StunUInt16ListAttribute* GetUnknownAttributes() const;
 
   // Takes ownership of the specified attribute and adds it to the message.
-  // TODO(zstein): Take a unique_ptr instead of a raw pointer.
-  void AddAttribute(StunAttribute* attr);
+  void AddAttribute(std::unique_ptr<StunAttribute> attr);
 
   // Validates that a raw STUN message has a correct MESSAGE-INTEGRITY value.
   // This can't currently be done on a StunMessage, since it is affected by
   // padding data (which we discard when reading a StunMessage).
   static bool ValidateMessageIntegrity(const char* data, size_t size,
                                        const std::string& password);
   // Adds a MESSAGE-INTEGRITY attribute that is valid for the current message.
   bool AddMessageIntegrity(const std::string& password);
   bool AddMessageIntegrity(const char* key, size_t keylen);
 
@@ skipping 52 matching lines @@
   // value is true if successful.
   virtual bool Write(rtc::ByteBufferWriter* buf) const = 0;
 
   // Creates an attribute object with the given type and smallest length.
   static StunAttribute* Create(StunAttributeValueType value_type,
                                uint16_t type,
                                uint16_t length,
                                StunMessage* owner);
   // TODO: Allow these create functions to take parameters, to reduce
   // the amount of work callers need to do to initialize attributes.
-  static StunAddressAttribute* CreateAddress(uint16_t type);
-  static StunXorAddressAttribute* CreateXorAddress(uint16_t type);
-  static StunUInt32Attribute* CreateUInt32(uint16_t type);
-  static StunUInt64Attribute* CreateUInt64(uint16_t type);
-  static StunByteStringAttribute* CreateByteString(uint16_t type);
-  static StunErrorCodeAttribute* CreateErrorCode();
-  static StunUInt16ListAttribute* CreateUnknownAttributes();
+  static std::unique_ptr<StunAddressAttribute> CreateAddress(uint16_t type);
+  static std::unique_ptr<StunXorAddressAttribute> CreateXorAddress(
+      uint16_t type);
+  static std::unique_ptr<StunUInt32Attribute> CreateUInt32(uint16_t type);
+  static std::unique_ptr<StunUInt64Attribute> CreateUInt64(uint16_t type);
+  static std::unique_ptr<StunByteStringAttribute> CreateByteString(
+      uint16_t type);
+  static std::unique_ptr<StunErrorCodeAttribute> CreateErrorCode();
+  static std::unique_ptr<StunUInt16ListAttribute> CreateUnknownAttributes();
 
  protected:
   StunAttribute(uint16_t type, uint16_t length);
   void SetLength(uint16_t length) { length_ = length; }
   void WritePadding(rtc::ByteBufferWriter* buf) const;
   void ConsumePadding(rtc::ByteBufferReader* buf) const;
 
  private:
   uint16_t type_;
   uint16_t length_;
@@ skipping 152 matching lines @@
 
  private:
   void SetBytes(char* bytes, size_t length);
 
   char* bytes_;
 };
 
 // Implements STUN attributes that record an error code.
 class StunErrorCodeAttribute : public StunAttribute {
  public:
-  static const uint16_t MIN_SIZE = 4;
+  static const uint16_t MIN_SIZE;
   StunErrorCodeAttribute(uint16_t type, int code, const std::string& reason);
   StunErrorCodeAttribute(uint16_t type, uint16_t length);
   ~StunErrorCodeAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_ERROR_CODE;
   }
 
   // The combined error and class, e.g. 0x400.
   int code() const;
@@ skipping 205 matching lines @@
       case STUN_ATTR_ICE_CONTROLLING: return STUN_VALUE_UINT64;
       default: return StunMessage::GetAttributeValueType(type);
     }
   }
   virtual StunMessage* CreateNew() const { return new IceMessage(); }
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_STUN_H_