Convert //remoting to use std::unique_ptr

remoting/protocol/jingle_messages_unittest.cc

 // Copyright (c) 2012 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/protocol/jingle_messages.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 78 matching lines @@
     *error = "Unexpected <" + val_child->Name().Merged() + "> found";
     return false;
   }
 
   return true;
 }
 
 // Parses |message_text| to JingleMessage.
 void ParseJingleMessageFromXml(const char* message_text,
                                JingleMessage* parsed) {
-  scoped_ptr<XmlElement> source_message(
-      XmlElement::ForStr(message_text));
+  std::unique_ptr<XmlElement> source_message(XmlElement::ForStr(message_text));
   ASSERT_TRUE(source_message.get());
 
   EXPECT_TRUE(JingleMessage::IsJingleMessage(source_message.get()));
 
   std::string error;
   EXPECT_TRUE(parsed->ParseXml(source_message.get(), &error)) << error;
 }
 
 
 // Parses |message_text| to JingleMessage then attempts to format it to XML and
 // verifies that the same XML content is generated.
 void ParseFormatAndCompare(const char* message_text, JingleMessage* parsed) {
-  scoped_ptr<XmlElement> source_message(
-      XmlElement::ForStr(message_text));
+  std::unique_ptr<XmlElement> source_message(XmlElement::ForStr(message_text));
   ASSERT_TRUE(source_message.get());
 
   EXPECT_TRUE(JingleMessage::IsJingleMessage(source_message.get()));
 
   std::string error;
   EXPECT_TRUE(parsed->ParseXml(source_message.get(), &error)) << error;
 
-  scoped_ptr<XmlElement> formatted_message(parsed->ToXml());
+  std::unique_ptr<XmlElement> formatted_message(parsed->ToXml());
   ASSERT_TRUE(formatted_message.get());
   EXPECT_TRUE(VerifyXml(source_message.get(), formatted_message.get(), &error))
       << error;
 }
 
 }  // namespace
 
 // Session-initiate message for current ICE-based protocol.
 TEST(JingleMessageTest, SessionInitiate) {
   const char* kTestSessionInitiateMessage =
@@ skipping 272 matching lines @@
               buzz::QName("urn:xmpp:jingle:1", "test-info"));
 }
 
 TEST(JingleMessageReplyTest, ToXml) {
   const char* kTestIncomingMessage =
       "<cli:iq from='user@gmail.com/chromoting016DBB07' id='4' "
       "to='user@gmail.com/chromiumsy5C6A652D' type='set' "
       "xmlns:cli='jabber:client'><jingle action='session-terminate' "
       "sid='2227053353' xmlns='urn:xmpp:jingle:1'><reason><success/>"
       "</reason></jingle></cli:iq>";
-  scoped_ptr<XmlElement> incoming_message(
+  std::unique_ptr<XmlElement> incoming_message(
       XmlElement::ForStr(kTestIncomingMessage));
   ASSERT_TRUE(incoming_message.get());
 
   struct TestCase {
     const JingleMessageReply::ErrorType error;
     std::string error_text;
     std::string expected_text;
   } tests[] = {
     { JingleMessageReply::BAD_REQUEST, "", "<iq xmlns='jabber:client' "
       "to='user@gmail.com/chromoting016DBB07' id='4' type='error'><jingle "
@@ skipping 27 matching lines @@
       "<unexpected-request/></error></iq>" },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     JingleMessageReply reply_msg;
     if (tests[i].error_text.empty()) {
       reply_msg = JingleMessageReply(tests[i].error);
     } else {
       reply_msg = JingleMessageReply(tests[i].error, tests[i].error_text);
     }
-    scoped_ptr<XmlElement> reply(reply_msg.ToXml(incoming_message.get()));
+    std::unique_ptr<XmlElement> reply(reply_msg.ToXml(incoming_message.get()));
 
-    scoped_ptr<XmlElement> expected(XmlElement::ForStr(tests[i].expected_text));
+    std::unique_ptr<XmlElement> expected(
+        XmlElement::ForStr(tests[i].expected_text));
     ASSERT_TRUE(expected.get());
 
     std::string error;
     EXPECT_TRUE(VerifyXml(expected.get(), reply.get(), &error)) << error;
   }
 }
 
 TEST(JingleMessageTest, ErrorMessage) {
   const char* kTestSessionInitiateErrorMessage =
       "<iq to='user@gmail.com/chromoting016DBB07' type='error' "
@@ skipping 12 matching lines @@
                 "j7whCMii0Z0AAPwj7whCM/j7whCMii0Z0AAPw="
               "</auth-token></authentication>"
             "</description>"
           "</content>"
         "</jingle>"
         "<error code='501' type='cancel'>"
           "<feature-not-implemented "
             "xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
         "</error>"
       "</iq>";
-  scoped_ptr<XmlElement> source_message(
+  std::unique_ptr<XmlElement> source_message(
       XmlElement::ForStr(kTestSessionInitiateErrorMessage));
   ASSERT_TRUE(source_message.get());
 
   EXPECT_FALSE(JingleMessage::IsJingleMessage(source_message.get()));
 
   JingleMessage message;
   std::string error;
   EXPECT_FALSE(message.ParseXml(source_message.get(), &error));
   EXPECT_FALSE(error.empty());
 }
 
 }  // namespace protocol
 }  // namespace remoting