Use std::default_delete as the default deleter for scoped_ptr.

components/webcrypto/webcrypto_impl.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 "components/webcrypto/webcrypto_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 367 matching lines @@
 }
 
 void DoEncrypt(scoped_ptr<EncryptState> passed_state) {
   EncryptState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::Encrypt(state->algorithm, state->key,
                          webcrypto::CryptoData(state->data), &state->buffer);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoEncryptReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoEncryptReply, base::Passed(&passed_state)));
 }
 
 void DoDecryptReply(scoped_ptr<DecryptState> state) {
   CompleteWithBufferOrError(state->status, state->buffer, &state->result);
 }
 
 void DoDecrypt(scoped_ptr<DecryptState> passed_state) {
   DecryptState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::Decrypt(state->algorithm, state->key,
                          webcrypto::CryptoData(state->data), &state->buffer);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoDecryptReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoDecryptReply, base::Passed(&passed_state)));
 }
 
 void DoDigestReply(scoped_ptr<DigestState> state) {
   CompleteWithBufferOrError(state->status, state->buffer, &state->result);
 }
 
 void DoDigest(scoped_ptr<DigestState> passed_state) {
   DigestState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::Digest(
       state->algorithm, webcrypto::CryptoData(state->data), &state->buffer);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoDigestReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoDigestReply, base::Passed(&passed_state)));
 }
 
 void DoGenerateKeyReply(scoped_ptr<GenerateKeyState> state) {
   if (state->status.IsError()) {
     CompleteWithError(state->status, &state->result);
   } else {
     state->generate_key_result.Complete(&state->result);
   }
 }
 
 void DoGenerateKey(scoped_ptr<GenerateKeyState> passed_state) {
   GenerateKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::GenerateKey(state->algorithm, state->extractable,
                              state->usages, &state->generate_key_result);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoGenerateKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoGenerateKeyReply, base::Passed(&passed_state)));
 }
 
 void DoImportKeyReply(scoped_ptr<ImportKeyState> state) {
   CompleteWithKeyOrError(state->status, state->key, &state->result);
 }
 
 void DoImportKey(scoped_ptr<ImportKeyState> passed_state) {
   ImportKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::ImportKey(
       state->format, webcrypto::CryptoData(state->key_data), state->algorithm,
       state->extractable, state->usages, &state->key);
   if (state->status.IsSuccess()) {
     DCHECK(state->key.handle());
     DCHECK(!state->key.algorithm().isNull());
     DCHECK_EQ(state->extractable, state->key.extractable());
   }
 
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoImportKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoImportKeyReply, base::Passed(&passed_state)));
 }
 
 void DoExportKeyReply(scoped_ptr<ExportKeyState> state) {
   if (state->format != blink::WebCryptoKeyFormatJwk) {
     CompleteWithBufferOrError(state->status, state->buffer, &state->result);
     return;
   }
 
   if (state->status.IsError()) {
     CompleteWithError(state->status, &state->result);
   } else {
     state->result.completeWithJson(
         reinterpret_cast<const char*>(vector_as_array(&state->buffer)),
         static_cast<unsigned int>(state->buffer.size()));
   }
 }
 
 void DoExportKey(scoped_ptr<ExportKeyState> passed_state) {
   ExportKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::ExportKey(state->format, state->key, &state->buffer);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoExportKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoExportKeyReply, base::Passed(&passed_state)));
 }
 
 void DoSignReply(scoped_ptr<SignState> state) {
   CompleteWithBufferOrError(state->status, state->buffer, &state->result);
 }
 
 void DoSign(scoped_ptr<SignState> passed_state) {
   SignState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::Sign(state->algorithm, state->key,
                       webcrypto::CryptoData(state->data), &state->buffer);
 
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoSignReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoSignReply, base::Passed(&passed_state)));
 }
 
 void DoVerifyReply(scoped_ptr<VerifySignatureState> state) {
   if (state->status.IsError()) {
     CompleteWithError(state->status, &state->result);
   } else {
     state->result.completeWithBoolean(state->verify_result);
   }
 }
 
 void DoVerify(scoped_ptr<VerifySignatureState> passed_state) {
   VerifySignatureState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::Verify(
       state->algorithm, state->key, webcrypto::CryptoData(state->signature),
       webcrypto::CryptoData(state->data), &state->verify_result);
 
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoVerifyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoVerifyReply, base::Passed(&passed_state)));
 }
 
 void DoWrapKeyReply(scoped_ptr<WrapKeyState> state) {
   CompleteWithBufferOrError(state->status, state->buffer, &state->result);
 }
 
 void DoWrapKey(scoped_ptr<WrapKeyState> passed_state) {
   WrapKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::WrapKey(state->format, state->key, state->wrapping_key,
                          state->wrap_algorithm, &state->buffer);
 
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoWrapKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoWrapKeyReply, base::Passed(&passed_state)));
 }
 
 void DoUnwrapKeyReply(scoped_ptr<UnwrapKeyState> state) {
   CompleteWithKeyOrError(state->status, state->unwrapped_key, &state->result);
 }
 
 void DoUnwrapKey(scoped_ptr<UnwrapKeyState> passed_state) {
   UnwrapKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::UnwrapKey(
       state->format, webcrypto::CryptoData(state->wrapped_key),
       state->wrapping_key, state->unwrap_algorithm,
       state->unwrapped_key_algorithm, state->extractable, state->usages,
       &state->unwrapped_key);
 
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoUnwrapKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoUnwrapKeyReply, base::Passed(&passed_state)));
 }
 
 void DoDeriveBitsReply(scoped_ptr<DeriveBitsState> state) {
   CompleteWithBufferOrError(state->status, state->derived_bytes,
                             &state->result);
 }
 
 void DoDeriveBits(scoped_ptr<DeriveBitsState> passed_state) {
   DeriveBitsState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status =
       webcrypto::DeriveBits(state->algorithm, state->base_key,
                             state->length_bits, &state->derived_bytes);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoDeriveBitsReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoDeriveBitsReply, base::Passed(&passed_state)));
 }
 
 void DoDeriveKeyReply(scoped_ptr<DeriveKeyState> state) {
   CompleteWithKeyOrError(state->status, state->derived_key, &state->result);
 }
 
 void DoDeriveKey(scoped_ptr<DeriveKeyState> passed_state) {
   DeriveKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::DeriveKey(
       state->algorithm, state->base_key, state->import_algorithm,
       state->key_length_algorithm, state->extractable, state->usages,
       &state->derived_key);
   state->origin_thread->PostTask(
-      FROM_HERE, base::Bind(DoDeriveKeyReply, Passed(&passed_state)));
+      FROM_HERE, base::Bind(DoDeriveKeyReply, base::Passed(&passed_state)));
 }
 
 }  // namespace
 
 WebCryptoImpl::WebCryptoImpl() {
 }
 
 WebCryptoImpl::~WebCryptoImpl() {
 }
 
 void WebCryptoImpl::encrypt(const blink::WebCryptoAlgorithm& algorithm,
                             const blink::WebCryptoKey& key,
                             const unsigned char* data,
                             unsigned int data_size,
                             blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   scoped_ptr<EncryptState> state(
       new EncryptState(algorithm, key, data, data_size, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoEncrypt, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoEncrypt, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::decrypt(const blink::WebCryptoAlgorithm& algorithm,
                             const blink::WebCryptoKey& key,
                             const unsigned char* data,
                             unsigned int data_size,
                             blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   scoped_ptr<DecryptState> state(
       new DecryptState(algorithm, key, data, data_size, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoDecrypt, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoDecrypt, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::digest(const blink::WebCryptoAlgorithm& algorithm,
                            const unsigned char* data,
                            unsigned int data_size,
                            blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   scoped_ptr<DigestState> state(new DigestState(
       algorithm, blink::WebCryptoKey::createNull(), data, data_size, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoDigest, Passed(&state)))) {
+                                  base::Bind(DoDigest, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::generateKey(const blink::WebCryptoAlgorithm& algorithm,
                                 bool extractable,
                                 blink::WebCryptoKeyUsageMask usages,
                                 blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   scoped_ptr<GenerateKeyState> state(
       new GenerateKeyState(algorithm, extractable, usages, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoGenerateKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoGenerateKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::importKey(blink::WebCryptoKeyFormat format,
                               const unsigned char* key_data,
                               unsigned int key_data_size,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usages,
                               blink::WebCryptoResult result) {
   scoped_ptr<ImportKeyState> state(new ImportKeyState(
       format, key_data, key_data_size, algorithm, extractable, usages, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoImportKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoImportKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::exportKey(blink::WebCryptoKeyFormat format,
                               const blink::WebCryptoKey& key,
                               blink::WebCryptoResult result) {
   scoped_ptr<ExportKeyState> state(new ExportKeyState(format, key, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoExportKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoExportKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::sign(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& key,
                          const unsigned char* data,
                          unsigned int data_size,
                          blink::WebCryptoResult result) {
   scoped_ptr<SignState> state(
       new SignState(algorithm, key, data, data_size, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoSign, Passed(&state)))) {
+                                  base::Bind(DoSign, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::verifySignature(const blink::WebCryptoAlgorithm& algorithm,
                                     const blink::WebCryptoKey& key,
                                     const unsigned char* signature,
                                     unsigned int signature_size,
                                     const unsigned char* data,
                                     unsigned int data_size,
                                     blink::WebCryptoResult result) {
   scoped_ptr<VerifySignatureState> state(new VerifySignatureState(
       algorithm, key, signature, signature_size, data, data_size, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoVerify, Passed(&state)))) {
+                                  base::Bind(DoVerify, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::wrapKey(blink::WebCryptoKeyFormat format,
                             const blink::WebCryptoKey& key,
                             const blink::WebCryptoKey& wrapping_key,
                             const blink::WebCryptoAlgorithm& wrap_algorithm,
                             blink::WebCryptoResult result) {
   scoped_ptr<WrapKeyState> state(
       new WrapKeyState(format, key, wrapping_key, wrap_algorithm, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoWrapKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoWrapKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::unwrapKey(
     blink::WebCryptoKeyFormat format,
     const unsigned char* wrapped_key,
     unsigned wrapped_key_size,
     const blink::WebCryptoKey& wrapping_key,
     const blink::WebCryptoAlgorithm& unwrap_algorithm,
     const blink::WebCryptoAlgorithm& unwrapped_key_algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoResult result) {
   scoped_ptr<UnwrapKeyState> state(new UnwrapKeyState(
       format, wrapped_key, wrapped_key_size, wrapping_key, unwrap_algorithm,
       unwrapped_key_algorithm, extractable, usages, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoUnwrapKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoUnwrapKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::deriveBits(const blink::WebCryptoAlgorithm& algorithm,
                                const blink::WebCryptoKey& base_key,
                                unsigned int length_bits,
                                blink::WebCryptoResult result) {
   scoped_ptr<DeriveBitsState> state(
       new DeriveBitsState(algorithm, base_key, length_bits, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoDeriveBits, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoDeriveBits, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::deriveKey(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& base_key,
     const blink::WebCryptoAlgorithm& import_algorithm,
     const blink::WebCryptoAlgorithm& key_length_algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoResult result) {
   scoped_ptr<DeriveKeyState> state(
       new DeriveKeyState(algorithm, base_key, import_algorithm,
                          key_length_algorithm, extractable, usages, result));
-  if (!CryptoThreadPool::PostTask(FROM_HERE,
-                                  base::Bind(DoDeriveKey, Passed(&state)))) {
+  if (!CryptoThreadPool::PostTask(
+          FROM_HERE, base::Bind(DoDeriveKey, base::Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 blink::WebCryptoDigestor* WebCryptoImpl::createDigestor(
     blink::WebCryptoAlgorithmId algorithm_id) {
   return webcrypto::CreateDigestor(algorithm_id).release();
 }
 
 bool WebCryptoImpl::deserializeKeyForClone(
     const blink::WebCryptoKeyAlgorithm& algorithm,
     blink::WebCryptoKeyType type,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     const unsigned char* key_data,
     unsigned key_data_size,
     blink::WebCryptoKey& key) {
   return webcrypto::DeserializeKeyForClone(
       algorithm, type, extractable, usages,
       webcrypto::CryptoData(key_data, key_data_size), &key);
 }
 
 bool WebCryptoImpl::serializeKeyForClone(
     const blink::WebCryptoKey& key,
     blink::WebVector<unsigned char>& key_data) {
   return webcrypto::SerializeKeyForClone(key, &key_data);
 }
 
 }  // namespace webcrypto