Remove IndexedDB experimental features flag.

third_party/WebKit/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 86 matching lines @@
   switch (key->getType()) {
     case IDBKey::InvalidType:
     case IDBKey::TypeEnumMax:
       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:
-      // Experimental feature: binary keys
-      // https://w3c.github.io/IndexedDB/#steps-to-convert-a-key-to-a-value
+      // https://w3c.github.io/IndexedDB/#convert-a-value-to-a-key
       return ToV8(DOMArrayBuffer::create(reinterpret_cast<const unsigned char*>(
                                              key->binary()->data()),
                                          key->binary()->size()),
                   creationContext, isolate);
     case IDBKey::DateType:
       return v8::Date::New(context, 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 =
@@ skipping 51 matching lines @@
 
   ASSERT_NOT_REACHED();
   return v8::Undefined(isolate);
 }
 
 static const size_t maximumDepth = 2000;
 
 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate,
                                      v8::Local<v8::Value> value,
                                      Vector<v8::Local<v8::Array>>& stack,
-                                     ExceptionState& exceptionState,
-                                     bool allowExperimentalTypes = false) {
+                                     ExceptionState& exceptionState) {
   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 (allowExperimentalTypes ||
-      RuntimeEnabledFeatures::indexedDBExperimentalEnabled()) {
-    // Experimental feature: binary keys
-    // https://w3c.github.io/IndexedDB/#dfn-convert-a-value-to-a-key
-    if (value->IsArrayBuffer()) {
-      DOMArrayBuffer* buffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
-      if (buffer->isNeutered()) {
-        exceptionState.throwTypeError("The ArrayBuffer is neutered.");
-        return nullptr;
-      }
-      const char* start = static_cast<const char*>(buffer->data());
-      size_t length = buffer->byteLength();
-      return IDBKey::createBinary(SharedBuffer::create(start, length));
+
+  // https://w3c.github.io/IndexedDB/#convert-a-key-to-a-value
+  if (value->IsArrayBuffer()) {
+    DOMArrayBuffer* buffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
+    if (buffer->isNeutered()) {
+      exceptionState.throwTypeError("The ArrayBuffer is neutered.");
+      return nullptr;
     }
-    if (value->IsArrayBufferView()) {
-      DOMArrayBufferView* view =
-          V8ArrayBufferView::toImpl(value.As<v8::Object>());
-      if (view->buffer()->isNeutered()) {
-        exceptionState.throwTypeError("The viewed ArrayBuffer is neutered.");
-        return nullptr;
-      }
-      const char* start = static_cast<const char*>(view->baseAddress());
-      size_t length = view->byteLength();
-      return IDBKey::createBinary(SharedBuffer::create(start, length));
+    const char* start = static_cast<const char*>(buffer->data());
+    size_t length = buffer->byteLength();
+    return IDBKey::createBinary(SharedBuffer::create(start, length));
+  }
+  if (value->IsArrayBufferView()) {
+    DOMArrayBufferView* view =
+        V8ArrayBufferView::toImpl(value.As<v8::Object>());
+    if (view->buffer()->isNeutered()) {
+      exceptionState.throwTypeError("The viewed ArrayBuffer is neutered.");
+      return nullptr;
     }
+    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.push_back(array);
 
     IDBKey::KeyArray subkeys;
     uint32_t length = array->Length();
     v8::TryCatch block(isolate);
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
     for (uint32_t i = 0; i < length; ++i) {
       if (!v8CallBoolean(array->HasOwnProperty(context, i)))
         return nullptr;
       v8::Local<v8::Value> item;
       if (!v8Call(array->Get(context, i), item, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return nullptr;
       }
-      IDBKey* subkey = createIDBKeyFromValue(
-          isolate, item, stack, exceptionState, allowExperimentalTypes);
+      IDBKey* subkey =
+          createIDBKeyFromValue(isolate, item, stack, exceptionState);
       if (!subkey)
         subkeys.push_back(IDBKey::createInvalid());
       else
         subkeys.push_back(subkey);
     }
 
     stack.pop_back();
     return IDBKey::createArray(subkeys);
   }
   return nullptr;
 }
 
 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate,
                                      v8::Local<v8::Value> value,
-                                     ExceptionState& exceptionState,
-                                     bool allowExperimentalTypes = false) {
+                                     ExceptionState& exceptionState) {
   Vector<v8::Local<v8::Array>> stack;
-  if (IDBKey* key = createIDBKeyFromValue(isolate, value, stack, exceptionState,
-                                          allowExperimentalTypes))
+  if (IDBKey* key =
+          createIDBKeyFromValue(isolate, value, stack, exceptionState))
     return key;
   return IDBKey::createInvalid();
 }
 
 // Indexed DB key paths should apply to explicitly copied properties (that
 // will be "own" properties when deserialized) as well as the following.
 // http://www.w3.org/TR/IndexedDB/#key-path-construct
 static bool isImplicitProperty(v8::Isolate* isolate,
                                v8::Local<v8::Value> value,
                                const String& name) {
@@ skipping 14 matching lines @@
   Vector<String> elements;
   IDBKeyPathParseError error;
   IDBParseKeyPath(keyPath, elements, error);
   ASSERT(error == IDBKeyPathParseErrorNone);
   return elements;
 }
 
 static IDBKey* createIDBKeyFromValueAndKeyPath(v8::Isolate* isolate,
                                                v8::Local<v8::Value> v8Value,
                                                const String& keyPath,
-                                               ExceptionState& exceptionState,
-                                               bool allowExperimentalTypes) {
+                                               ExceptionState& exceptionState) {
   Vector<String> keyPathElements = parseKeyPath(keyPath);
   ASSERT(isolate->InContext());
 
   v8::HandleScope handleScope(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::TryCatch block(isolate);
   for (size_t i = 0; i < keyPathElements.size(); ++i) {
     const String& element = keyPathElements[i];
 
     // Special cases from https://w3c.github.io/IndexedDB/#key-path-construct
@@ skipping 47 matching lines @@
     }
 
     v8::Local<v8::String> key = v8String(isolate, element);
     if (!v8CallBoolean(object->HasOwnProperty(context, key)))
       return nullptr;
     if (!v8Call(object->Get(context, key), v8Value, block)) {
       exceptionState.rethrowV8Exception(block.Exception());
       return nullptr;
     }
   }
-  return createIDBKeyFromValue(isolate, v8Value, exceptionState,
-                               allowExperimentalTypes);
+  return createIDBKeyFromValue(isolate, v8Value, exceptionState);
 }
 
-static IDBKey* createIDBKeyFromValueAndKeyPath(
-    v8::Isolate* isolate,
-    v8::Local<v8::Value> value,
-    const IDBKeyPath& keyPath,
-    ExceptionState& exceptionState,
-    bool allowExperimentalTypes = false) {
+static IDBKey* createIDBKeyFromValueAndKeyPath(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               const IDBKeyPath& keyPath,
+                                               ExceptionState& exceptionState) {
   ASSERT(!keyPath.isNull());
   v8::HandleScope handleScope(isolate);
   if (keyPath.getType() == IDBKeyPath::ArrayType) {
     IDBKey::KeyArray result;
     const Vector<String>& array = keyPath.array();
     for (size_t i = 0; i < array.size(); ++i) {
-      IDBKey* key = createIDBKeyFromValueAndKeyPath(
-          isolate, value, array[i], exceptionState, allowExperimentalTypes);
+      IDBKey* key = createIDBKeyFromValueAndKeyPath(isolate, value, array[i],
+                                                    exceptionState);
       if (!key)
         return nullptr;
       result.push_back(key);
     }
     return IDBKey::createArray(result);
   }
 
   ASSERT(keyPath.getType() == IDBKeyPath::StringType);
-  return createIDBKeyFromValueAndKeyPath(
-      isolate, value, keyPath.string(), exceptionState, allowExperimentalTypes);
+  return createIDBKeyFromValueAndKeyPath(isolate, value, keyPath.string(),
+                                         exceptionState);
 }
 
 // Deserialize just the value data & blobInfo from the given IDBValue.
 // Does not deserialize the key & keypath.
 static v8::Local<v8::Value> deserializeIDBValueData(v8::Isolate* isolate,
                                                     const IDBValue* value) {
   ASSERT(isolate->InContext());
   if (!value || value->isNull())
     return v8::Null(isolate);
 
@@ skipping 201 matching lines @@
 // with implicit keys (i.e. a key path). It verifies that either the value
 // contains an implicit key matching the primary key (so it was correctly
 // extracted when stored) or that the key can be inserted as an own property.
 void assertPrimaryKeyValidOrInjectable(ScriptState* scriptState,
                                        const IDBValue* value) {
   ScriptState::Scope scope(scriptState);
   v8::Isolate* isolate = scriptState->isolate();
   ScriptValue keyValue = ScriptValue::from(scriptState, value->primaryKey());
   ScriptValue scriptValue(scriptState, deserializeIDBValueData(isolate, value));
 
-  // This assertion is about already persisted data, so allow experimental
-  // types.
-  const bool allowExperimentalTypes = true;
   DummyExceptionStateForTesting exceptionState;
   IDBKey* expectedKey = createIDBKeyFromValueAndKeyPath(
-      isolate, scriptValue.v8Value(), value->keyPath(), exceptionState,
-      allowExperimentalTypes);
+      isolate, scriptValue.v8Value(), value->keyPath(), exceptionState);
   ASSERT(!exceptionState.hadException());
   if (expectedKey && expectedKey->isEqual(value->primaryKey()))
     return;
 
   bool injected = injectV8KeyIntoV8Value(
       isolate, keyValue.v8Value(), scriptValue.v8Value(), value->keyPath());
   DCHECK(injected);
 }
 #endif
 
 }  // namespace blink