[webcrypto] Allow both ArrayBuffer and ArrayBufferView as inputs to crypto.subtle methods.

Source/wtf/ArrayBytes.h

Index: Source/wtf/ArrayBytes.h
diff --git a/Source/wtf/ArrayBytes.h b/Source/wtf/ArrayBytes.h
new file mode 100644
index 0000000000000000000000000000000000000000..8073dac6b6d1b8416984e631691adaa5ecdae251
--- /dev/null
+++ b/Source/wtf/ArrayBytes.h
@@ -0,0 +1,52 @@
+// 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.
+
+#ifndef ArrayBytes_h
+#define ArrayBytes_h
+
+#include "wtf/Forward.h"
+#include "wtf/WTFExport.h"
+
+namespace WTF {
+
+// This class is for passing around un-owned bytes as a pointer + length.
+// It supports implicit conversion from several other data types.
+//
+// ArrayBytes has the concept of being "null". This is different from an empty
+// byte range. It is invalid to call methods other than isNull() on such
+// instances.
+//
+// IMPORTANT: The data contained by ArrayBytes is NOT OWNED, so caution must be
+//            taken to ensure it is kept alive.
+class WTF_EXPORT ArrayBytes {

[abarth-chromium, 2014/05/07 06:19:10]

I guess we could call this an ArrayPiece after StringPiece...

[eroman, 2014/05/07 21:34:57]

Sounds good, will make the change.

+public:
+    // Constructs a "null" ArrayBytes object.
+    ArrayBytes();
+
+    ArrayBytes(void* data, unsigned byteLength);
+
+    // Constructs an ArrayBytes from the given ArrayBuffer. If the input is a
+    // nullptr, then the constructed instance will be isNull().
+    ArrayBytes(ArrayBuffer*);
+    ArrayBytes(ArrayBufferView*);
+
+    bool isNull() const;
+    void* data() const;
+    unsigned char* bytes() const;
+    unsigned byteLength() const;
+
+private:
+    void initWithData(void* data, unsigned byteLength);
+    void initNull();
+
+    void* m_data;
+    unsigned m_byteLength;
+    bool m_isNull;

[abarth-chromium, 2014/05/07 06:19:10]

We can't use m_data == 0 as the m_isNull bit?

[eroman, 2014/05/07 21:34:57]

I want to be able to distinguish between a zero-length ArrayPiece vs an
ArrayPiece that was not initialized.

This comes up because the WebIDL generated code may call our methods with a
nullptr in place of  ArrayBuffer* and ArrayBufferView* (rather than throwing a
TypeError). So throwing the TypeError is then left to each implementation
(http://crbug.com/264520). Solving 264520 is a bigger task I am not prepared to
tackle just now, so I decided to make the adapter distinguish between:

   ArrayPiece(nullptr)
 vs
   ArrayPiece(zeroLengthArrayBuffer);

Which I think is generally useful anyway.

Interestingly, once I added the overloads in the .idl file, the generated
bindings no longer pass NULL when given an invalid ArrayBuffer/ArrayBufferView.
Instead it now correctly throws a TypeError to the effect of "No function was
found that matched the signature provided." (See the rebaselined tests).

So long story short: I can change ArrayPiece(nullptr) to be the same as an empty
ArrayPiece if you like, and still solve my particular use case. But I think
separating them will avoid future bugs.

+};
+
+} // namespace WTF
+
+using WTF::ArrayBytes;
+
+#endif // ArrayBytes_h