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

device/serial/data_source_unittest.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 <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "device/serial/buffer.h"
 #include "device/serial/data_receiver.h"
 #include "device/serial/data_source_sender.h"
 #include "device/serial/data_stream.mojom.h"
@@ skipping 17 matching lines @@
 
   void SetUp() override {
     message_loop_.reset(new base::MessageLoop);
     mojo::InterfacePtr<serial::DataSource> source_sender_handle;
     mojo::InterfacePtr<serial::DataSourceClient> source_sender_client_handle;
     mojo::InterfaceRequest<serial::DataSourceClient>
         source_sender_client_request =
             mojo::GetProxy(&source_sender_client_handle);
     source_sender_ = new DataSourceSender(
         mojo::GetProxy(&source_sender_handle),
-        source_sender_client_handle.Pass(),
+        std::move(source_sender_client_handle),
         base::Bind(&DataSourceTest::CanWriteData, base::Unretained(this)),
         base::Bind(&DataSourceTest::OnError, base::Unretained(this)));
-    receiver_ =
-        new DataReceiver(source_sender_handle.Pass(),
-                         source_sender_client_request.Pass(), 100, kFatalError);
+    receiver_ = new DataReceiver(std::move(source_sender_handle),
+                                 std::move(source_sender_client_request), 100,
+                                 kFatalError);
   }
 
   void TearDown() override {
     write_buffer_.reset();
     buffer_.reset();
     message_loop_.reset();
   }
 
   void OnError() {
     seen_connection_error_ = true;
@@ skipping 35 matching lines @@
 
   void ReceiveAndWait() {
     ASSERT_TRUE(Receive());
     // Run the message loop until OnDataReceived or OnReceiveError is called.
     WaitForEvent(EVENT_RECEIVE_COMPLETE);
   }
 
   void OnDataReceived(scoped_ptr<ReadOnlyBuffer> buffer) {
     ASSERT_TRUE(buffer);
     error_ = 0;
-    buffer_ = buffer.Pass();
+    buffer_ = std::move(buffer);
     buffer_contents_ = std::string(buffer_->GetData(), buffer_->GetSize());
     EventReceived(EVENT_RECEIVE_COMPLETE);
   }
 
   void OnReceiveError(int32_t error) {
     buffer_contents_.clear();
     error_ = error;
     EventReceived(EVENT_RECEIVE_COMPLETE);
   }
 
   void CanWriteData(scoped_ptr<WritableBuffer> buffer) {
-    write_buffer_ = buffer.Pass();
+    write_buffer_ = std::move(buffer);
     EventReceived(EVENT_WRITE_BUFFER_READY);
   }
 
  protected:
   static const int32_t kFatalError;
   scoped_ptr<base::MessageLoop> message_loop_;
   base::Closure stop_run_loop_;
 
   scoped_refptr<DataSourceSender> source_sender_;
   scoped_refptr<DataReceiver> receiver_;
@@ skipping 125 matching lines @@
 // Test that the receiver shutting down is correctly reported to the source.
 TEST_F(DataSourceTest, ReceiverShutdown) {
   Receive();
   receiver_ = NULL;
   EXPECT_EQ(kFatalError, error_);
   WaitForEvent(EVENT_ERROR);
   EXPECT_TRUE(seen_connection_error_);
 }
 
 }  // namespace device