Convert //remoting to use std::unique_ptr

remoting/signaling/iq_sender_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 "remoting/signaling/iq_sender.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
@@ skipping 42 matching lines @@
  public:
   IqSenderTest() {
     EXPECT_CALL(signal_strategy_, AddListener(NotNull()));
     sender_.reset(new IqSender(&signal_strategy_));
     EXPECT_CALL(signal_strategy_, RemoveListener(
         static_cast<SignalStrategy::Listener*>(sender_.get())));
   }
 
  protected:
   void SendTestMessage() {
-    scoped_ptr<XmlElement> iq_body(
+    std::unique_ptr<XmlElement> iq_body(
         new XmlElement(QName(kNamespace, kBodyTag)));
     XmlElement* sent_stanza;
     EXPECT_CALL(signal_strategy_, GetNextId())
         .WillOnce(Return(kStanzaId));
     EXPECT_CALL(signal_strategy_, SendStanzaPtr(_))
         .WillOnce(DoAll(SaveArg<0>(&sent_stanza), Return(true)));
     request_ = sender_->SendIq(kType, kTo, std::move(iq_body), base::Bind(
         &MockCallback::OnReply, base::Unretained(&callback_)));
 
     std::string expected_xml_string =
         base::StringPrintf(
             "<cli:iq type=\"%s\" to=\"%s\" id=\"%s\" "
             "xmlns:cli=\"jabber:client\">"
             "<%s:%s xmlns:%s=\"%s\"/>"
             "</cli:iq>",
             kType, kTo, kStanzaId, kNamespacePrefix, kBodyTag,
             kNamespacePrefix, kNamespace);
     EXPECT_EQ(expected_xml_string, sent_stanza->Str());
     delete sent_stanza;
   }
 
   bool FormatAndDeliverResponse(const std::string& from,
-                                scoped_ptr<XmlElement>* response_out) {
-    scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
+                                std::unique_ptr<XmlElement>* response_out) {
+    std::unique_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
     response->AddAttr(QName(std::string(), "type"), "result");
     response->AddAttr(QName(std::string(), "id"), kStanzaId);
     response->AddAttr(QName(std::string(), "from"), from);
 
     XmlElement* response_body = new XmlElement(
         QName("test:namespace", "response-body"));
     response->AddElement(response_body);
 
     bool result = sender_->OnSignalStrategyIncomingStanza(response.get());
 
     if (response_out)
       *response_out = std::move(response);
 
     return result;
   }
 
   base::MessageLoop message_loop_;
   MockSignalStrategy signal_strategy_;
-  scoped_ptr<IqSender> sender_;
+  std::unique_ptr<IqSender> sender_;
   MockCallback callback_;
-  scoped_ptr<IqRequest> request_;
+  std::unique_ptr<IqRequest> request_;
 };
 
 TEST_F(IqSenderTest, SendIq) {
   ASSERT_NO_FATAL_FAILURE({
     SendTestMessage();
   });
 
-  scoped_ptr<XmlElement> response;
+  std::unique_ptr<XmlElement> response;
   EXPECT_TRUE(FormatAndDeliverResponse(kTo, &response));
 
   EXPECT_CALL(callback_, OnReply(request_.get(), XmlEq(response.get())));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(IqSenderTest, Timeout) {
   ASSERT_NO_FATAL_FAILURE({
     SendTestMessage();
   });
 
   request_->SetTimeout(base::TimeDelta::FromMilliseconds(2));
 
   EXPECT_CALL(callback_, OnReply(request_.get(), nullptr))
       .WillOnce(
           InvokeWithoutArgs(&message_loop_, &base::MessageLoop::QuitWhenIdle));
   message_loop_.Run();
 }
 
 TEST_F(IqSenderTest, NotNormalizedJid) {
   ASSERT_NO_FATAL_FAILURE({
     SendTestMessage();
   });
 
   // Set upper-case from value, which is equivalent to kTo in the original
   // message.
-  scoped_ptr<XmlElement> response;
+  std::unique_ptr<XmlElement> response;
   EXPECT_TRUE(FormatAndDeliverResponse("USER@domain.com", &response));
 
   EXPECT_CALL(callback_, OnReply(request_.get(), XmlEq(response.get())));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(IqSenderTest, InvalidFrom) {
   ASSERT_NO_FATAL_FAILURE({
     SendTestMessage();
   });
 
   EXPECT_FALSE(FormatAndDeliverResponse("different_user@domain.com", nullptr));
 
   EXPECT_CALL(callback_, OnReply(_, _)).Times(0);
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace remoting