Replace scoped_ptr with std::unique_ptr in //media.

media/cdm/aes_decryptor.cc

 // Copyright 2013 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 "media/cdm/aes_decryptor.h"
 
 #include <stddef.h>
 #include <list>
 #include <utility>
 #include <vector>
@@ skipping 29 matching lines @@
   typedef std::list<std::pair<std::string, DecryptionKey*> > KeyList;
 
  public:
   SessionIdDecryptionKeyMap() {}
   ~SessionIdDecryptionKeyMap() { STLDeleteValues(&key_list_); }
 
   // Replaces value if |session_id| is already present, or adds it if not.
   // This |decryption_key| becomes the latest until another insertion or
   // |session_id| is erased.
   void Insert(const std::string& session_id,
-              scoped_ptr<DecryptionKey> decryption_key);
+              std::unique_ptr<DecryptionKey> decryption_key);
 
   // Deletes the entry for |session_id| if present.
   void Erase(const std::string& session_id);
 
   // Returns whether the list is empty
   bool Empty() const { return key_list_.empty(); }
 
   // Returns the last inserted DecryptionKey.
   DecryptionKey* LatestDecryptionKey() {
     DCHECK(!key_list_.empty());
@@ skipping 11 matching lines @@
   // Deletes the entry pointed to by |position|.
   void Erase(KeyList::iterator position);
 
   KeyList key_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionIdDecryptionKeyMap);
 };
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Insert(
     const std::string& session_id,
-    scoped_ptr<DecryptionKey> decryption_key) {
+    std::unique_ptr<DecryptionKey> decryption_key) {
   KeyList::iterator it = Find(session_id);
   if (it != key_list_.end())
     Erase(it);
   DecryptionKey* raw_ptr = decryption_key.release();
   key_list_.push_front(std::make_pair(session_id, raw_ptr));
 }
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
     const std::string& session_id) {
   KeyList::iterator it = Find(session_id);
@@ skipping 108 matching lines @@
     return DecoderBuffer::CopyFrom(reinterpret_cast<const uint8_t*>(sample),
                                    sample_size);
   }
 
   // The encrypted portions of all subsamples must form a contiguous block,
   // such that an encrypted subsample that ends away from a block boundary is
   // immediately followed by the start of the next encrypted subsample. We
   // copy all encrypted subsamples to a contiguous buffer, decrypt them, then
   // copy the decrypted bytes over the encrypted bytes in the output.
   // TODO(strobe): attempt to reduce number of memory copies
-  scoped_ptr<uint8_t[]> encrypted_bytes(new uint8_t[total_encrypted_size]);
+  std::unique_ptr<uint8_t[]> encrypted_bytes(new uint8_t[total_encrypted_size]);
   CopySubsamples(subsamples, kSrcContainsClearBytes,
                  reinterpret_cast<const uint8_t*>(sample),
                  encrypted_bytes.get());
 
   base::StringPiece encrypted_text(
       reinterpret_cast<const char*>(encrypted_bytes.get()),
       total_encrypted_size);
   std::string decrypted_text;
   if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
     DVLOG(1) << "Could not decrypt data.";
@@ skipping 20 matching lines @@
   // with |security_origin|.
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
 }
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
 
