Use unique pointers for U2fPacket and U2fMessage

device/u2f/u2f_packet.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "device/u2f/u2f_packet.h"
+#include "base/memory/ptr_util.h"
 #include "net/base/io_buffer.h"
 
+#include "u2f_packet.h"
+
 namespace device {
 
 U2fPacket::U2fPacket(const std::vector<uint8_t> data, const uint32_t channel_id)
     : data_(data), channel_id_(channel_id) {}
 
 U2fPacket::U2fPacket() {}
 
 U2fPacket::~U2fPacket() {}
 
 scoped_refptr<net::IOBufferWithSize> U2fPacket::GetSerializedBuffer() {
@@ skipping 33 matching lines @@
   payload_length_ = payload_length;
   serialized_->data()[index++] = (payload_length >> 8) & 0xff;
   serialized_->data()[index++] = payload_length & 0xff;
   for (size_t data_idx = 0; data_idx < data_.size(); ++data_idx)
     serialized_->data()[index++] = data_.at(data_idx);
   while (static_cast<int>(index) < serialized_->size())
     serialized_->data()[index++] = 0;
 }
 
 // static
-scoped_refptr<U2fInitPacket> U2fInitPacket::CreateFromSerializedData(
+std::unique_ptr<U2fInitPacket> U2fInitPacket::CreateFromSerializedData(
     scoped_refptr<net::IOBufferWithSize> buf,
     size_t* remaining_size) {
   if (buf == nullptr || remaining_size == nullptr || buf->size() != kPacketSize)
     return nullptr;
 
-  return make_scoped_refptr(new U2fInitPacket(buf, remaining_size));
+  return base::MakeUnique<U2fInitPacket>(buf, remaining_size);
 }
 
 U2fInitPacket::U2fInitPacket(scoped_refptr<net::IOBufferWithSize> buf,
                              size_t* remaining_size) {
   // Report ID is at index 0, so start at index 1 for channel ID
   size_t index = 1;
   uint16_t payload_size = 0;
   uint16_t data_size = 0;
 
   channel_id_ = (buf->data()[index++] & 0xff) << 24;
@@ skipping 42 matching lines @@
 
   serialized_->data()[index++] = sequence_;
   for (size_t idx = 0; idx < data_.size(); ++idx)
     serialized_->data()[index++] = data_.at(idx);
 
   while (static_cast<int>(index) < serialized_->size())
     serialized_->data()[index++] = 0;
 }
 
 // static
-scoped_refptr<U2fContinuationPacket>
+std::unique_ptr<U2fContinuationPacket>
 U2fContinuationPacket::CreateFromSerializedData(
     scoped_refptr<net::IOBufferWithSize> buf,
     size_t* remaining_size) {
   if (buf == nullptr || remaining_size == nullptr || buf->size() != kPacketSize)
     return nullptr;
 
-  return make_scoped_refptr(new U2fContinuationPacket(buf, remaining_size));
+  return base::MakeUnique<U2fContinuationPacket>(buf, remaining_size);
 }
 
 U2fContinuationPacket::U2fContinuationPacket(
     scoped_refptr<net::IOBufferWithSize> buf,
     size_t* remaining_size) {
   // Report ID is at index 0, so start at index 1 for channel ID
   size_t index = 1;
   size_t data_size;
 
   channel_id_ = (buf->data()[index++] & 0xff) << 24;
   channel_id_ |= (buf->data()[index++] & 0xff) << 16;
   channel_id_ |= (buf->data()[index++] & 0xff) << 8;
   channel_id_ |= buf->data()[index++] & 0xff;
   sequence_ = buf->data()[index++];
 
   // Check to see if packet payload is less than maximum size and padded with 0s
   data_size = std::min(*remaining_size, kPacketSize - index);
   *remaining_size -= data_size;
   data_.insert(std::end(data_), &buf->data()[index],
                &buf->data()[index + data_size]);
 
   // Incoming buffer may not be padded with 0's, so manually update buffer
   for (int i = index + data_size; i < buf->size(); ++i)
     buf->data()[i] = 0;
   serialized_ = buf;
 }
 
 U2fContinuationPacket::~U2fContinuationPacket() {}
+
 }  // namespace device