Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/cast_channel/cast_socket_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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_clock.h"
 #include "base/timer/mock_timer.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
@@ skipping 138 matching lines @@
   MOCK_METHOD1(OnConnectComplete, void(ChannelError error_state));
   MOCK_METHOD1(OnWriteComplete, void(int result));
   MOCK_METHOD1(OnReadComplete, void(int result));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
 class TestCastSocket : public CastSocketImpl {
  public:
-  static scoped_ptr<TestCastSocket> Create(
+  static std::unique_ptr<TestCastSocket> Create(
       Logger* logger,
       uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
-    return scoped_ptr<TestCastSocket>(
+    return std::unique_ptr<TestCastSocket>(
         new TestCastSocket(CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL,
                            kDistantTimeoutMillis, logger, device_capabilities));
   }
 
-  static scoped_ptr<TestCastSocket> CreateSecure(
+  static std::unique_ptr<TestCastSocket> CreateSecure(
       Logger* logger,
       uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
-    return scoped_ptr<TestCastSocket>(new TestCastSocket(
+    return std::unique_ptr<TestCastSocket>(new TestCastSocket(
         CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
         kDistantTimeoutMillis, logger, device_capabilities));
   }
 
   explicit TestCastSocket(const net::IPEndPoint& ip_endpoint,
                           ChannelAuthType channel_auth,
                           int64_t timeout_ms,
                           Logger* logger,
                           uint64_t device_capabilities)
       : CastSocketImpl("some_extension_id",
                        ip_endpoint,
                        channel_auth,
                        &capturing_net_log_,
                        base::TimeDelta::FromMilliseconds(timeout_ms),
                        false,
                        logger,
                        device_capabilities),
         ip_(ip_endpoint),
         extract_cert_result_(true),
         verify_challenge_result_(true),
         verify_challenge_disallow_(false),
         tcp_unresponsive_(false),
         mock_timer_(new base::MockTimer(false, false)),
         mock_transport_(nullptr) {}
 
   ~TestCastSocket() override {}
 
   void SetupMockTransport() {
     mock_transport_ = new MockCastTransport;
-    SetTransportForTesting(make_scoped_ptr(mock_transport_));
+    SetTransportForTesting(base::WrapUnique(mock_transport_));
   }
 
   // Socket connection helpers.
   void SetupTcpConnect(net::IoMode mode, int result) {
     tcp_connect_data_.reset(new net::MockConnect(mode, result));
   }
   void SetupSslConnect(net::IoMode mode, int result) {
     ssl_connect_data_.reset(new net::MockConnect(mode, result));
   }
 
@@ skipping 44 matching lines @@
   }
 
   void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }
 
   MockCastTransport* GetMockTransport() {
     CHECK(mock_transport_);
     return mock_transport_;
   }
 
  private:
-  scoped_ptr<net::TCPClientSocket> CreateTcpSocket() override {
+  std::unique_ptr<net::TCPClientSocket> CreateTcpSocket() override {
     if (tcp_unresponsive_) {
-      return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(true));
+      return std::unique_ptr<net::TCPClientSocket>(new MockTCPSocket(true));
     } else {
       net::MockConnect* connect_data = tcp_connect_data_.get();
       connect_data->peer_addr = ip_;
-      return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(*connect_data));
+      return std::unique_ptr<net::TCPClientSocket>(
+          new MockTCPSocket(*connect_data));
     }
   }
 
-  scoped_ptr<net::SSLClientSocket> CreateSslSocket(
-      scoped_ptr<net::StreamSocket> socket) override {
+  std::unique_ptr<net::SSLClientSocket> CreateSslSocket(
+      std::unique_ptr<net::StreamSocket> socket) override {
     net::MockConnect* connect_data = ssl_connect_data_.get();
     connect_data->peer_addr = ip_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
-    return scoped_ptr<net::SSLClientSocket>(
-        new net::MockTCPClientSocket(
-            net::AddressList(), &capturing_net_log_, ssl_data_.get()));
+    return std::unique_ptr<net::SSLClientSocket>(new net::MockTCPClientSocket(
+        net::AddressList(), &capturing_net_log_, ssl_data_.get()));
   }
 
   scoped_refptr<net::X509Certificate> ExtractPeerCert() override {
     return extract_cert_result_ ? make_scoped_refptr<net::X509Certificate>(
                                       new net::X509Certificate(
                                           "", "", base::Time(), base::Time()))
                                 : nullptr;
   }
 
   bool VerifyChallengeReply() override {
     EXPECT_FALSE(verify_challenge_disallow_);
     return verify_challenge_result_;
   }
 
   base::Timer* GetTimer() override { return mock_timer_.get(); }
 
   net::TestNetLog capturing_net_log_;
   net::IPEndPoint ip_;
   // Simulated connect data
-  scoped_ptr<net::MockConnect> tcp_connect_data_;
-  scoped_ptr<net::MockConnect> ssl_connect_data_;
+  std::unique_ptr<net::MockConnect> tcp_connect_data_;
+  std::unique_ptr<net::MockConnect> ssl_connect_data_;
   // Simulated read / write data
   std::vector<net::MockWrite> writes_;
   std::vector<net::MockRead> reads_;
-  scoped_ptr<net::SocketDataProvider> ssl_data_;
+  std::unique_ptr<net::SocketDataProvider> ssl_data_;
   // Simulated result of peer cert extraction.
   bool extract_cert_result_;
   // Simulated result of verifying challenge reply.
   bool verify_challenge_result_;
   bool verify_challenge_disallow_;
   // If true, makes TCP connection process stall. For timeout testing.
   bool tcp_unresponsive_;
-  scoped_ptr<base::MockTimer> mock_timer_;
+  std::unique_ptr<base::MockTimer> mock_timer_;
   MockCastTransport* mock_transport_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCastSocket);
 };
 
 class CastSocketTest : public testing::Test {
  public:
   CastSocketTest()
       : logger_(
-            new Logger(make_scoped_ptr<base::Clock>(new base::SimpleTestClock),
+            new Logger(base::WrapUnique<base::Clock>(new base::SimpleTestClock),
                        base::Time())),
         delegate_(new MockDelegate) {}
   ~CastSocketTest() override {}
 
   void SetUp() override { EXPECT_CALL(*delegate_, OnMessage(_)).Times(0); }
 
   void TearDown() override {
     if (socket_.get()) {
       EXPECT_CALL(handler_, OnCloseComplete(net::OK));
       socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
@@ skipping 26 matching lines @@
 
  protected:
   // Runs all pending tasks in the message loop.
   void RunPendingTasks() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   base::MessageLoop message_loop_;
   Logger* logger_;
-  scoped_ptr<TestCastSocket> socket_;
+  std::unique_ptr<TestCastSocket> socket_;
   CompleteHandler handler_;
-  scoped_ptr<MockDelegate> delegate_;
+  std::unique_ptr<MockDelegate> delegate_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CastSocketTest);
 };
 
 // Tests connecting and closing the socket.
 TEST_F(CastSocketTest, TestConnectAndClose) {
   CreateCastSocket();
   socket_->SetupMockTransport();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
@@ skipping 484 matching lines @@
       logger_, cast_channel::CastDeviceCapability::VIDEO_OUT);
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone());
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_FALSE(socket_->TestVerifyChannelPolicyAudioOnly());
   EXPECT_TRUE(socket_->audio_only());
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions