Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gcm/engine/connection_factory_impl_unittest.cc

 // Copyright (c) 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/connection_factory_impl.h"
 
 #include <cmath>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "net/base/backoff_entry.h"
 #include "net/http/http_network_session.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 47 matching lines @@
 double CalculateBackoff(int num_attempts) {
   double delay = kBackoffDelayMs;
   for (int i = 1; i < num_attempts; ++i) {
     delay += kBackoffDelayMs * pow(static_cast<double>(kBackoffMultiplier),
                                    i - 1);
   }
   DVLOG(1) << "Expected backoff " << delay << " milliseconds.";
   return delay;
 }
 
-void ReadContinuation(
-    scoped_ptr<google::protobuf::MessageLite> message) {
-}
+void ReadContinuation(std::unique_ptr<google::protobuf::MessageLite> message) {}
 
 void WriteContinuation() {
 }
 
 // A connection factory that stubs out network requests and overrides the
 // backoff policy.
 class TestConnectionFactoryImpl : public ConnectionFactoryImpl {
  public:
   TestConnectionFactoryImpl(const base::Closure& finished_callback);
   ~TestConnectionFactoryImpl() override;
 
   void InitializeFactory();
 
   // Overridden stubs.
   void ConnectImpl() override;
   void InitHandler() override;
-  scoped_ptr<net::BackoffEntry> CreateBackoffEntry(
+  std::unique_ptr<net::BackoffEntry> CreateBackoffEntry(
       const net::BackoffEntry::Policy* const policy) override;
-  scoped_ptr<ConnectionHandler> CreateConnectionHandler(
+  std::unique_ptr<ConnectionHandler> CreateConnectionHandler(
       base::TimeDelta read_timeout,
       const ConnectionHandler::ProtoReceivedCallback& read_callback,
       const ConnectionHandler::ProtoSentCallback& write_callback,
       const ConnectionHandler::ConnectionChangedCallback& connection_callback)
       override;
   base::TimeTicks NowTicks() override;
 
   // Helpers for verifying connection attempts are made. Connection results
   // must be consumed.
   void SetConnectResult(int connect_result);
@@ skipping 16 matching lines @@
   int num_expected_attempts_;
   // Whether all expected connection attempts have been fulfilled since an
   // expectation was last set.
   bool connections_fulfilled_;
   // Whether to delay a login handshake completion or not.
   bool delay_login_;
   // Callback to invoke when all connection attempts have been made.
   base::Closure finished_callback_;
   // A temporary scoped pointer to make sure we don't leak the handler in the
   // cases it's never consumed by the ConnectionFactory.
-  scoped_ptr<FakeConnectionHandler> scoped_handler_;
+  std::unique_ptr<FakeConnectionHandler> scoped_handler_;
   // The current fake connection handler..
   FakeConnectionHandler* fake_handler_;
   // Dummy GCM Stats recorder.
   FakeGCMStatsRecorder dummy_recorder_;
 };
 
 TestConnectionFactoryImpl::TestConnectionFactoryImpl(
     const base::Closure& finished_callback)
     : ConnectionFactoryImpl(BuildEndpoints(),
                             net::BackoffEntry::Policy(),
@@ skipping 14 matching lines @@
   tick_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
 }
 
 TestConnectionFactoryImpl::~TestConnectionFactoryImpl() {
   EXPECT_EQ(0, num_expected_attempts_);
 }
 
 void TestConnectionFactoryImpl::ConnectImpl() {
   ASSERT_GT(num_expected_attempts_, 0);
   ASSERT_FALSE(GetConnectionHandler()->CanSendMessage());
-  scoped_ptr<mcs_proto::LoginRequest> request(BuildLoginRequest(0, 0, ""));
+  std::unique_ptr<mcs_proto::LoginRequest> request(BuildLoginRequest(0, 0, ""));
   GetConnectionHandler()->Init(*request, NULL);
   OnConnectDone(connect_result_);
   if (!NextRetryAttempt().is_null()) {
     // Advance the time to the next retry time.
     base::TimeDelta time_till_retry =
         NextRetryAttempt() - tick_clock_.NowTicks();
     tick_clock_.Advance(time_till_retry);
   }
   --num_expected_attempts_;
   if (num_expected_attempts_ == 0) {
     connect_result_ = net::ERR_UNEXPECTED;
     connections_fulfilled_ = true;
     finished_callback_.Run();
   }
 }
 
 void TestConnectionFactoryImpl::InitHandler() {
   EXPECT_NE(connect_result_, net::ERR_UNEXPECTED);
   if (!delay_login_)
     ConnectionHandlerCallback(net::OK);
 }
 
-scoped_ptr<net::BackoffEntry> TestConnectionFactoryImpl::CreateBackoffEntry(
+std::unique_ptr<net::BackoffEntry>
+TestConnectionFactoryImpl::CreateBackoffEntry(
     const net::BackoffEntry::Policy* const policy) {
-  return make_scoped_ptr(new net::BackoffEntry(&kTestBackoffPolicy,
-                                               &tick_clock_));
+  return base::WrapUnique(
+      new net::BackoffEntry(&kTestBackoffPolicy, &tick_clock_));
 }
 
-scoped_ptr<ConnectionHandler>
+std::unique_ptr<ConnectionHandler>
 TestConnectionFactoryImpl::CreateConnectionHandler(
     base::TimeDelta read_timeout,
     const ConnectionHandler::ProtoReceivedCallback& read_callback,
     const ConnectionHandler::ProtoSentCallback& write_callback,
     const ConnectionHandler::ConnectionChangedCallback& connection_callback) {
   return std::move(scoped_handler_);
 }
 
 base::TimeTicks TestConnectionFactoryImpl::NowTicks() {
   return tick_clock_.NowTicks();
@@ skipping 50 matching lines @@
   // ConnectionFactory::ConnectionListener
   void OnConnected(const GURL& current_server,
                    const net::IPEndPoint& ip_endpoint) override;
   void OnDisconnected() override;
 
  private:
   void ConnectionsComplete();
 
   TestConnectionFactoryImpl factory_;
   base::MessageLoop message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   GURL connected_server_;
 };
 
 ConnectionFactoryImplTest::ConnectionFactoryImplTest()
     : factory_(base::Bind(&ConnectionFactoryImplTest::ConnectionsComplete,
                          base::Unretained(this))),
       run_loop_(new base::RunLoop()) {
   factory()->SetConnectionListener(this);
   factory()->Initialize(
@@ skipping 283 matching lines @@
   // Now trigger force a re-connection.
   factory()->SetConnectResult(net::OK);
   factory()->Connect();
   WaitForConnections();
 
   // Re-connection should succeed.
   EXPECT_TRUE(factory()->IsEndpointReachable());
 }
 
 }  // namespace gcm