Use vectors instead of IOBuffer for U2fPackets

device/u2f/u2f_hid_device.cc

 // Copyright 2017 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 "u2f_hid_device.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "crypto/random.h"
@@ skipping 179 matching lines @@
 
   connection_->Read(base::Bind(&U2fHidDevice::OnRead,
                                weak_factory_.GetWeakPtr(),
                                base::Passed(&callback)));
 }
 
 void U2fHidDevice::OnRead(U2fHidMessageCallback callback,
                           bool success,
                           scoped_refptr<net::IOBuffer> buf,
                           size_t size) {
-  if (!success) {
+  if (!success || !buf) {
     std::move(callback).Run(success, nullptr);
     return;
   }
 
-  scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(size));
-  memcpy(buffer->data(), buf->data(), size);
+  std::vector<uint8_t> read_buffer(buf->data(), buf->data() + size);
   std::unique_ptr<U2fMessage> read_message =
-      U2fMessage::CreateFromSerializedData(buffer);
+      U2fMessage::CreateFromSerializedData(read_buffer);
 
   if (!read_message) {
     std::move(callback).Run(false, nullptr);
     return;
   }
 
   // Received a message from a different channel, so try again
   if (channel_id_ != read_message->channel_id()) {
     connection_->Read(base::Bind(&U2fHidDevice::OnRead,
                                  weak_factory_.GetWeakPtr(),
@@ skipping 10 matching lines @@
   connection_->Read(
       base::Bind(&U2fHidDevice::OnReadContinuation, weak_factory_.GetWeakPtr(),
                  base::Passed(&read_message), base::Passed(&callback)));
 }
 
 void U2fHidDevice::OnReadContinuation(std::unique_ptr<U2fMessage> message,
                                       U2fHidMessageCallback callback,
                                       bool success,
                                       scoped_refptr<net::IOBuffer> buf,
                                       size_t size) {
-  if (!success) {
+  if (!success || !buf) {
     std::move(callback).Run(success, nullptr);
     return;
   }
 
-  scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(size));
-  memcpy(buffer->data(), buf->data(), size);
-  message->AddContinuationPacket(buffer);
+  std::vector<uint8_t> read_buffer(buf->data(), buf->data() + size);
+  message->AddContinuationPacket(read_buffer);
   if (message->MessageComplete()) {
     std::move(callback).Run(success, std::move(message));
     return;
   }
   connection_->Read(
       base::Bind(&U2fHidDevice::OnReadContinuation, weak_factory_.GetWeakPtr(),
                  base::Passed(&message), base::Passed(&callback)));
 }
 
 void U2fHidDevice::MessageReceived(const DeviceCallback& callback,
@@ skipping 48 matching lines @@
   return id.str();
 }
 
 // static
 bool U2fHidDevice::IsTestEnabled() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kEnableU2fHidTest);
 }
 
 }  // namespace device