Transfer WebCrypto databuffers across the Blink API using blink::WebVector.

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 <limits.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 160 matching lines @@
 
  protected:
   // Since there is no virtual destructor, must not delete directly as a
   // BaseState.
   ~BaseState() {}
 };
 
 struct EncryptState : public BaseState {
   EncryptState(const blink::WebCryptoAlgorithm& algorithm,
                const blink::WebCryptoKey& key,
-               const unsigned char* data,
-               unsigned int data_size,
+               blink::WebVector<unsigned char> data,
                const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         key(key),
-        data(data, data + data_size) {}
+        data(std::move(data)) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const blink::WebCryptoKey key;
-  const std::vector<uint8_t> data;
+  const blink::WebVector<unsigned char> data;
 
   std::vector<uint8_t> buffer;
 };
 
 typedef EncryptState DecryptState;
 typedef EncryptState DigestState;
 
 struct GenerateKeyState : public BaseState {
   GenerateKeyState(const blink::WebCryptoAlgorithm& algorithm,
                    bool extractable,
                    blink::WebCryptoKeyUsageMask usages,
                    const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         extractable(extractable),
         usages(usages) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usages;
 
   webcrypto::GenerateKeyResult generate_key_result;
 };
 
 struct ImportKeyState : public BaseState {
   ImportKeyState(blink::WebCryptoKeyFormat format,
-                 const unsigned char* key_data,
-                 unsigned int key_data_size,
+                 blink::WebVector<unsigned char> key_data,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
-        key_data(key_data, key_data + key_data_size),
+        key_data(std::move(key_data)),
         algorithm(algorithm),
         extractable(extractable),
         usages(usages) {}
 
   const blink::WebCryptoKeyFormat format;
-  const std::vector<uint8_t> key_data;
+  const blink::WebVector<unsigned char> key_data;
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usages;
 
   blink::WebCryptoKey key;
 };
 
 struct ExportKeyState : public BaseState {
   ExportKeyState(blink::WebCryptoKeyFormat format,
                  const blink::WebCryptoKey& key,
                  const blink::WebCryptoResult& result)
       : BaseState(result), format(format), key(key) {}
 
   const blink::WebCryptoKeyFormat format;
   const blink::WebCryptoKey key;
 
   std::vector<uint8_t> buffer;
 };
 
 typedef EncryptState SignState;
 
 struct VerifySignatureState : public BaseState {
   VerifySignatureState(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::WebVector<unsigned char> signature,
+                       blink::WebVector<unsigned char> data,
                        const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         key(key),
-        signature(signature, signature + signature_size),
-        data(data, data + data_size),
+        signature(std::move(signature)),
+        data(std::move(data)),
         verify_result(false) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const blink::WebCryptoKey key;
-  const std::vector<uint8_t> signature;
-  const std::vector<uint8_t> data;
+  blink::WebVector<unsigned char> signature;
+  blink::WebVector<unsigned char> data;
 
   bool verify_result;
 };
 
 struct WrapKeyState : public BaseState {
   WrapKeyState(blink::WebCryptoKeyFormat format,
                const blink::WebCryptoKey& key,
                const blink::WebCryptoKey& wrapping_key,
                const blink::WebCryptoAlgorithm& wrap_algorithm,
                const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
         key(key),
         wrapping_key(wrapping_key),
         wrap_algorithm(wrap_algorithm) {}
 
   const blink::WebCryptoKeyFormat format;
   const blink::WebCryptoKey key;
   const blink::WebCryptoKey wrapping_key;
   const blink::WebCryptoAlgorithm wrap_algorithm;
 
   std::vector<uint8_t> buffer;
 };
 
 struct UnwrapKeyState : public BaseState {
   UnwrapKeyState(blink::WebCryptoKeyFormat format,
-                 const unsigned char* wrapped_key,
-                 unsigned wrapped_key_size,
+                 blink::WebVector<unsigned char> wrapped_key,
                  const blink::WebCryptoKey& wrapping_key,
                  const blink::WebCryptoAlgorithm& unwrap_algorithm,
                  const blink::WebCryptoAlgorithm& unwrapped_key_algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
-        wrapped_key(wrapped_key, wrapped_key + wrapped_key_size),
+        wrapped_key(std::move(wrapped_key)),
         wrapping_key(wrapping_key),
         unwrap_algorithm(unwrap_algorithm),
         unwrapped_key_algorithm(unwrapped_key_algorithm),
         extractable(extractable),
         usages(usages) {}
 
   const blink::WebCryptoKeyFormat format;
-  const std::vector<uint8_t> wrapped_key;
+  blink::WebVector<unsigned char> wrapped_key;
   const blink::WebCryptoKey wrapping_key;
   const blink::WebCryptoAlgorithm unwrap_algorithm;
   const blink::WebCryptoAlgorithm unwrapped_key_algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usages;
 
   blink::WebCryptoKey unwrapped_key;
 };
 
 struct DeriveBitsState : public BaseState {
@@ skipping 260 matching lines @@
 }  // 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::WebVector<unsigned char> data,
                             blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   std::unique_ptr<EncryptState> state(
-      new EncryptState(algorithm, key, data, data_size, result));
+      new EncryptState(algorithm, key, std::move(data), result));
   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::WebVector<unsigned char> data,
                             blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   std::unique_ptr<DecryptState> state(
-      new DecryptState(algorithm, key, data, data_size, result));
+      new DecryptState(algorithm, key, std::move(data), result));
   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::WebVector<unsigned char> data,
                            blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   std::unique_ptr<DigestState> state(new DigestState(
-      algorithm, blink::WebCryptoKey::createNull(), data, data_size, result));
+      algorithm, blink::WebCryptoKey::createNull(), std::move(data), result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   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());
 
   std::unique_ptr<GenerateKeyState> state(
       new GenerateKeyState(algorithm, extractable, usages, result));
   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,
+                              blink::WebVector<unsigned char> key_data,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
                               blink::WebCryptoKeyUsageMask usages,
                               blink::WebCryptoResult result) {
   std::unique_ptr<ImportKeyState> state(new ImportKeyState(
-      format, key_data, key_data_size, algorithm, extractable, usages, result));
+      format, std::move(key_data), algorithm, extractable, usages, result));
   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) {
   std::unique_ptr<ExportKeyState> state(
       new ExportKeyState(format, key, result));
   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::WebVector<unsigned char> data,
                          blink::WebCryptoResult result) {
   std::unique_ptr<SignState> state(
-      new SignState(algorithm, key, data, data_size, result));
+      new SignState(algorithm, key, std::move(data), result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   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::WebVector<unsigned char> signature,
+                                    blink::WebVector<unsigned char> data,
                                     blink::WebCryptoResult result) {
   std::unique_ptr<VerifySignatureState> state(new VerifySignatureState(
-      algorithm, key, signature, signature_size, data, data_size, result));
+      algorithm, key, std::move(signature), std::move(data), result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   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) {
   std::unique_ptr<WrapKeyState> state(
       new WrapKeyState(format, key, wrapping_key, wrap_algorithm, result));
   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,
+    blink::WebVector<unsigned char> wrapped_key,
     const blink::WebCryptoKey& wrapping_key,
     const blink::WebCryptoAlgorithm& unwrap_algorithm,
     const blink::WebCryptoAlgorithm& unwrapped_key_algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoResult result) {
   std::unique_ptr<UnwrapKeyState> state(new UnwrapKeyState(
-      format, wrapped_key, wrapped_key_size, wrapping_key, unwrap_algorithm,
+      format, std::move(wrapped_key), wrapping_key, unwrap_algorithm,
       unwrapped_key_algorithm, extractable, usages, result));
   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,
@@ skipping 41 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