Convert //remoting to use std::unique_ptr

remoting/signaling/xmpp_signal_strategy_unittest.cc

 // Copyright 2015 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 "remoting/signaling/xmpp_signal_strategy.h"
 
 #include <utility>
 
 #include "base/base64.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
 
 namespace {
@@ skipping 62 matching lines @@
 
  private:
   std::string written_data_;
   bool use_async_write_ = false;
   int pending_write_size_ = 0;
   net::Error write_error_ = net::OK;
 };
 
 class MockClientSocketFactory : public net::MockClientSocketFactory {
  public:
-  scoped_ptr<net::SSLClientSocket> CreateSSLClientSocket(
-      scoped_ptr<net::ClientSocketHandle> transport_socket,
+  std::unique_ptr<net::SSLClientSocket> CreateSSLClientSocket(
+      std::unique_ptr<net::ClientSocketHandle> transport_socket,
       const net::HostPortPair& host_and_port,
       const net::SSLConfig& ssl_config,
       const net::SSLClientSocketContext& context) override {
     ssl_socket_created_ = true;
     return net::MockClientSocketFactory::CreateSSLClientSocket(
         std::move(transport_socket), host_and_port, ssl_config, context);
   }
 
   bool ssl_socket_created() const { return ssl_socket_created_; }
 
  private:
   bool ssl_socket_created_ = false;
 };
 
 }  // namespace
 
 const char kTestUsername[] = "test_username@example.com";
 const char kTestAuthToken[] = "test_auth_token";
 const int kDefaultPort = 443;
 
 class XmppSignalStrategyTest : public testing::Test,
                                public SignalStrategy::Listener {
  public:
   XmppSignalStrategyTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
   void SetUp() override {
     request_context_getter_ = new net::TestURLRequestContextGetter(
         message_loop_.task_runner(),
-        make_scoped_ptr(new net::TestURLRequestContext()));
+        base::WrapUnique(new net::TestURLRequestContext()));
   }
 
   void CreateSignalStrategy(int port) {
     XmppSignalStrategy::XmppServerConfig config;
     config.host = "talk.google.com";
     config.port = port;
     config.username = kTestUsername;
     config.auth_token = kTestAuthToken;
     signal_strategy_.reset(new XmppSignalStrategy(
         &client_socket_factory_, request_context_getter_, config));
     signal_strategy_->AddListener(this);
   }
 
   void TearDown() override {
     signal_strategy_->RemoveListener(this);
     signal_strategy_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void OnSignalStrategyStateChange(SignalStrategy::State state) override {
     state_history_.push_back(state);
   }
 
   bool OnSignalStrategyIncomingStanza(const buzz::XmlElement* stanza) override {
     received_messages_.push_back(
-        make_scoped_ptr(new buzz::XmlElement(*stanza)));
+        base::WrapUnique(new buzz::XmlElement(*stanza)));
     return true;
   }
 
   void Connect(bool success);
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   MockClientSocketFactory client_socket_factory_;
-  scoped_ptr<XmppSocketDataProvider> socket_data_provider_;
-  scoped_ptr<net::SSLSocketDataProvider> ssl_socket_data_provider_;
-  scoped_ptr<XmppSignalStrategy> signal_strategy_;
+  std::unique_ptr<XmppSocketDataProvider> socket_data_provider_;
+  std::unique_ptr<net::SSLSocketDataProvider> ssl_socket_data_provider_;
+  std::unique_ptr<XmppSignalStrategy> signal_strategy_;
 
   std::vector<SignalStrategy::State> state_history_;
   ScopedVector<buzz::XmlElement> received_messages_;
 };
 
 void XmppSignalStrategyTest::Connect(bool success) {
   EXPECT_EQ(SignalStrategy::DISCONNECTED, signal_strategy_->GetState());
   state_history_.clear();
 
   socket_data_provider_.reset(new XmppSocketDataProvider());
@@ skipping 94 matching lines @@
       "<iq type=\"result\" id=\"1\"/>");
 
   EXPECT_EQ(2U, state_history_.size());
   EXPECT_EQ(SignalStrategy::CONNECTED, state_history_[1]);
 }
 
 TEST_F(XmppSignalStrategyTest, SendAndReceive) {
   CreateSignalStrategy(kDefaultPort);
   Connect(true);
 
-  EXPECT_TRUE(signal_strategy_->SendStanza(make_scoped_ptr(
+  EXPECT_TRUE(signal_strategy_->SendStanza(base::WrapUnique(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
   EXPECT_EQ("<hello/>", socket_data_provider_->GetAndClearWrittenData());
 
   socket_data_provider_->ReceiveData("<hi xmlns=\"hello\"/>");
   EXPECT_EQ(1U, received_messages_.size());
   EXPECT_EQ("<hi xmlns=\"hello\"/>", received_messages_[0]->Str());
 }
 
 TEST_F(XmppSignalStrategyTest, AuthError) {
   CreateSignalStrategy(kDefaultPort);
   Connect(false);
 }
 
 TEST_F(XmppSignalStrategyTest, ConnectionClosed) {
   CreateSignalStrategy(kDefaultPort);
   Connect(true);
 
   socket_data_provider_->Close();
 
   EXPECT_EQ(3U, state_history_.size());
   EXPECT_EQ(SignalStrategy::DISCONNECTED, state_history_[2]);
   EXPECT_EQ(SignalStrategy::DISCONNECTED, signal_strategy_->GetState());
   EXPECT_EQ(SignalStrategy::OK, signal_strategy_->GetError());
 
   // Can't send messages anymore.
-  EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
+  EXPECT_FALSE(signal_strategy_->SendStanza(base::WrapUnique(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
 
   // Try connecting again.
   Connect(true);
 }
 
 TEST_F(XmppSignalStrategyTest, NetworkReadError) {
   CreateSignalStrategy(kDefaultPort);
   Connect(true);
 
   socket_data_provider_->SimulateAsyncReadError();
 
   EXPECT_EQ(3U, state_history_.size());
   EXPECT_EQ(SignalStrategy::DISCONNECTED, state_history_[2]);
   EXPECT_EQ(SignalStrategy::NETWORK_ERROR, signal_strategy_->GetError());
 
   // Can't send messages anymore.
-  EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
+  EXPECT_FALSE(signal_strategy_->SendStanza(base::WrapUnique(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
 
   // Try connecting again.
   Connect(true);
 }
 
 TEST_F(XmppSignalStrategyTest, NetworkWriteError) {
   CreateSignalStrategy(kDefaultPort);
   Connect(true);
 
   socket_data_provider_->set_write_error(net::ERR_FAILED);
 
   // Next SendMessage() will call Write() which will fail.
-  EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
+  EXPECT_FALSE(signal_strategy_->SendStanza(base::WrapUnique(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
 
   EXPECT_EQ(3U, state_history_.size());
   EXPECT_EQ(SignalStrategy::DISCONNECTED, state_history_[2]);
   EXPECT_EQ(SignalStrategy::NETWORK_ERROR, signal_strategy_->GetError());
 
   // Try connecting again.
   Connect(true);
 }
 
@@ skipping 29 matching lines @@
         "<proceed xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>");
 
   // Verify that SSL is connected only after write is finished.
   EXPECT_FALSE(client_socket_factory_.ssl_socket_created());
   socket_data_provider_->CompletePendingWrite();
   EXPECT_TRUE(client_socket_factory_.ssl_socket_created());
 }
 
 
   }  // namespace remoting