Convert //remoting to use std::unique_ptr

remoting/signaling/xmpp_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/xmpp_signal_strategy.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
       const XmppServerConfig& xmpp_server_config);
   ~Core() override;
 
   void Connect();
   void Disconnect();
   State GetState() const;
   Error GetError() const;
   std::string GetLocalJid() const;
   void AddListener(Listener* listener);
   void RemoveListener(Listener* listener);
-  bool SendStanza(scoped_ptr<buzz::XmlElement> stanza);
+  bool SendStanza(std::unique_ptr<buzz::XmlElement> stanza);
 
   void SetAuthInfo(const std::string& username,
                    const std::string& auth_token);
 
  private:
   enum class TlsState {
     // StartTls() hasn't been called. |socket_| is not encrypted.
     NOT_REQUESTED,
 
     // StartTls() has been called. Waiting for |writer_| to finish writing
@@ skipping 11 matching lines @@
   void OnTlsConnected(int result);
 
   void ReadSocket();
   void OnReadResult(int result);
   void HandleReadResult(int result);
 
   // XmppLoginHandler::Delegate interface.
   void SendMessage(const std::string& message) override;
   void StartTls() override;
   void OnHandshakeDone(const std::string& jid,
-                       scoped_ptr<XmppStreamParser> parser) override;
+                       std::unique_ptr<XmppStreamParser> parser) override;
   void OnLoginHandlerError(SignalStrategy::Error error) override;
 
   // Callback for BufferedSocketWriter.
   void OnMessageSent();
 
   // Event handlers for XmppStreamParser.
-  void OnStanza(const scoped_ptr<buzz::XmlElement> stanza);
+  void OnStanza(const std::unique_ptr<buzz::XmlElement> stanza);
   void OnParserError();
 
   void OnNetworkError(int error);
 
   void SendKeepAlive();
 
   net::ClientSocketFactory* socket_factory_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   XmppServerConfig xmpp_server_config_;
 
   // Used by the |socket_|.
-  scoped_ptr<net::CertVerifier> cert_verifier_;
-  scoped_ptr<net::TransportSecurityState> transport_security_state_;
+  std::unique_ptr<net::CertVerifier> cert_verifier_;
+  std::unique_ptr<net::TransportSecurityState> transport_security_state_;
 
-  scoped_ptr<net::StreamSocket> socket_;
-  scoped_ptr<BufferedSocketWriter> writer_;
+  std::unique_ptr<net::StreamSocket> socket_;
+  std::unique_ptr<BufferedSocketWriter> writer_;
   int pending_writes_ = 0;
   scoped_refptr<net::IOBuffer> read_buffer_;
   bool read_pending_ = false;
 
   TlsState tls_state_ = TlsState::NOT_REQUESTED;
 
-  scoped_ptr<XmppLoginHandler> login_handler_;
-  scoped_ptr<XmppStreamParser> stream_parser_;
+  std::unique_ptr<XmppLoginHandler> login_handler_;
+  std::unique_ptr<XmppStreamParser> stream_parser_;
   std::string jid_;
 
   Error error_ = OK;
 
   base::ObserverList<Listener, true> listeners_;
 
   base::Timer keep_alive_timer_;
 
   base::ThreadChecker thread_checker_;
 
@@ skipping 85 matching lines @@
 void XmppSignalStrategy::Core::AddListener(Listener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.AddObserver(listener);
 }
 
 void XmppSignalStrategy::Core::RemoveListener(Listener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.RemoveObserver(listener);
 }
 
-bool XmppSignalStrategy::Core::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
+bool XmppSignalStrategy::Core::SendStanza(
+    std::unique_ptr<buzz::XmlElement> stanza) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!stream_parser_) {
     VLOG(0) << "Dropping signalling message because XMPP is not connected.";
     return false;
   }
 
   SendMessage(stanza->Str());
 
   // Return false if the SendMessage() call above resulted in the SignalStrategy
@@ skipping 31 matching lines @@
     return;
   }
 
   tls_state_ = TlsState::CONNECTING;
 
   // Reset the writer so we don't try to write to the raw socket anymore.
   writer_.reset();
 
   DCHECK(!read_pending_);
 
-  scoped_ptr<net::ClientSocketHandle> socket_handle(
+  std::unique_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
   socket_handle->SetSocket(std::move(socket_));
 
   cert_verifier_ = net::CertVerifier::CreateDefault();
   transport_security_state_.reset(new net::TransportSecurityState());
   net::SSLClientSocketContext context;
   context.cert_verifier = cert_verifier_.get();
   context.transport_security_state = transport_security_state_.get();
 
   socket_ = socket_factory_->CreateSSLClientSocket(
       std::move(socket_handle),
       net::HostPortPair(xmpp_server_config_.host, kDefaultHttpsPort),
       net::SSLConfig(), context);
 
   int result = socket_->Connect(
       base::Bind(&Core::OnTlsConnected, base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnTlsConnected(result);
 }
 
 void XmppSignalStrategy::Core::OnHandshakeDone(
     const std::string& jid,
-    scoped_ptr<XmppStreamParser> parser) {
+    std::unique_ptr<XmppStreamParser> parser) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   jid_ = jid;
   stream_parser_ = std::move(parser);
   stream_parser_->SetCallbacks(
       base::Bind(&Core::OnStanza, base::Unretained(this)),
       base::Bind(&Core::OnParserError, base::Unretained(this)));
 
   // Don't need |login_handler_| anymore.
   login_handler_.reset();
@@ skipping 13 matching lines @@
 void XmppSignalStrategy::Core::OnMessageSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (tls_state_ == TlsState::WAITING_FOR_FLUSH &&
       !writer_->has_data_pending()) {
     StartTls();
   }
 }
 
 void XmppSignalStrategy::Core::OnStanza(
-    const scoped_ptr<buzz::XmlElement> stanza) {
+    const std::unique_ptr<buzz::XmlElement> stanza) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::ObserverListBase<Listener>::Iterator it(&listeners_);
   for (Listener* listener = it.GetNext(); listener; listener = it.GetNext()) {
     if (listener->OnSignalStrategyIncomingStanza(stanza.get()))
       return;
   }
 }
 
 void XmppSignalStrategy::Core::OnParserError() {
@@ skipping 160 matching lines @@
   return core_->GetLocalJid();
 }
 
 void XmppSignalStrategy::AddListener(Listener* listener) {
   core_->AddListener(listener);
 }
 
 void XmppSignalStrategy::RemoveListener(Listener* listener) {
   core_->RemoveListener(listener);
 }
-bool XmppSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
+bool XmppSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) {
   return core_->SendStanza(std::move(stanza));
 }
 
 std::string XmppSignalStrategy::GetNextId() {
   return base::Uint64ToString(base::RandUint64());
 }
 
 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
                                      const std::string& auth_token) {
   core_->SetAuthInfo(username, auth_token);
 }
 
 }  // namespace remoting