Convert Pass()→std::move() 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>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_key_information.h"
@@ skipping 369 matching lines @@
   {
     base::AutoLock auto_lock(key_map_lock_);
     for (const auto& item : key_map_) {
       if (item.second->Contains(session_id)) {
         keys_info.push_back(
             new CdmKeyInformation(item.first, CdmKeyInformation::USABLE, 0));
       }
     }
   }
 
-  session_keys_change_cb_.Run(session_id, key_added, keys_info.Pass());
+  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) {
   // 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) {
   // 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()) {
-    CloseSession(session_id, promise.Pass());
+    CloseSession(session_id, std::move(promise));
     return;
   }
 
   promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
 }
 
 CdmContext* AesDecryptor::GetCdmContext() {
   return this;
 }
 
@@ skipping 98 matching lines @@
                                     const std::string& key_string) {
   scoped_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, decryption_key.Pass());
+    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(
       new SessionIdDecryptionKeyMap());
-  inner_map->Insert(session_id, decryption_key.Pass());
-  key_map_.add(key_id, inner_map.Pass());
+  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);
   if (key_id_found == key_map_.end())
     return NULL;
 
@@ skipping 41 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