Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cdm/browser_cdm_cast.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 "chromecast/media/cdm/browser_cdm_cast.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromecast/media/base/media_resource_tracker.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/cdm/player_tracker_impl.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 // media::CdmPromiseTemplate implementation that wraps a promise so as to
 // allow passing to other threads.
 template <typename... T>
 class CdmPromiseInternal : public ::media::CdmPromiseTemplate<T...> {
  public:
-  CdmPromiseInternal(scoped_ptr<::media::CdmPromiseTemplate<T...>> promise)
+  CdmPromiseInternal(std::unique_ptr<::media::CdmPromiseTemplate<T...>> promise)
       : task_runner_(base::ThreadTaskRunnerHandle::Get()),
         promise_(std::move(promise)) {}
 
   ~CdmPromiseInternal() final {
     if (IsPromiseSettled())
       return;
 
     DCHECK(promise_);
     RejectPromiseOnDestruction();
   }
@@ skipping 11 matching lines @@
                    base::Owned(promise_.release()),
                    exception, system_code, error_message));
   }
 
  private:
   using ::media::CdmPromiseTemplate<T...>::IsPromiseSettled;
   using ::media::CdmPromiseTemplate<T...>::MarkPromiseSettled;
   using ::media::CdmPromiseTemplate<T...>::RejectPromiseOnDestruction;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_ptr<::media::CdmPromiseTemplate<T...>> promise_;
+  std::unique_ptr<::media::CdmPromiseTemplate<T...>> promise_;
 };
 
 template <typename... T>
 void CdmPromiseInternal<T...>::resolve(const T&... result) {
   MarkPromiseSettled();
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&::media::CdmPromiseTemplate<T...>::resolve,
                  base::Owned(promise_.release()),
                  result...));
 }
 
 template <typename... T>
-scoped_ptr<CdmPromiseInternal<T...>> BindPromiseToCurrentLoop(
-    scoped_ptr<::media::CdmPromiseTemplate<T...>> promise) {
-  return make_scoped_ptr(new CdmPromiseInternal<T...>(std::move(promise)));
+std::unique_ptr<CdmPromiseInternal<T...>> BindPromiseToCurrentLoop(
+    std::unique_ptr<::media::CdmPromiseTemplate<T...>> promise) {
+  return base::WrapUnique(new CdmPromiseInternal<T...>(std::move(promise)));
 }
 
 }  // namespace
 
 BrowserCdmCast::BrowserCdmCast(MediaResourceTracker* media_resource_tracker)
     : media_resource_tracker_(media_resource_tracker) {
   DCHECK(media_resource_tracker);
   thread_checker_.DetachFromThread();
 }
 
@@ skipping 58 matching lines @@
 
   if (newly_usable_keys)
     player_tracker_impl_->NotifyNewKey();
 }
 
 void BrowserCdmCast::KeyIdAndKeyPairsToInfo(
     const ::media::KeyIdAndKeyPairs& keys,
     ::media::CdmKeysInfo* keys_info) {
   DCHECK(keys_info);
   for (const std::pair<std::string, std::string>& key : keys) {
-    scoped_ptr<::media::CdmKeyInformation> cdm_key_information(
+    std::unique_ptr<::media::CdmKeyInformation> cdm_key_information(
         new ::media::CdmKeyInformation(key.first,
                                        ::media::CdmKeyInformation::USABLE, 0));
     keys_info->push_back(cdm_key_information.release());
   }
 }
 
 // A macro runs current member function on |task_runner_| thread.
 #define FORWARD_ON_CDM_THREAD(param_fn, ...) \
   task_runner_->PostTask(                    \
       FROM_HERE,                             \
@@ skipping 13 matching lines @@
   task_runner_->ReleaseSoon(FROM_HERE, raw_cdm);
 }
 
 BrowserCdmCast* BrowserCdmCastUi::browser_cdm_cast() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return browser_cdm_cast_.get();
 }
 
 void BrowserCdmCastUi::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
-    scoped_ptr<::media::SimpleCdmPromise> promise) {
+    std::unique_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       SetServerCertificate, certificate,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::CreateSessionAndGenerateRequest(
     ::media::MediaKeys::SessionType session_type,
     ::media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
-    scoped_ptr<::media::NewSessionCdmPromise> promise) {
+    std::unique_ptr<::media::NewSessionCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       CreateSessionAndGenerateRequest, session_type, init_data_type, init_data,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::LoadSession(
     ::media::MediaKeys::SessionType session_type,
     const std::string& session_id,
-    scoped_ptr<::media::NewSessionCdmPromise> promise) {
+    std::unique_ptr<::media::NewSessionCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       LoadSession, session_type, session_id,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
-    scoped_ptr<::media::SimpleCdmPromise> promise) {
+    std::unique_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       UpdateSession, session_id, response,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::CloseSession(
     const std::string& session_id,
-    scoped_ptr<::media::SimpleCdmPromise> promise) {
+    std::unique_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       CloseSession, session_id,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 void BrowserCdmCastUi::RemoveSession(
     const std::string& session_id,
-    scoped_ptr<::media::SimpleCdmPromise> promise) {
+    std::unique_ptr<::media::SimpleCdmPromise> promise) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FORWARD_ON_CDM_THREAD(
       RemoveSession, session_id,
       base::Passed(BindPromiseToCurrentLoop(std::move(promise))));
 }
 
 // A default empty implementation for subclasses that don't need to provide
 // any key system specific initialization.
 void BrowserCdmCast::InitializeInternal() {
 }
 
 }  // namespace media
 }  // namespace chromecast