Convert //remoting to use std::unique_ptr

remoting/signaling/fake_signal_strategy.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/fake_signal_strategy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 80 matching lines @@
 void FakeSignalStrategy::AddListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
   listeners_.AddObserver(listener);
 }
 
 void FakeSignalStrategy::RemoveListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
   listeners_.RemoveObserver(listener);
 }
 
-bool FakeSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
+bool FakeSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) {
   DCHECK(CalledOnValidThread());
 
   stanza->SetAttr(buzz::QN_FROM, jid_);
 
   if (!peer_callback_.is_null()) {
     if (send_delay_ != base::TimeDelta()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(peer_callback_, base::Passed(&stanza)),
           send_delay_);
     } else {
       peer_callback_.Run(std::move(stanza));
     }
     return true;
   } else {
     return false;
   }
 }
 
 std::string FakeSignalStrategy::GetNextId() {
   ++last_id_;
   return base::IntToString(last_id_);
 }
 
 // static
 void FakeSignalStrategy::DeliverMessageOnThread(
     scoped_refptr<base::SingleThreadTaskRunner> thread,
     base::WeakPtr<FakeSignalStrategy> target,
-    scoped_ptr<buzz::XmlElement> stanza) {
+    std::unique_ptr<buzz::XmlElement> stanza) {
   thread->PostTask(FROM_HERE,
                    base::Bind(&FakeSignalStrategy::OnIncomingMessage,
                               target, base::Passed(&stanza)));
 }
 
 void FakeSignalStrategy::OnIncomingMessage(
-    scoped_ptr<buzz::XmlElement> stanza) {
+    std::unique_ptr<buzz::XmlElement> stanza) {
   DCHECK(CalledOnValidThread());
 
   buzz::XmlElement* stanza_ptr = stanza.get();
   received_messages_.push_back(stanza.release());
 
   const std::string& to_field = stanza_ptr->Attr(buzz::QN_TO);
   if (to_field != jid_) {
     LOG(WARNING) << "Dropping stanza that is addressed to " << to_field
                  << ". Local jid: " << jid_
                  << ". Message content: " << stanza_ptr->Str();
     return;
   }
 
   base::ObserverListBase<Listener>::Iterator it(&listeners_);
   Listener* listener;
   while ((listener = it.GetNext()) != nullptr) {
     if (listener->OnSignalStrategyIncomingStanza(stanza_ptr))
       break;
   }
 }
 
 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) {
   peer_callback_ = peer_callback;
 }
 
 }  // namespace remoting