WebRTC's scoped_ptr and scoped_ptr.h are going away, so stop using them

content/renderer/media/webrtc/peer_connection_dependency_factory.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 "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 366 matching lines @@
 scoped_refptr<webrtc::PeerConnectionInterface>
 PeerConnectionDependencyFactory::CreatePeerConnection(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     blink::WebFrame* web_frame,
     webrtc::PeerConnectionObserver* observer) {
   CHECK(web_frame);
   CHECK(observer);
   if (!GetPcFactory().get())
     return NULL;
 
-  rtc::scoped_ptr<PeerConnectionIdentityStore> identity_store(
+  std::unique_ptr<PeerConnectionIdentityStore> identity_store(
       new PeerConnectionIdentityStore(
           base::ThreadTaskRunnerHandle::Get(), GetWebRtcSignalingThread(),
           GURL(web_frame->document().url()),
           GURL(web_frame->document().firstPartyForCookies())));
 
   // Copy the flag from Preference associated with this WebFrame.
   P2PPortAllocator::Config port_config;
 
   // |media_permission| will be called to check mic/camera permission. If at
   // least one of them is granted, P2PPortAllocator is allowed to gather local
@@ skipping 88 matching lines @@
       // time. It's safe to use Unretained here since both destructor and
       // Initialize can only be called on the worker thread.
       chrome_worker_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&FilteringNetworkManager::Initialize,
                                 base::Unretained(filtering_network_manager)));
     }
     network_manager.reset(filtering_network_manager);
   } else {
     network_manager.reset(new EmptyNetworkManager(network_manager_));
   }
-  rtc::scoped_ptr<P2PPortAllocator> port_allocator(new P2PPortAllocator(
+  std::unique_ptr<P2PPortAllocator> port_allocator(new P2PPortAllocator(
       p2p_socket_dispatcher_, std::move(network_manager), socket_factory_.get(),
       port_config, requesting_origin, chrome_worker_thread_.task_runner()));
 
   return GetPcFactory()
       ->CreatePeerConnection(config, std::move(port_allocator),
                              std::move(identity_store), observer)
       .get();
 }
 
 // static
 rtc::scoped_refptr<rtc::RTCCertificate>
 PeerConnectionDependencyFactory::GenerateDefaultCertificate() {
-  rtc::scoped_ptr<rtc::SSLIdentity> identity(rtc::SSLIdentity::Generate(
+  std::unique_ptr<rtc::SSLIdentity> identity(rtc::SSLIdentity::Generate(
       webrtc::kIdentityName, rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)));
   return rtc::RTCCertificate::Create(std::move(identity));
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return GetPcFactory()->CreateLocalMediaStream(label).get();
 }
 
@@ skipping 259 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content