Indexed DB: Adopt BufferSource model for binary keys

Source/bindings/modules/v8/V8BindingForModules.cpp

 /*
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * 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 "bindings/modules/v8/V8BindingForModules.h"
 
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/SerializedScriptValueFactory.h"
+#include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMStringList.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8Uint8Array.h"
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8IDBCursor.h"
 #include "bindings/modules/v8/V8IDBCursorWithValue.h"
 #include "bindings/modules/v8/V8IDBDatabase.h"
 #include "bindings/modules/v8/V8IDBIndex.h"
 #include "bindings/modules/v8/V8IDBKeyRange.h"
 #include "bindings/modules/v8/V8IDBObjectStore.h"
+#include "core/dom/DOMArrayBuffer.h"
+#include "core/dom/DOMArrayBufferView.h"
 #include "modules/indexeddb/IDBKey.h"
 #include "modules/indexeddb/IDBKeyPath.h"
 #include "modules/indexeddb/IDBKeyRange.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Vector.h"
 
@@ skipping 31 matching lines @@
     switch (key->type()) {
     case IDBKey::InvalidType:
     case IDBKey::MinType:
         ASSERT_NOT_REACHED();
         return v8Undefined();
     case IDBKey::NumberType:
         return v8::Number::New(isolate, key->number());
     case IDBKey::StringType:
         return v8String(isolate, key->string());
     case IDBKey::BinaryType:
-        return toV8(DOMUint8Array::create(reinterpret_cast<const unsigned char*>(key->binary()->data()), key->binary()->size()), creationContext, isolate);
+        return toV8(DOMArrayBuffer::create(reinterpret_cast<const unsigned char*>(key->binary()->data()), key->binary()->size()), creationContext, isolate);
     case IDBKey::DateType:
         return v8::Date::New(isolate->GetCurrentContext(), key->date()).ToLocalChecked();
     case IDBKey::ArrayType:
         {
             v8::Local<v8::Array> array = v8::Array::New(isolate, key->array().size());
             for (size_t i = 0; i < key->array().size(); ++i) {
                 v8::Local<v8::Value> value = toV8(key->array()[i].get(), creationContext, isolate);
                 if (value.IsEmpty())
                     value = v8::Undefined(isolate);
                 array->Set(i, value);
@@ skipping 77 matching lines @@
 static const size_t maximumDepth = 2000;
 
 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate, v8::Local<v8::Value> value, Vector<v8::Local<v8::Array>>& stack, bool allowExperimentalTypes = false)
 {
     if (value->IsNumber() && !std::isnan(value.As<v8::Number>()->Value()))
         return IDBKey::createNumber(value.As<v8::Number>()->Value());
     if (value->IsString())
         return IDBKey::createString(toCoreString(value.As<v8::String>()));
     if (value->IsDate() && !std::isnan(value.As<v8::Date>()->ValueOf()))
         return IDBKey::createDate(value.As<v8::Date>()->ValueOf());
-    if (value->IsUint8Array() && (allowExperimentalTypes || RuntimeEnabledFeatures::indexedDBExperimentalEnabled())) {
-        // Per discussion in https://www.w3.org/Bugs/Public/show_bug.cgi?id=23332 the
-        // input type is constrained to Uint8Array to match the output type.
-        DOMArrayBufferView* view = blink::V8ArrayBufferView::toImpl(value.As<v8::Object>());
-        const char* start = static_cast<const char*>(view->baseAddress());
-        size_t length = view->byteLength();
-        return IDBKey::createBinary(SharedBuffer::create(start, length));
+    if (allowExperimentalTypes || RuntimeEnabledFeatures::indexedDBExperimentalEnabled()) {
+        // Experimental feature: binary keys
+        // https://www.w3.org/Bugs/Public/show_bug.cgi?id=23332
+        if (value->IsArrayBuffer()) {
+            DOMArrayBuffer* buffer = blink::V8ArrayBuffer::toImpl(value.As<v8::Object>());
+            const char* start = static_cast<const char*>(buffer->data());
+            size_t length = buffer->byteLength();
+            return IDBKey::createBinary(SharedBuffer::create(start, length));

[cmumford, 2015/04/27 17:14:23]

How much do we care about overflow? length is going from unsigned -> signed w/o
a check.

[jsbell, 2015/04/27 22:39:47]

Covered by the FIXME at:

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

(Lame answer, but that's the right place to fix it)

+        }
+        if (value->IsArrayBufferView()) {
+            DOMArrayBufferView* view = blink::V8ArrayBufferView::toImpl(value.As<v8::Object>());
+            const char* start = static_cast<const char*>(view->baseAddress());
+            size_t length = view->byteLength();
+            return IDBKey::createBinary(SharedBuffer::create(start, length));
+        }
     }
     if (value->IsArray()) {
         v8::Local<v8::Array> array = value.As<v8::Array>();
 
         if (stack.contains(array))
             return nullptr;
         if (stack.size() >= maximumDepth)
             return nullptr;
         stack.append(array);
 
@@ skipping 238 matching lines @@
     const bool allowExperimentalTypes = true;
     IDBKey* expectedKey = createIDBKeyFromValueAndKeyPath(isolate, scriptValue.v8Value(), value->keyPath(), allowExperimentalTypes);
     ASSERT(!expectedKey || expectedKey->isEqual(value->primaryKey()));
 
     bool injected = injectV8KeyIntoV8Value(isolate, keyValue.v8Value(), scriptValue.v8Value(), value->keyPath());
     ASSERT_UNUSED(injected, injected);
 }
 #endif
 
 } // namespace blink