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

third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
 
 class WebCryptoAlgorithmParams {
 public:
     WebCryptoAlgorithmParams() { }
     virtual ~WebCryptoAlgorithmParams() { }
     virtual WebCryptoAlgorithmParamsType type() const = 0;
 };
 
 class WebCryptoAesCbcParams : public WebCryptoAlgorithmParams {
 public:
-    WebCryptoAesCbcParams(const unsigned char* iv, unsigned ivSize)
-        : m_iv(iv, ivSize)
+    explicit WebCryptoAesCbcParams(WebVector<unsigned char> iv)
+        : m_iv(std::move(iv))
     {
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeAesCbcParams; }
 
     const WebVector<unsigned char>& iv() const { return m_iv; }
 
 private:
     const WebVector<unsigned char> m_iv;
 };
 
 class WebCryptoAlgorithmParamsWithHash : public WebCryptoAlgorithmParams {
 public:
     explicit WebCryptoAlgorithmParamsWithHash(const WebCryptoAlgorithm& hash)
         : m_hash(hash)
     {
         DCHECK(!hash.isNull());
     }
 
     const WebCryptoAlgorithm& hash() const { return m_hash; }
 
 private:
     const WebCryptoAlgorithm m_hash;
 };
 
 class WebCryptoAesCtrParams : public WebCryptoAlgorithmParams {
 public:
-    WebCryptoAesCtrParams(unsigned char lengthBits, const unsigned char* counter, unsigned counterSize)
+    WebCryptoAesCtrParams(unsigned char lengthBits, WebVector<unsigned char> counter)
         : WebCryptoAlgorithmParams()
-        , m_counter(counter, counterSize)
+        , m_counter(std::move(counter))
         , m_lengthBits(lengthBits)
     {
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeAesCtrParams; }
 
     const WebVector<unsigned char>& counter() const { return m_counter; }
     unsigned char lengthBits() const { return m_lengthBits; }
 
 private:
@@ skipping 61 matching lines @@
 
     unsigned optionalLengthBits() const { return m_optionalLengthBits; }
 
 private:
     const bool m_hasLengthBits;
     const unsigned m_optionalLengthBits;
 };
 
 class WebCryptoAesGcmParams : public WebCryptoAlgorithmParams {
 public:
-    WebCryptoAesGcmParams(const unsigned char* iv, unsigned ivSize, bool hasAdditionalData, const unsigned char* additionalData, unsigned additionalDataSize, bool hasTagLengthBits, unsigned char tagLengthBits)
-        : m_iv(iv, ivSize)
+    WebCryptoAesGcmParams(WebVector<unsigned char> iv, bool hasAdditionalData, WebVector<unsigned char> additionalData, bool hasTagLengthBits, unsigned char tagLengthBits)
+        : m_iv(std::move(iv))
         , m_hasAdditionalData(hasAdditionalData)
-        , m_optionalAdditionalData(additionalData, additionalDataSize)
+        , m_optionalAdditionalData(std::move(additionalData))
         , m_hasTagLengthBits(hasTagLengthBits)
         , m_optionalTagLengthBits(tagLengthBits)
     {
-        DCHECK(hasAdditionalData || !additionalDataSize);
+        DCHECK(hasAdditionalData || m_optionalAdditionalData.isEmpty());
         DCHECK(hasTagLengthBits || !tagLengthBits);
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeAesGcmParams; }
 
     const WebVector<unsigned char>& iv() const { return m_iv; }
 
     bool hasAdditionalData() const { return m_hasAdditionalData; }
     const WebVector<unsigned char>& optionalAdditionalData() const { return m_optionalAdditionalData; }
 
@@ skipping 13 matching lines @@
     explicit WebCryptoRsaHashedImportParams(const WebCryptoAlgorithm& hash)
         : WebCryptoAlgorithmParamsWithHash(hash)
     {
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaHashedImportParams; }
 };
 
 class WebCryptoRsaHashedKeyGenParams : public WebCryptoAlgorithmParams {
 public:
-    explicit WebCryptoRsaHashedKeyGenParams(const WebCryptoAlgorithm& hash, unsigned modulusLengthBits, const unsigned char* publicExponent, unsigned publicExponentSize)
+    WebCryptoRsaHashedKeyGenParams(const WebCryptoAlgorithm& hash, unsigned modulusLengthBits, WebVector<unsigned char> publicExponent)
         : m_modulusLengthBits(modulusLengthBits)
-        , m_publicExponent(publicExponent, publicExponentSize)
+        , m_publicExponent(std::move(publicExponent))
         , m_hash(hash)
     {
         DCHECK(!hash.isNull());
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams; }
 
     unsigned modulusLengthBits() const { return m_modulusLengthBits; }
     const WebVector<unsigned char>& publicExponent() const { return m_publicExponent; }
     const WebCryptoAlgorithm& hash() const { return m_hash; }
@@ skipping 15 matching lines @@
     }
 
 private:
     const unsigned m_modulusLengthBits;
     const WebVector<unsigned char> m_publicExponent;
     const WebCryptoAlgorithm m_hash;
 };
 
 class WebCryptoRsaOaepParams : public WebCryptoAlgorithmParams {
 public:
-    WebCryptoRsaOaepParams(bool hasLabel, const unsigned char* label, unsigned labelSize)
+    WebCryptoRsaOaepParams(bool hasLabel, WebVector<unsigned char> label)
         : m_hasLabel(hasLabel)
-        , m_optionalLabel(label, labelSize)
+        , m_optionalLabel(std::move(label))
     {
-        DCHECK(hasLabel || !labelSize);
+        DCHECK(hasLabel || m_optionalLabel.isEmpty());
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaOaepParams; }
 
     bool hasLabel() const { return m_hasLabel; }
     const WebVector<unsigned char>& optionalLabel() const { return m_optionalLabel; }
 
 private:
     const bool m_hasLabel;
     const WebVector<unsigned char> m_optionalLabel;
@@ skipping 79 matching lines @@
     virtual WebCryptoAlgorithmParamsType type() const override { return WebCryptoAlgorithmParamsTypeAesDerivedKeyParams; }
 
     unsigned short lengthBits() const { return m_lengthBits; }
 
 private:
     const unsigned short m_lengthBits;
 };
 
 class WebCryptoHkdfParams : public WebCryptoAlgorithmParamsWithHash {
 public:
-    WebCryptoHkdfParams(const WebCryptoAlgorithm& hash, const unsigned char* salt, unsigned saltSize, const unsigned char* info, unsigned infoSize)
+    WebCryptoHkdfParams(const WebCryptoAlgorithm& hash, WebVector<unsigned char> salt, WebVector<unsigned char> info)
         : WebCryptoAlgorithmParamsWithHash(hash)
-        , m_salt(salt, saltSize)
-        , m_info(info, infoSize)
+        , m_salt(std::move(salt))
+        , m_info(std::move(info))
     {
     }
 
     const WebVector<unsigned char>& salt() const { return m_salt; }
 
     const WebVector<unsigned char>& info() const { return m_info; }
 
     virtual WebCryptoAlgorithmParamsType type() const
     {
         return WebCryptoAlgorithmParamsTypeHkdfParams;
     }
 
 private:
     const WebVector<unsigned char> m_salt;
     const WebVector<unsigned char> m_info;
 };
 
 class WebCryptoPbkdf2Params : public WebCryptoAlgorithmParamsWithHash {
 public:
-    WebCryptoPbkdf2Params(const WebCryptoAlgorithm& hash, const unsigned char* salt, unsigned saltLength, unsigned iterations)
+    WebCryptoPbkdf2Params(const WebCryptoAlgorithm& hash, WebVector<unsigned char> salt, unsigned iterations)
         : WebCryptoAlgorithmParamsWithHash(hash)
-        , m_salt(salt, saltLength)
+        , m_salt(std::move(salt))
         , m_iterations(iterations)
     {
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypePbkdf2Params; }
 
     const WebVector<unsigned char>& salt() const { return m_salt; }
     unsigned iterations() const { return m_iterations; }
 
 private:
     const WebVector<unsigned char> m_salt;
     const unsigned m_iterations;
 };
 
 } // namespace blink
 
 #endif