Convert //google_apis from scoped_ptr to std::unique_ptr

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 <memory>
 #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/memory/ptr_util.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"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/fake_encryptor.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
@@ skipping 134 matching lines @@
   void MessageReceivedCallback(const MCSMessage& message);
   void MessageSentCallback(int64_t user_serial_number,
                            const std::string& app_id,
                            const std::string& message_id,
                            MCSClient::MessageSendStatus status);
 
   base::SimpleTestClock clock_;
 
   base::ScopedTempDir temp_directory_;
   base::MessageLoop message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
-  scoped_ptr<GCMStore> gcm_store_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<GCMStore> gcm_store_;
 
   FakeConnectionFactory connection_factory_;
-  scoped_ptr<TestMCSClient> mcs_client_;
+  std::unique_ptr<TestMCSClient> mcs_client_;
   bool init_success_;
   uint64_t restored_android_id_;
   uint64_t restored_security_token_;
-  scoped_ptr<MCSMessage> received_message_;
+  std::unique_ptr<MCSMessage> received_message_;
   std::string sent_message_id_;
   MCSClient::MessageSendStatus message_send_status_;
 
   gcm::FakeGCMStatsRecorder recorder_;
 };
 
 MCSClientTest::MCSClientTest()
     : run_loop_(new base::RunLoop()),
       init_success_(true),
       restored_android_id_(0),
       restored_security_token_(0),
       message_send_status_(MCSClient::SENT) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
   run_loop_.reset(new base::RunLoop());
 
   // Advance the clock to a non-zero time.
   clock_.Advance(base::TimeDelta::FromSeconds(1));
 }
 
 MCSClientTest::~MCSClientTest() {}
 
 void MCSClientTest::SetUp() {
   testing::Test::SetUp();
 }
 
 void MCSClientTest::BuildMCSClient() {
-  gcm_store_.reset(new GCMStoreImpl(
-      temp_directory_.path(),
-      message_loop_.task_runner(),
-      make_scoped_ptr<Encryptor>(new FakeEncryptor)));
+  gcm_store_.reset(
+      new GCMStoreImpl(temp_directory_.path(), message_loop_.task_runner(),
+                       base::WrapUnique<Encryptor>(new FakeEncryptor)));
   mcs_client_.reset(new TestMCSClient(&clock_,
                                       &connection_factory_,
                                       gcm_store_.get(),
                                       &recorder_));
 }
 
 void MCSClientTest::InitializeClient() {
   gcm_store_->Load(GCMStore::CREATE_IF_MISSING, base::Bind(
       &MCSClient::Initialize,
       base::Unretained(mcs_client_.get()),
@@ skipping 16 matching lines @@
     int heartbeat_interval_ms) {
   AddExpectedLoginRequest(acknowledged_ids, heartbeat_interval_ms);
   mcs_client_->Login(kAndroidId, kSecurityToken);
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void MCSClientTest::AddExpectedLoginRequest(
     const std::vector<std::string>& acknowledged_ids,
     int heartbeat_interval_ms) {
-  scoped_ptr<mcs_proto::LoginRequest> login_request =
+  std::unique_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, std::move(login_request)));
@@ skipping 165 matching lines @@
   EXPECT_EQ(MCSClient::QUEUED, message_send_status());
   EXPECT_EQ("X", sent_message_id());
   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();
+  std::unique_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(2);
   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
@@ skipping 41 matching lines @@
     MCSMessage message(BuildDataMessage("from", "category", "X", 1,
                                         base::IntToString(i), kTTLValue, 1, 0,
                                         "", 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();
+  std::unique_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kMessageBatchSize + 1);
   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 18 matching lines @@
     PumpLoop();
   }
   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));
+  std::unique_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(id_list));
   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();
@@ skipping 25 matching lines @@
                    id_list.begin() + kMessageBatchSize / 2);
   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));
+  std::unique_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
   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) {
@@ 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));
+  std::unique_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
   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();
@@ skipping 65 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();
+  std::unique_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kAckLimitSize + 1);
   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(
+  std::unique_ptr<mcs_proto::HeartbeatPing> heartbeat(
       new mcs_proto::HeartbeatPing());
   heartbeat->set_last_stream_id_received(2);
 
-  scoped_ptr<mcs_proto::HeartbeatAck> heartbeat_ack(
+  std::unique_ptr<mcs_proto::HeartbeatAck> heartbeat_ack(
       new mcs_proto::HeartbeatAck());
   heartbeat_ack->set_last_stream_id_received(kAckLimitSize + 2);
   GetFakeHandler()->ExpectOutgoingMessage(
       MCSMessage(kHeartbeatAckTag, std::move(heartbeat_ack)));
 
   GetFakeHandler()->ReceiveMessage(
       MCSMessage(kHeartbeatPingTag, std::move(heartbeat)));
   PumpLoop();
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 
@@ skipping 386 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();
+  std::unique_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
   ack->set_last_stream_id_received(kAckLimitSize - 1);
   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));
@@ skipping 11 matching lines @@
   GetFakeHandler()->ReceiveMessage(message);
   WaitForMCSEvent();
   PumpLoop();
 
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 } // namespace
 
 }  // namespace gcm