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

google_apis/gcm/engine/mcs_client_unittest.cc

 // Copyright 2013 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 "google_apis/gcm/engine/mcs_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 225 matching lines @@
   scoped_ptr<mcs_proto::LoginRequest> login_request =
       BuildLoginRequest(kAndroidId, kSecurityToken, "");
   for (size_t i = 0; i < acknowledged_ids.size(); ++i)
     login_request->add_received_persistent_id(acknowledged_ids[i]);
   if (heartbeat_interval_ms) {
     mcs_proto::Setting* setting = login_request->add_setting();
     setting->set_name("hbping");
     setting->set_value(base::IntToString(heartbeat_interval_ms));
   }
   GetFakeHandler()->ExpectOutgoingMessage(
-      MCSMessage(kLoginRequestTag, login_request.Pass()));
+      MCSMessage(kLoginRequestTag, std::move(login_request)));
 }
 
 void MCSClientTest::StoreCredentials() {
   gcm_store_->SetDeviceCredentials(
       kAndroidId, kSecurityToken,
       base::Bind(&MCSClientTest::SetDeviceCredentialsCallback,
                  base::Unretained(this)));
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
@@ skipping 157 matching lines @@
   EXPECT_FALSE(GetFakeHandler()->AllOutgoingMessagesReceived());
   GetFakeHandler()->set_fail_send(false);
   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue - 1));
   connection_factory()->Connect();
   WaitForMCSEvent();  // Wait for the login to finish.
   PumpLoop();         // Wait for the send to happen.
 
   // Receive the ack.
   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(2);
-  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, std::move(ack)));
   WaitForMCSEvent();
 
   EXPECT_EQ(MCSClient::SENT, message_send_status());
   EXPECT_EQ("X", sent_message_id());
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 // Send a message with RMQ support without receiving an acknowledgement. On
 // restart the message should be resent.
 TEST_F(MCSClientTest, SendMessageRMQOnRestart) {
@@ skipping 41 matching lines @@
                                         "", 0, IMMEDIATE_ACK_NO));
     GetFakeHandler()->ExpectOutgoingMessage(message);
     mcs_client()->SendMessage(message);
     PumpLoop();
   }
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
   // Receive the ack.
   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kMessageBatchSize + 1);
-  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, std::move(ack)));
   WaitForMCSEvent();
 
   // Reconnect and ensure no messages are resent.
   StoreCredentials();
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
   PumpLoop();
 }
 
