Re-write many calls to WrapUnique() with MakeUnique()

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"
@@ skipping 102 matching lines @@
 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(),
-        base::WrapUnique(new net::TestURLRequestContext()));
+        base::MakeUnique<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(
-        base::WrapUnique(new buzz::XmlElement(*stanza)));
+    received_messages_.push_back(base::MakeUnique<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_;
   std::unique_ptr<XmppSocketDataProvider> socket_data_provider_;
@@ skipping 106 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(base::WrapUnique(
-      new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
+  EXPECT_TRUE(signal_strategy_->SendStanza(
+      base::MakeUnique<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(base::WrapUnique(
-      new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
+  EXPECT_FALSE(signal_strategy_->SendStanza(
+      base::MakeUnique<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(base::WrapUnique(
-      new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
+  EXPECT_FALSE(signal_strategy_->SendStanza(
+      base::MakeUnique<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(base::WrapUnique(
-      new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
+  EXPECT_FALSE(signal_strategy_->SendStanza(
+      base::MakeUnique<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);
 }
 
 TEST_F(XmppSignalStrategyTest, StartTlsWithPendingWrite) {
@@ skipping 28 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