Move all Pass() calls in blimp/ to std::move()

Updated all .Pass() methods to be std::move() now that is approved for
Chromium code.

BUG=557422

Review URL: https://codereview.chromium.org/1473933002

Cr-Commit-Position: refs/heads/master@{#362211}

10 files changed, 34 insertions, 28 deletions

diff --git a/blimp/net/blimp_connection.cc b/blimp/net/blimp_connection.cc
index e7db062..a79ffe0 100644
--- a/blimp/net/blimp_connection.cc
+++ b/blimp/net/blimp_connection.cc
@@ -95,9 +95,9 @@ void BlimpMessageSender::OnWritePacketComplete(int result) {
 
 BlimpConnection::BlimpConnection(scoped_ptr<PacketReader> reader,
                                  scoped_ptr<PacketWriter> writer)
-    : reader_(reader.Pass()),
+    : reader_(std::move(reader)),
       message_pump_(new BlimpMessagePump(reader_.get())),
-      writer_(writer.Pass()),
+      writer_(std::move(writer)),
       outgoing_msg_processor_(new BlimpMessageSender(writer_.get())) {
   DCHECK(writer_);
 }
diff --git a/blimp/net/blimp_connection_unittest.cc b/blimp/net/blimp_connection_unittest.cc
index 82a547b..66d0658 100644
--- a/blimp/net/blimp_connection_unittest.cc
+++ b/blimp/net/blimp_connection_unittest.cc
@@ -32,15 +32,16 @@ namespace {
 class BlimpConnectionTest : public testing::Test {
  public:
   BlimpConnectionTest() {
-    message1_ = CreateInputMessage().Pass();
-    message2_ = CreateControlMessage().Pass();
+    message1_ = CreateInputMessage();
+    message2_ = CreateControlMessage();
     scoped_ptr<testing::StrictMock<MockPacketReader>> reader(
         new testing::StrictMock<MockPacketReader>);
     reader_ = reader.get();
     scoped_ptr<testing::StrictMock<MockPacketWriter>> writer(
         new testing::StrictMock<MockPacketWriter>);
     writer_ = writer.get();
-    connection_.reset(new BlimpConnection(reader.Pass(), writer.Pass()));
+    connection_.reset(new BlimpConnection(std::move(reader),
+                                          std::move(writer)));
     connection_->SetConnectionErrorObserver(&error_observer_);
   }
 
@@ -49,13 +50,13 @@ class BlimpConnectionTest : public testing::Test {
   scoped_ptr<BlimpMessage> CreateInputMessage() {
     scoped_ptr<BlimpMessage> msg(new BlimpMessage);
     msg->set_type(BlimpMessage::INPUT);
-    return msg.Pass();
+    return msg;
   }
 
   scoped_ptr<BlimpMessage> CreateControlMessage() {
     scoped_ptr<BlimpMessage> msg(new BlimpMessage);
     msg->set_type(BlimpMessage::CONTROL);
-    return msg.Pass();
+    return msg;
   }
 
  protected:
@@ -101,10 +102,11 @@ TEST_F(BlimpConnectionTest, SyncTwoPacketsWrite) {
 
   BlimpMessageProcessor* sender = connection_->GetOutgoingMessageProcessor();
   net::TestCompletionCallback complete_cb_1;
-  sender->ProcessMessage(CreateInputMessage().Pass(), complete_cb_1.callback());
+  sender->ProcessMessage(CreateInputMessage(),
+                         complete_cb_1.callback());
   EXPECT_EQ(net::OK, complete_cb_1.WaitForResult());
   net::TestCompletionCallback complete_cb_2;
-  sender->ProcessMessage(CreateControlMessage().Pass(),
+  sender->ProcessMessage(CreateControlMessage(),
                          complete_cb_2.callback());
   EXPECT_EQ(net::OK, complete_cb_2.WaitForResult());
 }
@@ -123,10 +125,11 @@ TEST_F(BlimpConnectionTest, SyncTwoPacketsWriteWithError) {
 
   BlimpMessageProcessor* sender = connection_->GetOutgoingMessageProcessor();
   net::TestCompletionCallback complete_cb_1;
-  sender->ProcessMessage(CreateInputMessage().Pass(), complete_cb_1.callback());
+  sender->ProcessMessage(CreateInputMessage(),
+                         complete_cb_1.callback());
   EXPECT_EQ(net::OK, complete_cb_1.WaitForResult());
   net::TestCompletionCallback complete_cb_2;
-  sender->ProcessMessage(CreateControlMessage().Pass(),
+  sender->ProcessMessage(CreateControlMessage(),
                          complete_cb_2.callback());
   EXPECT_EQ(net::ERR_FAILED, complete_cb_2.WaitForResult());
 }
@@ -148,14 +151,15 @@ TEST_F(BlimpConnectionTest, AsyncTwoPacketsWrite) {
   BlimpMessageProcessor* sender = connection_->GetOutgoingMessageProcessor();
   net::TestCompletionCallback complete_cb_1;
   ASSERT_TRUE(write_packet_cb.is_null());
-  sender->ProcessMessage(CreateInputMessage().Pass(), complete_cb_1.callback());
+  sender->ProcessMessage(CreateInputMessage(),
+                         complete_cb_1.callback());
   ASSERT_FALSE(write_packet_cb.is_null());
   base::ResetAndReturn(&write_packet_cb).Run(net::OK);
   EXPECT_EQ(net::OK, complete_cb_1.WaitForResult());
 
   net::TestCompletionCallback complete_cb_2;
   ASSERT_TRUE(write_packet_cb.is_null());
-  sender->ProcessMessage(CreateControlMessage().Pass(),
+  sender->ProcessMessage(CreateControlMessage(),
                          complete_cb_2.callback());
   ASSERT_FALSE(write_packet_cb.is_null());
   base::ResetAndReturn(&write_packet_cb).Run(net::OK);
@@ -180,12 +184,13 @@ TEST_F(BlimpConnectionTest, AsyncTwoPacketsWriteWithError) {
 
   BlimpMessageProcessor* sender = connection_->GetOutgoingMessageProcessor();
   net::TestCompletionCallback complete_cb_1;
-  sender->ProcessMessage(CreateInputMessage().Pass(), complete_cb_1.callback());
+  sender->ProcessMessage(CreateInputMessage(),
+                         complete_cb_1.callback());
   base::ResetAndReturn(&write_packet_cb).Run(net::OK);
   EXPECT_EQ(net::OK, complete_cb_1.WaitForResult());
 
   net::TestCompletionCallback complete_cb_2;
-  sender->ProcessMessage(CreateControlMessage().Pass(),
+  sender->ProcessMessage(CreateControlMessage(),
                          complete_cb_2.callback());
   base::ResetAndReturn(&write_packet_cb).Run(net::ERR_FAILED);
   EXPECT_EQ(net::ERR_FAILED, complete_cb_2.WaitForResult());
diff --git a/blimp/net/blimp_message_demultiplexer.cc b/blimp/net/blimp_message_demultiplexer.cc
index e4992be..6a1fa64 100644
--- a/blimp/net/blimp_message_demultiplexer.cc
+++ b/blimp/net/blimp_message_demultiplexer.cc
@@ -44,7 +44,7 @@ void BlimpMessageDemultiplexer::ProcessMessage(
     }
   }
 
-  receiver_iter->second->ProcessMessage(message.Pass(), callback);
+  receiver_iter->second->ProcessMessage(std::move(message), callback);
 }
 
 }  // namespace blimp
diff --git a/blimp/net/blimp_message_demultiplexer_unittest.cc b/blimp/net/blimp_message_demultiplexer_unittest.cc
index 6101adf..7ab9333 100644
--- a/blimp/net/blimp_message_demultiplexer_unittest.cc
+++ b/blimp/net/blimp_message_demultiplexer_unittest.cc
@@ -46,7 +46,7 @@ TEST_F(BlimpMessageDemultiplexerTest, ProcessMessageOK) {
   EXPECT_CALL(receiver1_, MockableProcessMessage(Ref(*input_msg_), _))
       .WillOnce(SaveArg<1>(&captured_cb_));
   net::TestCompletionCallback cb;
-  demux_.ProcessMessage(input_msg_.Pass(), cb.callback());
+  demux_.ProcessMessage(std::move(input_msg_), cb.callback());
   captured_cb_.Run(net::OK);
   EXPECT_EQ(net::OK, cb.WaitForResult());
 }
@@ -55,7 +55,7 @@ TEST_F(BlimpMessageDemultiplexerTest, ProcessMessageFailed) {
   EXPECT_CALL(receiver2_, MockableProcessMessage(Ref(*compositor_msg_), _))
       .WillOnce(SaveArg<1>(&captured_cb_));
   net::TestCompletionCallback cb2;
-  demux_.ProcessMessage(compositor_msg_.Pass(), cb2.callback());
+  demux_.ProcessMessage(std::move(compositor_msg_), cb2.callback());
   captured_cb_.Run(net::ERR_FAILED);
   EXPECT_EQ(net::ERR_FAILED, cb2.WaitForResult());
 }
diff --git a/blimp/net/blimp_message_multiplexer.cc b/blimp/net/blimp_message_multiplexer.cc
index 644d747..4d4703b 100644
--- a/blimp/net/blimp_message_multiplexer.cc
+++ b/blimp/net/blimp_message_multiplexer.cc
@@ -44,7 +44,7 @@ void MultiplexedSender::ProcessMessage(
   } else {
     message->set_type(type_);
   }
-  output_processor_->ProcessMessage(message.Pass(), callback);
+  output_processor_->ProcessMessage(std::move(message), callback);
 }
 
 }  // namespace
diff --git a/blimp/net/blimp_message_multiplexer_unittest.cc b/blimp/net/blimp_message_multiplexer_unittest.cc
index 7a4028f..ec0e8ff 100644
--- a/blimp/net/blimp_message_multiplexer_unittest.cc
+++ b/blimp/net/blimp_message_multiplexer_unittest.cc
@@ -56,7 +56,7 @@ class BlimpMessageMultiplexerTest : public testing::Test {
 // correctly.
 TEST_F(BlimpMessageMultiplexerTest, TypeSetByMux) {
   net::TestCompletionCallback cb_1;
-  input_processor_->ProcessMessage(input_message_.Pass(), cb_1.callback());
+  input_processor_->ProcessMessage(std::move(input_message_), cb_1.callback());
   EXPECT_EQ(BlimpMessage::INPUT, captured_message_.type());
   EXPECT_EQ(InputMessage::Type_GestureScrollBegin,
             captured_message_.input().type());
@@ -64,7 +64,7 @@ TEST_F(BlimpMessageMultiplexerTest, TypeSetByMux) {
   EXPECT_EQ(net::OK, cb_1.WaitForResult());
 
   net::TestCompletionCallback cb_2;
-  navigation_processor_->ProcessMessage(navigation_message_.Pass(),
+  navigation_processor_->ProcessMessage(std::move(navigation_message_),
                                         cb_2.callback());
   EXPECT_EQ(BlimpMessage::NAVIGATION, captured_message_.type());
   EXPECT_EQ(NavigationMessage::LOAD_URL, captured_message_.navigation().type());
@@ -77,7 +77,7 @@ TEST_F(BlimpMessageMultiplexerTest, TypeSetByCaller) {
   input_message_->set_type(BlimpMessage::INPUT);
 
   net::TestCompletionCallback cb_1;
-  input_processor_->ProcessMessage(input_message_.Pass(), cb_1.callback());
+  input_processor_->ProcessMessage(std::move(input_message_), cb_1.callback());
   EXPECT_EQ(BlimpMessage::INPUT, captured_message_.type());
   EXPECT_EQ(InputMessage::Type_GestureScrollBegin,
             captured_message_.input().type());
@@ -89,7 +89,7 @@ TEST_F(BlimpMessageMultiplexerTest, TypeSetByCaller) {
 TEST_F(BlimpMessageMultiplexerTest, SenderTransience) {
   net::TestCompletionCallback cb_3;
   input_processor_ = multiplexer_.CreateSenderForType(BlimpMessage::INPUT);
-  input_processor_->ProcessMessage(input_message_.Pass(), cb_3.callback());
+  input_processor_->ProcessMessage(std::move(input_message_), cb_3.callback());
   EXPECT_EQ(BlimpMessage::INPUT, captured_message_.type());
   EXPECT_EQ(InputMessage::Type_GestureScrollBegin,
             captured_message_.input().type());
@@ -102,7 +102,7 @@ TEST_F(BlimpMessageMultiplexerTest, SenderMultiplicity) {
   net::TestCompletionCallback cb_4;
   scoped_ptr<BlimpMessageProcessor> input_processor_2 =
       multiplexer_.CreateSenderForType(BlimpMessage::INPUT);
-  input_processor_2->ProcessMessage(input_message_.Pass(), cb_4.callback());
+  input_processor_2->ProcessMessage(std::move(input_message_), cb_4.callback());
   EXPECT_EQ(BlimpMessage::INPUT, captured_message_.type());
   EXPECT_EQ(InputMessage::Type_GestureScrollBegin,
             captured_message_.input().type());
diff --git a/blimp/net/blimp_message_pump.cc b/blimp/net/blimp_message_pump.cc
index 70c3217..d9a250a 100644
--- a/blimp/net/blimp_message_pump.cc
+++ b/blimp/net/blimp_message_pump.cc
@@ -59,7 +59,7 @@ void BlimpMessagePump::OnReadPacketComplete(int result) {
     if (parse_result) {
       process_msg_callback_.Reset(base::Bind(
           &BlimpMessagePump::OnProcessMessageComplete, base::Unretained(this)));
-      processor_->ProcessMessage(message.Pass(),
+      processor_->ProcessMessage(std::move(message),
                                  process_msg_callback_.callback());
       return;
     }
diff --git a/blimp/net/stream_socket_connection.cc b/blimp/net/stream_socket_connection.cc
index ec06206..73a8cd7 100644
--- a/blimp/net/stream_socket_connection.cc
+++ b/blimp/net/stream_socket_connection.cc
@@ -13,7 +13,7 @@ StreamSocketConnection::StreamSocketConnection(
     scoped_ptr<net::StreamSocket> socket)
     : BlimpConnection(make_scoped_ptr(new StreamPacketReader(socket.get())),
                       make_scoped_ptr(new StreamPacketWriter(socket.get()))),
-      socket_(socket.Pass()) {
+      socket_(std::move(socket)) {
   DCHECK(socket_);
 }
 
diff --git a/blimp/net/tcp_client_transport.cc b/blimp/net/tcp_client_transport.cc
index 2bdf91d..e5f5b37 100644
--- a/blimp/net/tcp_client_transport.cc
+++ b/blimp/net/tcp_client_transport.cc
@@ -46,7 +46,7 @@ void TCPClientTransport::Connect(const net::CompletionCallback& callback) {
 scoped_ptr<BlimpConnection> TCPClientTransport::TakeConnection() {
   DCHECK(connect_callback_.is_null());
   DCHECK(socket_);
-  return make_scoped_ptr(new StreamSocketConnection(socket_.Pass()));
+  return make_scoped_ptr(new StreamSocketConnection(std::move(socket_)));
 }
 
 void TCPClientTransport::OnTCPConnectComplete(int result) {
diff --git a/blimp/net/tcp_engine_transport.cc b/blimp/net/tcp_engine_transport.cc
index 112e350..e48509b 100644
--- a/blimp/net/tcp_engine_transport.cc
+++ b/blimp/net/tcp_engine_transport.cc
@@ -57,7 +57,8 @@ void TCPEngineTransport::Connect(const net::CompletionCallback& callback) {
 scoped_ptr<BlimpConnection> TCPEngineTransport::TakeConnection() {
   DCHECK(connect_callback_.is_null());
   DCHECK(accepted_socket_);
-  return make_scoped_ptr(new StreamSocketConnection(accepted_socket_.Pass()));
+  return make_scoped_ptr(
+      new StreamSocketConnection(std::move(accepted_socket_)));
 }
 
 int TCPEngineTransport::GetLocalAddressForTesting(