Convert //remoting to use std::unique_ptr

remoting/signaling/xmpp_stream_parser.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_stream_parser.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlbuilder.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlparser.h"
 
 namespace remoting {
 
 class XmppStreamParser::Core : public buzz::XmlParseHandler {
  public:
-  typedef base::Callback<void(scoped_ptr<buzz::XmlElement> stanza)>
+  typedef base::Callback<void(std::unique_ptr<buzz::XmlElement> stanza)>
       OnStanzaCallback;
 
   Core();
   ~Core() override;
 
   void SetCallbacks(const OnStanzaCallback& on_stanza_callback,
                     const base::Closure& on_error_callback);
 
   void AppendData(const std::string& data);
 
@@ skipping 44 matching lines @@
   parser_.Parse(data.data(), data.size(), false);
 }
 
 void XmppStreamParser::Core::StartElement(buzz::XmlParseContext* context,
                                     const char* name,
                                     const char** atts) {
   DCHECK(!error_);
 
   ++depth_;
   if (depth_ == 1) {
-    scoped_ptr<buzz::XmlElement> header(
+    std::unique_ptr<buzz::XmlElement> header(
         buzz::XmlBuilder::BuildElement(context, name, atts));
     if (!header) {
       LOG(ERROR) << "Failed to parse XMPP stream header.";
       ProcessError();
     }
     return;
   }
 
   builder_.StartElement(context, name, atts);
 }
 
 void XmppStreamParser::Core::EndElement(buzz::XmlParseContext* context,
                                         const char* name) {
   DCHECK(!error_);
 
   --depth_;
   if (depth_ == 0) {
     LOG(ERROR) << "XMPP stream ended unexpectedly.";
     ProcessError();
     return;
   }
 
   builder_.EndElement(context, name);
 
   if (depth_ == 1) {
     if (!on_stanza_callback_.is_null())
-      on_stanza_callback_.Run(make_scoped_ptr(builder_.CreateElement()));
+      on_stanza_callback_.Run(base::WrapUnique(builder_.CreateElement()));
   }
 }
 
 void XmppStreamParser::Core::CharacterData(buzz::XmlParseContext* context,
                                            const char* text,
                                            int len) {
   DCHECK(!error_);
 
   // Ignore data between stanzas.
   if (depth_ <= 1) {
@@ skipping 40 matching lines @@
 void XmppStreamParser::SetCallbacks(const OnStanzaCallback& on_stanza_callback,
                                     const base::Closure& on_error_callback) {
   core_->SetCallbacks(on_stanza_callback, on_error_callback);
 }
 
 void XmppStreamParser::AppendData(const std::string& data) {
   core_->AppendData(data);
 }
 
 }  // namespace remoting