Check cancellation before reporting crypto result.

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 357 matching lines @@
 };
 
 // --------------------------------------------------------------------
 // Wrapper functions
 // --------------------------------------------------------------------
 //
 // * The methods named Do*() run on the crypto thread.
 // * The methods named Do*Reply() run on the target Blink thread
 
 void DoEncryptReply(scoped_ptr<EncryptState> state) {
+  if (state->cancelled())
+    return;
   CompleteWithBufferOrError(state->status, state->buffer, &state->result);
 }
 
 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)));
 }
 
 void DoDecryptReply(scoped_ptr<DecryptState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoDigestReply(scoped_ptr<DigestState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoGenerateKeyReply(scoped_ptr<GenerateKeyState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoImportKeyReply(scoped_ptr<ImportKeyState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoExportKeyReply(scoped_ptr<ExportKeyState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoSignReply(scoped_ptr<SignState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoVerifyReply(scoped_ptr<VerifySignatureState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoWrapKeyReply(scoped_ptr<WrapKeyState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoUnwrapKeyReply(scoped_ptr<UnwrapKeyState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoDeriveBitsReply(scoped_ptr<DeriveBitsState> state) {
+  if (state->cancelled())
+    return;
   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)));
 }
 
 void DoDeriveKeyReply(scoped_ptr<DeriveKeyState> state) {
+  if (state->cancelled())
+    return;
   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,
@@ skipping 200 matching lines @@
       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