Convert Pass()→std::move() in //media

media/cdm/proxy_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/proxy_decryptor.h"
 
 #include <stddef.h>
-
 #include <cstring>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_factory.h"
@@ skipping 158 matching lines @@
                  session_creation_type),
       base::Bind(&ProxyDecryptor::OnLegacySessionError,
                  weak_ptr_factory_.GetWeakPtr(),
                  std::string())));  // No session id until created.
 
   if (session_creation_type == LoadSession) {
     media_keys_->LoadSession(
         MediaKeys::PERSISTENT_LICENSE_SESSION,
         std::string(reinterpret_cast<const char*>(stripped_init_data.data()),
                     stripped_init_data.size()),
-        promise.Pass());
+        std::move(promise));
     return;
   }
 
   MediaKeys::SessionType session_type =
       session_creation_type == PersistentSession
           ? MediaKeys::PERSISTENT_LICENSE_SESSION
           : MediaKeys::TEMPORARY_SESSION;
 
   // No permission required when AesDecryptor is used or when the key system is
   // external clear key.
   DCHECK(!key_system_.empty());
   if (CanUseAesDecryptor(key_system_) || IsExternalClearKey(key_system_)) {
     OnPermissionStatus(session_type, init_data_type, stripped_init_data,
-                       promise.Pass(), true /* granted */);
+                       std::move(promise), true /* granted */);
     return;
   }
 
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   media_permission_->RequestPermission(
       MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin_,
       base::Bind(&ProxyDecryptor::OnPermissionStatus,
                  weak_ptr_factory_.GetWeakPtr(), session_type, init_data_type,
                  stripped_init_data, base::Passed(&promise)));
 #else
   OnPermissionStatus(session_type, init_data_type, stripped_init_data,
-                     promise.Pass(), true /* granted */);
+                     std::move(promise), true /* granted */);
 #endif
 }
 
 void ProxyDecryptor::OnPermissionStatus(
     MediaKeys::SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise,
     bool granted) {
   // ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is
   // only for triggering the permission UI. Later CheckPermission() will be
   // called (e.g. in PlatformVerificationFlow on ChromeOS; in BrowserCdmManager
   // on Android) and the permission status will be evaluated then.
   DVLOG_IF(1, !granted) << "Permission request rejected.";
 
   media_keys_->CreateSessionAndGenerateRequest(session_type, init_data_type,
-                                               init_data, promise.Pass());
+                                               init_data, std::move(promise));
 }
 
 void ProxyDecryptor::AddKey(const uint8_t* key,
                             int key_length,
                             const uint8_t* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
   if (!media_keys_) {
@@ skipping 33 matching lines @@
       static const uint8_t kDummyInitData[1] = {0};
       init_data = kDummyInitData;
       init_data_length = arraysize(kDummyInitData);
     }
 
     std::string jwk =
         GenerateJWKSet(key, key_length, init_data, init_data_length);
     DCHECK(!jwk.empty());
     media_keys_->UpdateSession(new_session_id,
                                std::vector<uint8_t>(jwk.begin(), jwk.end()),
-                               promise.Pass());
+                               std::move(promise));
     return;
   }
 
   media_keys_->UpdateSession(new_session_id,
                              std::vector<uint8_t>(key, key + key_length),
-                             promise.Pass());
+                             std::move(promise));
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   if (!media_keys_) {
     OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
                          "CDM is not available.");
     return;
   }
 
   scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr(), session_id),
       base::Bind(&ProxyDecryptor::OnLegacySessionError,
                  weak_ptr_factory_.GetWeakPtr(), session_id)));
-  media_keys_->RemoveSession(session_id, promise.Pass());
+  media_keys_->RemoveSession(session_id, std::move(promise));
 }
 
 void ProxyDecryptor::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
                                       const std::vector<uint8_t>& message,
                                       const GURL& legacy_destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
 
   // For ClearKey, convert the message from JSON into just passing the key
   // as the message. If unable to extract the key, return the message unchanged.
@@ skipping 87 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media