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

content/renderer/media/rtc_certificate_generator.cc

 // Copyright (c) 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 "content/renderer/media/rtc_certificate_generator.h"
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 58 matching lines @@
         &RTCCertificateIdentityObserver::RequestIdentityOnWebRtcSignalingThread,
         this, url, first_party_for_cookies, expires_ms));
   }
 
  private:
   void RequestIdentityOnWebRtcSignalingThread(
       GURL url,
       GURL first_party_for_cookies,
       rtc::Optional<uint64_t> expires_ms) {
     DCHECK(signaling_thread_->BelongsToCurrentThread());
-    rtc::scoped_ptr<PeerConnectionIdentityStore> store(
+    std::unique_ptr<PeerConnectionIdentityStore> store(
         new PeerConnectionIdentityStore(main_thread_, signaling_thread_, url,
                                         first_party_for_cookies));
     // Request identity with |this| as the observer. OnSuccess/OnFailure will be
     // called asynchronously.
     store->RequestIdentity(WebRTCKeyParamsToKeyParams(key_params_),
                            expires_ms, this);
   }
 
   // webrtc::DtlsIdentityRequestObserver implementation.
   void OnFailure(int error) override {
     DCHECK(signaling_thread_->BelongsToCurrentThread());
     DCHECK(observer_);
     main_thread_->PostTask(FROM_HERE, base::Bind(
         &RTCCertificateIdentityObserver::DoCallbackOnMainThread,
         this, nullptr));
   }
   void OnSuccess(const std::string& der_cert,
                  const std::string& der_private_key) override {
     std::string pem_cert = rtc::SSLIdentity::DerToPem(
         rtc::kPemTypeCertificate,
         reinterpret_cast<const unsigned char*>(der_cert.data()),
         der_cert.length());
     std::string pem_key = rtc::SSLIdentity::DerToPem(
         rtc::kPemTypeRsaPrivateKey,
         reinterpret_cast<const unsigned char*>(der_private_key.data()),
         der_private_key.length());
-    OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity>(
+    OnSuccess(std::unique_ptr<rtc::SSLIdentity>(
         rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert)));
   }
-  void OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity> identity) override {
+  void OnSuccess(std::unique_ptr<rtc::SSLIdentity> identity) override {
     DCHECK(signaling_thread_->BelongsToCurrentThread());
     DCHECK(observer_);
     rtc::scoped_refptr<rtc::RTCCertificate> certificate =
         rtc::RTCCertificate::Create(std::move(identity));
     main_thread_->PostTask(
         FROM_HERE,
         base::Bind(&RTCCertificateIdentityObserver::DoCallbackOnMainThread,
                    this, base::Passed(base::WrapUnique(
                              new RTCCertificate(key_params_, certificate)))));
   }
@@ skipping 71 matching lines @@
   observer->onError();
 #endif
 }
 
 bool RTCCertificateGenerator::isSupportedKeyParams(
     const blink::WebRTCKeyParams& key_params) {
   return WebRTCKeyParamsToKeyParams(key_params).IsValid();
 }
 
 }  // namespace content