Convert //remoting to use std::unique_ptr

remoting/protocol/webrtc_transport.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/protocol/webrtc_transport.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/port_allocator_factory.h"
 #include "remoting/protocol/stream_message_pipe_adapter.h"
@@ skipping 39 matching lines @@
       SplitString(sdp, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   return base::JoinString(lines, "\n") + "\n";
 }
 
 // A webrtc::CreateSessionDescriptionObserver implementation used to receive the
 // results of creating descriptions for this end of the PeerConnection.
 class CreateSessionDescriptionObserver
     : public webrtc::CreateSessionDescriptionObserver {
  public:
   typedef base::Callback<void(
-      scoped_ptr<webrtc::SessionDescriptionInterface> description,
-      const std::string& error)> ResultCallback;
+      std::unique_ptr<webrtc::SessionDescriptionInterface> description,
+      const std::string& error)>
+      ResultCallback;
 
   static CreateSessionDescriptionObserver* Create(
       const ResultCallback& result_callback) {
     return new rtc::RefCountedObject<CreateSessionDescriptionObserver>(
         result_callback);
   }
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
     base::ResetAndReturn(&result_callback_)
-        .Run(make_scoped_ptr(desc), std::string());
+        .Run(base::WrapUnique(desc), std::string());
   }
   void OnFailure(const std::string& error) override {
     base::ResetAndReturn(&result_callback_).Run(nullptr, error);
   }
 
  protected:
   explicit CreateSessionDescriptionObserver(
       const ResultCallback& result_callback)
       : result_callback_(result_callback) {}
   ~CreateSessionDescriptionObserver() override {}
@@ skipping 85 matching lines @@
 
   webrtc::PeerConnectionInterface::IceServer stun_server;
   stun_server.urls.push_back("stun:stun.l.google.com:19302");
   webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
   rtc_config.servers.push_back(stun_server);
 
   webrtc::FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            webrtc::MediaConstraintsInterface::kValueTrue);
 
-  scoped_ptr<cricket::PortAllocator> port_allocator =
+  std::unique_ptr<cricket::PortAllocator> port_allocator =
       transport_context_->port_allocator_factory()->CreatePortAllocator(
           transport_context_);
   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
       rtc_config, &constraints,
       rtc::scoped_ptr<cricket::PortAllocator>(port_allocator.release()),
       nullptr, this);
 
   outgoing_data_stream_adapter_.Initialize(peer_connection_);
   incoming_data_stream_adapter_.Initialize(peer_connection_);
 
@@ skipping 43 matching lines @@
       ignore_error = base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableAuthenticationSwitchName);
 #endif
       if (!ignore_error) {
         Close(AUTHENTICATION_FAILED);
         return true;
       }
     }
 
     webrtc::SdpParseError error;
-    scoped_ptr<webrtc::SessionDescriptionInterface> session_description(
+    std::unique_ptr<webrtc::SessionDescriptionInterface> session_description(
         webrtc::CreateSessionDescription(type, sdp, &error));
     if (!session_description) {
       LOG(ERROR) << "Failed to parse the session description: "
                  << error.description << " line: " << error.line;
       return false;
     }
 
     peer_connection_->SetRemoteDescription(
         SetSessionDescriptionObserver::Create(
             base::Bind(&WebrtcTransport::OnRemoteDescriptionSet,
@@ skipping 13 matching lines @@
     std::string sdp_mlineindex_str =
         candidate_element->Attr(QName(std::string(), "sdpMLineIndex"));
     int sdp_mlineindex;
     if (candidate_str.empty() || sdp_mid.empty() ||
         !base::StringToInt(sdp_mlineindex_str, &sdp_mlineindex)) {
       LOG(ERROR) << "Failed to parse incoming candidates.";
       return false;
     }
 
     webrtc::SdpParseError error;
-    scoped_ptr<webrtc::IceCandidateInterface> candidate(
+    std::unique_ptr<webrtc::IceCandidateInterface> candidate(
         webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, candidate_str,
                                    &error));
     if (!candidate) {
       LOG(ERROR) << "Failed to parse incoming candidate: " << error.description
                  << " line: " << error.line;
       return false;
     }
 
     if (peer_connection_->signaling_state() ==
         webrtc::PeerConnectionInterface::kStable) {
       if (!peer_connection_->AddIceCandidate(candidate.get())) {
         LOG(ERROR) << "Failed to add incoming ICE candidate.";
         return false;
       }
     } else {
       pending_incoming_candidates_.push_back(std::move(candidate));
     }
   }
 
   return true;
 }
 
 void WebrtcTransport::OnLocalSessionDescriptionCreated(
-    scoped_ptr<webrtc::SessionDescriptionInterface> description,
+    std::unique_ptr<webrtc::SessionDescriptionInterface> description,
     const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!peer_connection_)
     return;
 
   if (!description) {
     LOG(ERROR) << "PeerConnection offer creation failed: " << error;
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   std::string description_sdp;
   if (!description->ToString(&description_sdp)) {
     LOG(ERROR) << "Failed to serialize description.";
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
   description_sdp = NormalizeSessionDescription(description_sdp);
 
   // Format and send the session description to the peer.
-  scoped_ptr<XmlElement> transport_info(
+  std::unique_ptr<XmlElement> transport_info(
       new XmlElement(QName(kTransportNamespace, "transport"), true));
   XmlElement* offer_tag =
       new XmlElement(QName(kTransportNamespace, "session-description"));
   transport_info->AddElement(offer_tag);
   offer_tag->SetAttr(QName(std::string(), "type"), description->type());
   offer_tag->SetBodyText(description_sdp);
 
   std::string digest;
   digest.resize(handshake_hmac_.DigestLength());
   CHECK(handshake_hmac_.Sign(description->type() + " " + description_sdp,
@@ skipping 110 matching lines @@
 
 void WebrtcTransport::OnIceGatheringChange(
     webrtc::PeerConnectionInterface::IceGatheringState new_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebrtcTransport::OnIceCandidate(
     const webrtc::IceCandidateInterface* candidate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<XmlElement> candidate_element(
+  std::unique_ptr<XmlElement> candidate_element(
       new XmlElement(QName(kTransportNamespace, "candidate")));
   std::string candidate_str;
   if (!candidate->ToString(&candidate_str)) {
     LOG(ERROR) << "Failed to serialize local candidate.";
     return;
   }
   candidate_element->SetBodyText(candidate_str);
   candidate_element->SetAttr(QName(std::string(), "sdpMid"),
                              candidate->sdp_mid());
   candidate_element->SetAttr(QName(std::string(), "sdpMLineIndex"),
@@ skipping 75 matching lines @@
   peer_connection_->Close();
   peer_connection_ = nullptr;
   peer_connection_factory_ = nullptr;
 
   if (error != OK)
     event_handler_->OnWebrtcTransportError(error);
 }
 
 }  // namespace protocol
 }  // namespace remoting