@@ skipping 17 matching lines @@
   }
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
   // Rebuild the client, and receive an acknowledgment for the messages as
   // part of the login response.
   StoreCredentials();
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(id_list));
-  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, std::move(ack)));
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 // Send messages with RMQ support. On restart, receive a SelectiveAck with
 // the login response that only acks some messages. The unacked messages should
 // be resent.
 TEST_F(MCSClientTest, SendMessageRMQPartialAckOnReconnect) {
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
@@ skipping 25 matching lines @@
   remaining_ids.insert(remaining_ids.end(),
                        id_list.begin() + kMessageBatchSize / 2,
                        id_list.end());
   for (int i = 1; i <= kMessageBatchSize / 2; ++i) {
     MCSMessage message(BuildDataMessage(
         "from", "category", remaining_ids[i - 1], 2, remaining_ids[i - 1],
         kTTLValue, 1, 0, "", 0, IMMEDIATE_ACK_NO));
     GetFakeHandler()->ExpectOutgoingMessage(message);
   }
   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
-  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, std::move(ack)));
   WaitForMCSEvent();
   PumpLoop();
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 // Handle a selective ack that only acks some messages. The remaining unacked
 // messages should be resent. On restart, those same unacked messages should be
 // resent, and any pending acks for incoming messages should also be resent.
 TEST_F(MCSClientTest, SelectiveAckMidStream) {
   BuildMCSClient();
@@ skipping 42 matching lines @@
   // Simulate the last message being dropped by having the server selectively
   // ack client message "1".
   // Client message "2" should be resent, acking server stream id 4 (selective
   // ack).
   MCSMessage cMessage3(BuildDataMessage("from", "category", "Y", 4, "2",
                                         kTTLValue, 1, 0, "", 0,
                                         IMMEDIATE_ACK_NO));
   GetFakeHandler()->ExpectOutgoingMessage(cMessage3);
   std::vector<std::string> acked_ids(1, "1");
   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
-  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ReceiveMessage(MCSMessage(kIqStanzaTag, std::move(ack)));
   WaitForMCSEvent();
   PumpLoop();
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
   // Rebuild the client without any further acks from server. Note that this
   // resets the stream ids.
   // Sever message "s2" should be acked as part of login.
   // Client message "2" should be resent.
   StoreCredentials();
   BuildMCSClient();
@@ skipping 66 matching lines @@
 // Receive the ack limit in messages, which should trigger an automatic
 // stream ack. Receive a heartbeat to confirm the ack.
 TEST_F(MCSClientTest, AckWhenLimitReachedWithHeartbeat) {
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
 
   // The stream ack.
   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kAckLimitSize + 1);
-  GetFakeHandler()->ExpectOutgoingMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ExpectOutgoingMessage(
+      MCSMessage(kIqStanzaTag, std::move(ack)));
 
   // Receive some messages.
   std::vector<std::string> id_list;
   for (int i = 1; i <= kAckLimitSize; ++i) {
     id_list.push_back(base::IntToString(i));
     MCSMessage message(BuildDataMessage("from", "category", id_list.back(), 1,
                                         id_list.back(), kTTLValue, 1, 0, "", 0,
                                         IMMEDIATE_ACK_NO));
     GetFakeHandler()->ReceiveMessage(message);
     WaitForMCSEvent();
     PumpLoop();
   }
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
   // Receive a heartbeat confirming the ack (and receive the heartbeat ack).
   scoped_ptr<mcs_proto::HeartbeatPing> heartbeat(
       new mcs_proto::HeartbeatPing());
   heartbeat->set_last_stream_id_received(2);
 
   scoped_ptr<mcs_proto::HeartbeatAck> heartbeat_ack(
       new mcs_proto::HeartbeatAck());
   heartbeat_ack->set_last_stream_id_received(kAckLimitSize + 2);
   GetFakeHandler()->ExpectOutgoingMessage(
-      MCSMessage(kHeartbeatAckTag, heartbeat_ack.Pass()));
+      MCSMessage(kHeartbeatAckTag, std::move(heartbeat_ack)));
 
   GetFakeHandler()->ReceiveMessage(
-      MCSMessage(kHeartbeatPingTag, heartbeat.Pass()));
+      MCSMessage(kHeartbeatPingTag, std::move(heartbeat)));
   PumpLoop();
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
   // Rebuild the client. Nothing should be sent on login.
   StoreCredentials();
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
@@ skipping 381 matching lines @@
 // Receive a message with immediate ack request, which should trigger an
 // automatic stream ack.
 TEST_F(MCSClientTest, AckWhenImmediateAckRequested) {
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
 
   // The stream ack.
   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kAckLimitSize - 1);
-  GetFakeHandler()->ExpectOutgoingMessage(MCSMessage(kIqStanzaTag, ack.Pass()));
+  GetFakeHandler()->ExpectOutgoingMessage(
+      MCSMessage(kIqStanzaTag, std::move(ack)));
 
   // Receive some messages.
   for (int i = 1; i < kAckLimitSize - 2; ++i) {
     std::string id(base::IntToString(i));
     MCSMessage message(BuildDataMessage("from", "category", id, 1, id,
                                         kTTLValue, 1, 0, "", 0,
                                         IMMEDIATE_ACK_NO));
     GetFakeHandler()->ReceiveMessage(message);
     WaitForMCSEvent();
     PumpLoop();
   }
   // This message expects immediate ACK, which means it will happen before the
   // ACK limit size is reached. All of the preceding messages will be acked at
   // the same time.
   std::string ack_id(base::IntToString(kAckLimitSize - 1));
   MCSMessage message(BuildDataMessage("from", "category", ack_id, 1, ack_id,
                                       kTTLValue, 1, 0, "", 0,
                                       IMMEDIATE_ACK_YES));
   GetFakeHandler()->ReceiveMessage(message);
   WaitForMCSEvent();
   PumpLoop();
 
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 } // namespace
 
 }  // namespace gcm