[webcrypto] Don't execute cancelled crypto operations.

content/child/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 "content/child/webcrypto/webcrypto_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 152 matching lines @@
 //
 // Ownership of the State object is passed between the crypto thread and the
 // Blink thread. Under normal completion it is destroyed on the Blink thread.
 // However it may also be destroyed on the crypto thread if the Blink thread
 // has vanished (which can happen for Blink web worker threads).
 
 struct BaseState {
   explicit BaseState(const blink::WebCryptoResult& result)
       : origin_thread(GetCurrentBlinkThread()), result(result) {}
 
+  bool cancelled() {
+#ifdef WEBCRYPTO_RESULT_HAS_CANCELLED
+    return result.cancelled();

[Ryan Sleevi, 2014/06/18 23:59:51]

Is this really safe? Seems like we try to only access |result| on
|origin_thread|, but your DoOp friends will be accessing it from the worker
thread.

+#else
+    return false;
+#endif
+  }
+
   scoped_refptr<base::TaskRunner> origin_thread;
 
   webcrypto::Status status;
   blink::WebCryptoResult result;
 
  protected:
   // Since there is no virtual destructor, must not delete directly as a
   // BaseState.
   ~BaseState() {}
 };
@@ skipping 162 matching lines @@
 //
 // * 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) {
   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) {
   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) {
   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->status.IsError()) {
     CompleteWithError(state->status, &state->result);
   } else {
     if (state->is_asymmetric)
       state->result.completeWithKeyPair(state->public_key, state->private_key);
     else
       state->result.completeWithKey(state->public_key);
   }
 }
 
 void DoGenerateKey(scoped_ptr<GenerateKeyState> passed_state) {
   GenerateKeyState* state = passed_state.get();
+  if (state->cancelled())
+    return;
   state->is_asymmetric =
       webcrypto::IsAlgorithmAsymmetric(state->algorithm.id());
   if (state->is_asymmetric) {
     state->status = webcrypto::GenerateKeyPair(state->algorithm,
                                                state->extractable,
                                                state->usage_mask,
                                                &state->public_key,
                                                &state->private_key);
 
     if (state->status.IsSuccess()) {
@@ skipping 21 matching lines @@
   state->origin_thread->PostTask(
       FROM_HERE, base::Bind(DoGenerateKeyReply, 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->usage_mask,
                                        &state->key);
   if (state->status.IsSuccess()) {
     DCHECK(state->key.handle());
     DCHECK(!state->key.algorithm().isNull());
     DCHECK_EQ(state->extractable, state->key.extractable());
@@ skipping 19 matching lines @@
     state->result.completeWithJson(
         reinterpret_cast<const char*>(
             webcrypto::Uint8VectorStart(&state->buffer)),
         state->buffer.size());
   }
 #endif
 }
 
 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) {
   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->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::VerifySignature(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) {
   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) {
   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);
 
@@ skipping 191 matching lines @@
       &key);
 }
 
 bool WebCryptoImpl::serializeKeyForClone(
     const blink::WebCryptoKey& key,
     blink::WebVector<unsigned char>& key_data) {
   return webcrypto::SerializeKeyForClone(key, &key_data);
 }
 
 }  // namespace content