bindings: Adds DOMArrayBuffer, etc. as thin wrappers for ArrayBuffer, etc.

Source/modules/crypto/NormalizeAlgorithm.cpp

 /*
  * 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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/crypto/NormalizeAlgorithm.h"
 
 #include "bindings/core/v8/Dictionary.h"
+#include "core/dom/DOMTypedArray.h"
 #include "platform/NotImplemented.h"
 #include "public/platform/WebCryptoAlgorithmParams.h"
 #include "public/platform/WebString.h"
-#include "wtf/ArrayBuffer.h"
-#include "wtf/ArrayBufferView.h"
 #include "wtf/MathExtras.h"
-#include "wtf/Uint8Array.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
 struct AlgorithmNameMapping {
     // Must be an upper case ASCII string.
@@ skipping 208 matching lines @@
     // This inline size is large enough to avoid having to grow the Vector in
     // the majority of cases (up to 1 nested algorithm identifier).
     Vector<const char*, 10> m_messages;
 };
 
 // Defined by the WebCrypto spec as:
 //
 //     typedef (ArrayBuffer or ArrayBufferView) CryptoOperationData;
 //
 // FIXME: Currently only supports ArrayBufferView.
-bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyName, bool& hasProperty, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, AlgorithmError* error)
+bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyName, bool& hasProperty, RefPtr<DOMArrayBufferView>& buffer, const ErrorContext& context, AlgorithmError* error)
 {
     if (!DictionaryHelper::get(raw, propertyName, buffer)) {
         hasProperty = false;
         return true;
     }
 
     hasProperty = true;
 
     if (!buffer) {
         setSyntaxError(context.toString(propertyName, "Not an ArrayBufferView"), error);
         return false;
     }
 
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     typedef (ArrayBuffer or ArrayBufferView) CryptoOperationData;
 //
 // FIXME: Currently only supports ArrayBufferView.
-bool getCryptoOperationData(const Dictionary& raw, const char* propertyName, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, AlgorithmError* error)
+bool getCryptoOperationData(const Dictionary& raw, const char* propertyName, RefPtr<DOMArrayBufferView>& buffer, const ErrorContext& context, AlgorithmError* error)
 {
     bool hasProperty;
     bool ok = getOptionalCryptoOperationData(raw, propertyName, hasProperty, buffer, context, error);
     if (!hasProperty) {
         setSyntaxError(context.toString(propertyName, "Missing required property"), error);
         return false;
     }
     return ok;
 }
 
-bool getUint8Array(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, AlgorithmError* error)
+bool getUint8Array(const Dictionary& raw, const char* propertyName, RefPtr<DOMUint8Array>& array, const ErrorContext& context, AlgorithmError* error)
 {
     if (!DictionaryHelper::get(raw, propertyName, array) || !array) {
         setSyntaxError(context.toString(propertyName, "Missing or not a Uint8Array"), error);
         return false;
     }
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     typedef Uint8Array BigInteger;
-bool getBigInteger(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, AlgorithmError* error)
+bool getBigInteger(const Dictionary& raw, const char* propertyName, RefPtr<DOMUint8Array>& array, const ErrorContext& context, AlgorithmError* error)
 {
     if (!getUint8Array(raw, propertyName, array, context, error))
         return false;
 
     if (!array->byteLength()) {
         setSyntaxError(context.toString(propertyName, "BigInteger should not be empty"), error);
         return false;
     }
 
     if (!DictionaryHelper::get(raw, propertyName, array) || !array) {
@@ skipping 79 matching lines @@
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCbcParams : Algorithm {
 //      CryptoOperationData iv;
 //    };
 bool parseAesCbcParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    RefPtr<ArrayBufferView> iv;
+    RefPtr<DOMArrayBufferView> iv;
     if (!getCryptoOperationData(raw, "iv", iv, context, error))
         return false;
 
     if (iv->byteLength() != 16) {
         setDataError(context.toString("iv", "Must be 16 bytes"), error);
         return false;
     }
 
     params = adoptPtr(new WebCryptoAesCbcParams(static_cast<unsigned char*>(iv->baseAddress()), iv->byteLength()));
     return true;
@@ skipping 91 matching lines @@
 //    dictionary RsaKeyGenParams : Algorithm {
 //      unsigned long modulusLength;
 //      BigInteger publicExponent;
 //    };
 bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     uint32_t modulusLength;
     if (!getUint32(raw, "modulusLength", modulusLength, context, error))
         return false;
 
-    RefPtr<Uint8Array> publicExponent;
+    RefPtr<DOMUint8Array> publicExponent;
     if (!getBigInteger(raw, "publicExponent", publicExponent, context, error))
         return false;
 
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
 
     params = adoptPtr(new WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCtrParams : Algorithm {
 //      CryptoOperationData counter;
 //      [EnforceRange] octet length;
 //    };
 bool parseAesCtrParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    RefPtr<ArrayBufferView> counter;
+    RefPtr<DOMArrayBufferView> counter;
     if (!getCryptoOperationData(raw, "counter", counter, context, error))
         return false;
 
     uint8_t length;
     if (!getUint8(raw, "length", length, context, error))
         return false;
 
     params = adoptPtr(new WebCryptoAesCtrParams(length, static_cast<const unsigned char*>(counter->baseAddress()), counter->byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary AesGcmParams : Algorithm {
 //       CryptoOperationData iv;
 //       CryptoOperationData? additionalData;
 //       [EnforceRange] octet? tagLength;  // May be 0-128
 //     }
 bool parseAesGcmParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
-    RefPtr<ArrayBufferView> iv;
+    RefPtr<DOMArrayBufferView> iv;
     if (!getCryptoOperationData(raw, "iv", iv, context, error))
         return false;
 
     bool hasAdditionalData;
-    RefPtr<ArrayBufferView> additionalData;
+    RefPtr<DOMArrayBufferView> additionalData;
     if (!getOptionalCryptoOperationData(raw, "additionalData", hasAdditionalData, additionalData, context, error))
         return false;
 
     double tagLength;
     bool hasTagLength;
     if (!getOptionalInteger(raw, "tagLength", hasTagLength, tagLength, 0, 128, context, error))
         return false;
 
     const unsigned char* ivStart = static_cast<const unsigned char*>(iv->baseAddress());
     unsigned ivLength = iv->byteLength();
 
     const unsigned char* additionalDataStart = hasAdditionalData ? static_cast<const unsigned char*>(additionalData->baseAddress()) : 0;
     unsigned additionalDataLength = hasAdditionalData ? additionalData->byteLength() : 0;
 
     params = adoptPtr(new WebCryptoAesGcmParams(ivStart, ivLength, hasAdditionalData, additionalDataStart, additionalDataLength, hasTagLength, tagLength));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary RsaOaepParams : Algorithm {
 //       CryptoOperationData? label;
 //     };
 bool parseRsaOaepParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     bool hasLabel;
-    RefPtr<ArrayBufferView> label;
+    RefPtr<DOMArrayBufferView> label;
     if (!getOptionalCryptoOperationData(raw, "label", hasLabel, label, context, error))
         return false;
 
     const unsigned char* labelStart = hasLabel ? static_cast<const unsigned char*>(label->baseAddress()) : 0;
     unsigned labelLength = hasLabel ? label->byteLength() : 0;
 
     params = adoptPtr(new WebCryptoRsaOaepParams(hasLabel, labelStart, labelLength));
     return true;
 }
 
@@ skipping 109 matching lines @@
 }
 
 } // namespace
 
 bool normalizeAlgorithm(const Dictionary& raw, WebCryptoOperation op, WebCryptoAlgorithm& algorithm, AlgorithmError* error)
 {
     return parseAlgorithm(raw, op, algorithm, ErrorContext(), error);
 }
 
 } // namespace blink