Use IOBufferWithSize instead of storing IOBuffer and size separately.

chrome/browser/devtools/device/usb/android_usb_device.cc

 // Copyright 2014 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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
@@ skipping 382 matching lines @@
   if (message->command == AdbMessage::kCommandAUTH &&
       message->arg0 == AdbMessage::kAuthSignature)
     append_zero = false;
   if (message->command == AdbMessage::kCommandWRTE)
     append_zero = false;
 
   size_t body_length = message->body.length() + (append_zero ? 1 : 0);
   header.push_back(body_length);
   header.push_back(Checksum(message->body));
   header.push_back(message->command ^ 0xffffffff);
-  scoped_refptr<net::IOBuffer> header_buffer = new net::IOBuffer(kHeaderSize);
+  scoped_refptr<net::IOBufferWithSize> header_buffer =
+      new net::IOBufferWithSize(kHeaderSize);
   memcpy(header_buffer.get()->data(), &header[0], kHeaderSize);
-  outgoing_queue_.push(std::make_pair(header_buffer, kHeaderSize));
+  outgoing_queue_.push(header_buffer);
 
   // Queue body.
   if (!message->body.empty()) {
-    scoped_refptr<net::IOBuffer> body_buffer = new net::IOBuffer(body_length);
+    scoped_refptr<net::IOBufferWithSize> body_buffer =
+        new net::IOBufferWithSize(body_length);
     memcpy(body_buffer->data(), message->body.data(), message->body.length());
     if (append_zero)
       body_buffer->data()[body_length - 1] = 0;
-    outgoing_queue_.push(std::make_pair(body_buffer, body_length));
+    outgoing_queue_.push(body_buffer);
     if (zero_mask_ && (body_length & zero_mask_) == 0) {
       // Send a zero length packet.
-      outgoing_queue_.push(std::make_pair(body_buffer, 0));
+      outgoing_queue_.push(new net::IOBufferWithSize(0));
     }
   }
   ProcessOutgoing();
 }
 
 void AndroidUsbDevice::ProcessOutgoing() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (outgoing_queue_.empty() || !usb_handle_)
     return;
 
   BulkMessage message = outgoing_queue_.front();
   outgoing_queue_.pop();
-  DumpMessage(true, message.first->data(), message.second);
+  DumpMessage(true, message->data(), message->size());
   usb_handle_->BulkTransfer(
       usb_service::USB_DIRECTION_OUTBOUND, outbound_address_,
-      message.first, message.second, kUsbTimeout,
+      message, message->size(), kUsbTimeout,
       base::Bind(&AndroidUsbDevice::OutgoingMessageSent,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::OutgoingMessageSent(UsbTransferStatus status,
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (status != usb_service::USB_TRANSFER_COMPLETED)
@@ skipping 199 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }