Convert Pass()→std::move() in //device

device/serial/data_receiver.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 "device/serial/data_receiver.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 
 namespace device {
 
 // Represents a receive that is not yet fulfilled.
 class DataReceiver::PendingReceive {
  public:
   PendingReceive(DataReceiver* receiver,
@@ skipping 58 matching lines @@
   PendingReceive* pending_receive_;
 
   const char* buffer_;
   uint32_t buffer_size_;
 };
 
 // A buffer of data or an error received from the DataSource.
 struct DataReceiver::DataFrame {
   explicit DataFrame(mojo::Array<uint8_t> data)
       : is_error(false),
-        data(data.Pass()),
+        data(std::move(data)),
         offset(0),
         error(0),
         dispatched(false) {}
 
   explicit DataFrame(int32_t error)
       : is_error(true), offset(0), error(error), dispatched(false) {}
 
   // Whether this DataFrame represents an error.
   bool is_error;
 
   // The data received from the DataSource.
   mojo::Array<uint8_t> data;
 
   // The offset within |data| at which the next read should begin.
   uint32_t offset;
 
   // The value of the error that occurred.
   const int32_t error;
 
   // Whether the error has been dispatched to the user.
   bool dispatched;
 };
 
 DataReceiver::DataReceiver(
     mojo::InterfacePtr<serial::DataSource> source,
     mojo::InterfaceRequest<serial::DataSourceClient> client,
     uint32_t buffer_size,
     int32_t fatal_error_value)
-    : source_(source.Pass()),
-      client_(this, client.Pass()),
+    : source_(std::move(source)),
+      client_(this, std::move(client)),
       fatal_error_value_(fatal_error_value),
       shut_down_(false),
       weak_factory_(this) {
   source_.set_connection_error_handler(
       base::Bind(&DataReceiver::OnConnectionError, base::Unretained(this)));
   source_->Init(buffer_size);
   client_.set_connection_error_handler(
       base::Bind(&DataReceiver::OnConnectionError, base::Unretained(this)));
 }
 
@@ skipping 25 matching lines @@
 void DataReceiver::OnError(int32_t error) {
   if (shut_down_)
     return;
 
   pending_data_frames_.push(linked_ptr<DataFrame>(new DataFrame(error)));
   if (pending_receive_)
     ReceiveInternal();
 }
 
 void DataReceiver::OnData(mojo::Array<uint8_t> data) {
-  pending_data_frames_.push(linked_ptr<DataFrame>(new DataFrame(data.Pass())));
+  pending_data_frames_.push(
+      linked_ptr<DataFrame>(new DataFrame(std::move(data))));
   if (pending_receive_)
     ReceiveInternal();
 }
 
 void DataReceiver::OnConnectionError() {
   ShutDown();
 }
 
 void DataReceiver::Done(uint32_t bytes_consumed) {
   if (shut_down_)
@@ skipping 108 matching lines @@
   buffer_size_ = 0;
 }
 
 void DataReceiver::PendingReceive::Buffer::DoneWithError(
     uint32_t bytes_consumed,
     int32_t error) {
   Done(bytes_consumed);
 }
 
 }  // namespace device