-void AesDecryptor::SetServerCertificate(const std::vector<uint8_t>& certificate,
-                                        scoped_ptr<SimpleCdmPromise> promise) {
+void AesDecryptor::SetServerCertificate(
+    const std::vector<uint8_t>& certificate,
+    std::unique_ptr<SimpleCdmPromise> promise) {
   promise->reject(
       NOT_SUPPORTED_ERROR, 0, "SetServerCertificate() is not supported.");
 }
 
 void AesDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
-    scoped_ptr<NewSessionCdmPromise> promise) {
+    std::unique_ptr<NewSessionCdmPromise> promise) {
   std::string session_id(base::UintToString(next_session_id_++));
   valid_sessions_.insert(session_id);
 
   // For now, the AesDecryptor does not care about |session_type|.
   // TODO(jrummell): Validate |session_type|.
 
   std::vector<uint8_t> message;
   // TODO(jrummell): Since unprefixed will never send NULL, remove this check
   // when prefixed EME is removed (http://crbug.com/249976).
   if (!init_data.empty()) {
@@ skipping 38 matching lines @@
 
   promise->resolve(session_id);
 
   // No URL needed for license requests.
   GURL empty_gurl;
   session_message_cb_.Run(session_id, LICENSE_REQUEST, message, empty_gurl);
 }
 
 void AesDecryptor::LoadSession(SessionType session_type,
                                const std::string& session_id,
-                               scoped_ptr<NewSessionCdmPromise> promise) {
+                               std::unique_ptr<NewSessionCdmPromise> promise) {
   // TODO(xhwang): Change this to NOTREACHED() when blink checks for key systems
   // that do not support loadSession. See http://crbug.com/342481
   promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
 }
 
 void AesDecryptor::UpdateSession(const std::string& session_id,
                                  const std::vector<uint8_t>& response,
-                                 scoped_ptr<SimpleCdmPromise> promise) {
+                                 std::unique_ptr<SimpleCdmPromise> promise) {
   CHECK(!response.empty());
 
   // TODO(jrummell): Convert back to a DCHECK once prefixed EME is removed.
   if (valid_sessions_.find(session_id) == valid_sessions_.end()) {
     promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
     return;
   }
 
   std::string key_string(response.begin(), response.end());
 
@@ skipping 53 matching lines @@
         keys_info.push_back(
             new CdmKeyInformation(item.first, CdmKeyInformation::USABLE, 0));
       }
     }
   }
 
   session_keys_change_cb_.Run(session_id, key_added, std::move(keys_info));
 }
 
 void AesDecryptor::CloseSession(const std::string& session_id,
-                                scoped_ptr<SimpleCdmPromise> promise) {
+                                std::unique_ptr<SimpleCdmPromise> promise) {
   // Validate that this is a reference to an active session and then forget it.
   std::set<std::string>::iterator it = valid_sessions_.find(session_id);
   DCHECK(it != valid_sessions_.end());
 
   valid_sessions_.erase(it);
 
   // Close the session.
   DeleteKeysForSession(session_id);
   promise->resolve();
   session_closed_cb_.Run(session_id);
 }
 
 void AesDecryptor::RemoveSession(const std::string& session_id,
-                                 scoped_ptr<SimpleCdmPromise> promise) {
+                                 std::unique_ptr<SimpleCdmPromise> promise) {
   // AesDecryptor doesn't keep any persistent data, so this should be
   // NOT_REACHED().
   // TODO(jrummell): Make sure persistent session types are rejected.
   // http://crbug.com/384152.
   //
   // However, v0.1b calls to CancelKeyRequest() will call this, so close the
   // session, if it exists.
   // TODO(jrummell): Remove the close() call when prefixed EME is removed.
   // http://crbug.com/249976.
   if (valid_sessions_.find(session_id) != valid_sessions_.end()) {
@@ skipping 100 matching lines @@
 
 void AesDecryptor::DeinitializeDecoder(StreamType stream_type) {
   // AesDecryptor does not support audio/video decoding, but since this can be
   // called any time after InitializeAudioDecoder/InitializeVideoDecoder,
   // nothing to be done here.
 }
 
 bool AesDecryptor::AddDecryptionKey(const std::string& session_id,
                                     const std::string& key_id,
                                     const std::string& key_string) {
-  scoped_ptr<DecryptionKey> decryption_key(new DecryptionKey(key_string));
+  std::unique_ptr<DecryptionKey> decryption_key(new DecryptionKey(key_string));
   if (!decryption_key->Init()) {
     DVLOG(1) << "Could not initialize decryption key.";
     return false;
   }
 
   base::AutoLock auto_lock(key_map_lock_);
   KeyIdToSessionKeysMap::iterator key_id_entry = key_map_.find(key_id);
   if (key_id_entry != key_map_.end()) {
     key_id_entry->second->Insert(session_id, std::move(decryption_key));
     return true;
   }
 
   // |key_id| not found, so need to create new entry.
-  scoped_ptr<SessionIdDecryptionKeyMap> inner_map(
+  std::unique_ptr<SessionIdDecryptionKeyMap> inner_map(
       new SessionIdDecryptionKeyMap());
   inner_map->Insert(session_id, std::move(decryption_key));
   key_map_.add(key_id, std::move(inner_map));
   return true;
 }
 
 AesDecryptor::DecryptionKey* AesDecryptor::GetKey_Locked(
     const std::string& key_id) const {
   key_map_lock_.AssertAcquired();
   KeyIdToSessionKeysMap::const_iterator key_id_found = key_map_.find(key_id);
@@ skipping 44 matching lines @@
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_.reset(crypto::SymmetricKey::Import(
       crypto::SymmetricKey::AES, secret_));
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media