[Bindings] Cache handles for dictionary keys on V8PerIsolateData.

third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp

 // 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.
 
 // This file has been auto-generated by code_generator_v8.py.
 // DO NOT MODIFY!
 
 // This file has been generated from the Jinja2 template in
 // third_party/WebKit/Source/bindings/templates/dictionary_v8.cpp.tmpl
 
@@ skipping 13 matching lines @@
 #include "bindings/core/v8/V8TestInterface2.h"
 #include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
 #include "bindings/core/v8/V8TestObject.h"
 #include "bindings/core/v8/V8Uint8Array.h"
 #include "core/dom/FlexibleArrayBufferView.h"
 #include "core/frame/Deprecation.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
+static const v8::Eternal<v8::Name>* eternalV8TestDictionaryKeys(v8::Isolate* isolate) {
+  static const char* const kKeys[] = {
+    "anyMember",
+    "booleanMember",
+    "create",
+    "deprecatedCreateMember",
+    "dictionaryMember",
+    "doubleOrNullMember",
+    "doubleOrStringMember",
+    "doubleOrStringSequenceMember",
+    "elementOrNullMember",
+    "enumMember",
+    "enumSequenceMember",
+    "eventTargetMember",
+    "garbageCollectedRecordMember",
+    "internalDictionarySequenceMember",
+    "longMember",
+    "objectMember",
+    "objectOrNullMember",
+    "otherDoubleOrStringMember",
+    "prefixGetMember",
+    "recordMember",
+    "restrictedDoubleMember",
+    "runtimeMember",
+    "stringArrayMember",
+    "stringMember",
+    "stringOrNullMember",
+    "stringSequenceMember",
+    "testInterface2OrUint8ArrayMember",
+    "testInterfaceGarbageCollectedMember",
+    "testInterfaceGarbageCollectedOrNullMember",
+    "testInterfaceGarbageCollectedSequenceMember",
+    "testInterfaceMember",
+    "testInterfaceOrNullMember",
+    "testInterfaceSequenceMember",
+    "testObjectSequenceMember",
+    "uint8ArrayMember",
+    "unionInRecordMember",
+    "unionWithTypedefs",
+    "unrestrictedDoubleMember",
+  };
+  return V8PerIsolateData::from(isolate)->findOrCreateEternalNameCache(
+      kKeys, kKeys, WTF_ARRAY_LENGTH(kKeys));
+}
+
 void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState) {
   if (isUndefinedOrNull(v8Value)) {
     return;
   }
   if (!v8Value->IsObject()) {
     exceptionState.throwTypeError("cannot convert to dictionary.");
     return;
   }
   v8::Local<v8::Object> v8Object = v8Value.As<v8::Object>();
   ALLOW_UNUSED_LOCAL(v8Object);
 
+  const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryKeys(isolate);
   v8::TryCatch block(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Value> anyMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "anyMember")).ToLocal(&anyMemberValue)) {
+  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&anyMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (anyMemberValue.IsEmpty() || anyMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     ScriptValue anyMember = ScriptValue(ScriptState::current(isolate), anyMemberValue);
     impl.setAnyMember(anyMember);
   }
 
   v8::Local<v8::Value> booleanMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "booleanMember")).ToLocal(&booleanMemberValue)) {
+  if (!v8Object->Get(context, keys[1].Get(isolate)).ToLocal(&booleanMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     bool booleanMember = NativeValueTraits<IDLBoolean>::nativeValue(isolate, booleanMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setBooleanMember(booleanMember);
   }
 
   v8::Local<v8::Value> createValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "create")).ToLocal(&createValue)) {
+  if (!v8Object->Get(context, keys[2].Get(isolate)).ToLocal(&createValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (createValue.IsEmpty() || createValue->IsUndefined()) {
     // Do nothing.
   } else {
     bool create = NativeValueTraits<IDLBoolean>::nativeValue(isolate, createValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setCreateMember(create);
   }
 
   v8::Local<v8::Value> deprecatedCreateMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "deprecatedCreateMember")).ToLocal(&deprecatedCreateMemberValue)) {
+  if (!v8Object->Get(context, keys[3].Get(isolate)).ToLocal(&deprecatedCreateMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Deprecation::countDeprecation(currentExecutionContext(isolate), UseCounter::CreateMember);
     bool deprecatedCreateMember = NativeValueTraits<IDLBoolean>::nativeValue(isolate, deprecatedCreateMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setCreateMember(deprecatedCreateMember);
   }
 
   v8::Local<v8::Value> dictionaryMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "dictionaryMember")).ToLocal(&dictionaryMemberValue)) {
+  if (!v8Object->Get(context, keys[4].Get(isolate)).ToLocal(&dictionaryMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (dictionaryMemberValue.IsEmpty() || dictionaryMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Dictionary dictionaryMember = NativeValueTraits<Dictionary>::nativeValue(isolate, dictionaryMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     if (!dictionaryMember.isObject()) {
       exceptionState.throwTypeError("member dictionaryMember is not an object.");
       return;
     }
     impl.setDictionaryMember(dictionaryMember);
   }
 
   v8::Local<v8::Value> doubleOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrNullMember")).ToLocal(&doubleOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[5].Get(isolate)).ToLocal(&doubleOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (doubleOrNullMemberValue->IsNull()) {
     impl.setDoubleOrNullMemberToNull();
   } else {
     double doubleOrNullMember = NativeValueTraits<IDLDouble>::nativeValue(isolate, doubleOrNullMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setDoubleOrNullMember(doubleOrNullMember);
   }
 
   v8::Local<v8::Value> doubleOrStringMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringMember")).ToLocal(&doubleOrStringMemberValue)) {
+  if (!v8Object->Get(context, keys[6].Get(isolate)).ToLocal(&doubleOrStringMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     DoubleOrString doubleOrStringMember;
     V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setDoubleOrStringMember(doubleOrStringMember);
   }
 
   v8::Local<v8::Value> doubleOrStringSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringSequenceMember")).ToLocal(&doubleOrStringSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[7].Get(isolate)).ToLocal(&doubleOrStringSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (doubleOrStringSequenceMemberValue.IsEmpty() || doubleOrStringSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<DoubleOrString> doubleOrStringSequenceMember = toImplArray<HeapVector<DoubleOrString>>(doubleOrStringSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setDoubleOrStringSequenceMember(doubleOrStringSequenceMember);
   }
 
   v8::Local<v8::Value> elementOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "elementOrNullMember")).ToLocal(&elementOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[8].Get(isolate)).ToLocal(&elementOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (elementOrNullMemberValue->IsNull()) {
     impl.setElementOrNullMemberToNull();
   } else {
     Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
     if (!elementOrNullMember) {
       exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
       return;
     }
     impl.setElementOrNullMember(elementOrNullMember);
   }
 
   v8::Local<v8::Value> enumMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumMember")).ToLocal(&enumMemberValue)) {
+  if (!v8Object->Get(context, keys[9].Get(isolate)).ToLocal(&enumMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     V8StringResource<> enumMember = enumMemberValue;
     if (!enumMember.prepare(exceptionState))
       return;
     const char* validValues[] = {
         "",
         "EnumValue1",
         "EnumValue2",
         "EnumValue3",
     };
     if (!isValidEnum(enumMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
       return;
     impl.setEnumMember(enumMember);
   }
 
   v8::Local<v8::Value> enumSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumSequenceMember")).ToLocal(&enumSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[10].Get(isolate)).ToLocal(&enumSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (enumSequenceMemberValue.IsEmpty() || enumSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Vector<String> enumSequenceMember = toImplArray<Vector<String>>(enumSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     const char* validValues[] = {
         "",
         "EnumValue1",
         "EnumValue2",
         "EnumValue3",
     };
     if (!isValidEnum(enumSequenceMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
       return;
     impl.setEnumSequenceMember(enumSequenceMember);
   }
 
   v8::Local<v8::Value> eventTargetMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "eventTargetMember")).ToLocal(&eventTargetMemberValue)) {
+  if (!v8Object->Get(context, keys[11].Get(isolate)).ToLocal(&eventTargetMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     EventTarget* eventTargetMember = V8EventTarget::toImplWithTypeCheck(isolate, eventTargetMemberValue);
     if (!eventTargetMember) {
       exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
       return;
     }
     impl.setEventTargetMember(eventTargetMember);
   }
 
   v8::Local<v8::Value> garbageCollectedRecordMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "garbageCollectedRecordMember")).ToLocal(&garbageCollectedRecordMemberValue)) {
+  if (!v8Object->Get(context, keys[12].Get(isolate)).ToLocal(&garbageCollectedRecordMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (garbageCollectedRecordMemberValue.IsEmpty() || garbageCollectedRecordMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<std::pair<String, Member<TestObject>>> garbageCollectedRecordMember = NativeValueTraits<IDLRecord<IDLUSVString, TestObject>>::nativeValue(isolate, garbageCollectedRecordMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setGarbageCollectedRecordMember(garbageCollectedRecordMember);
   }
 
   v8::Local<v8::Value> internalDictionarySequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "internalDictionarySequenceMember")).ToLocal(&internalDictionarySequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[13].Get(isolate)).ToLocal(&internalDictionarySequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<InternalDictionary> internalDictionarySequenceMember = toImplArray<HeapVector<InternalDictionary>>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
   }
 
   v8::Local<v8::Value> longMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "longMember")).ToLocal(&longMemberValue)) {
+  if (!v8Object->Get(context, keys[14].Get(isolate)).ToLocal(&longMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     int32_t longMember = NativeValueTraits<IDLLong>::nativeValue(isolate, longMemberValue, exceptionState, NormalConversion);
     if (exceptionState.hadException())
       return;
     impl.setLongMember(longMember);
   }
 
   v8::Local<v8::Value> objectMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectMember")).ToLocal(&objectMemberValue)) {
+  if (!v8Object->Get(context, keys[15].Get(isolate)).ToLocal(&objectMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
     if (!objectMember.isObject()) {
       exceptionState.throwTypeError("member objectMember is not an object.");
       return;
     }
     impl.setObjectMember(objectMember);
   }
 
   v8::Local<v8::Value> objectOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectOrNullMember")).ToLocal(&objectOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[16].Get(isolate)).ToLocal(&objectOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (objectOrNullMemberValue->IsNull()) {
     impl.setObjectOrNullMemberToNull();
   } else {
     ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
     if (!objectOrNullMember.isObject()) {
       exceptionState.throwTypeError("member objectOrNullMember is not an object.");
       return;
     }
     impl.setObjectOrNullMember(objectOrNullMember);
   }
 
   v8::Local<v8::Value> otherDoubleOrStringMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "otherDoubleOrStringMember")).ToLocal(&otherDoubleOrStringMemberValue)) {
+  if (!v8Object->Get(context, keys[17].Get(isolate)).ToLocal(&otherDoubleOrStringMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     DoubleOrString otherDoubleOrStringMember;
     V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
   }
 
   v8::Local<v8::Value> prefixGetMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "prefixGetMember")).ToLocal(&prefixGetMemberValue)) {
+  if (!v8Object->Get(context, keys[18].Get(isolate)).ToLocal(&prefixGetMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (prefixGetMemberValue.IsEmpty() || prefixGetMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     ScriptValue prefixGetMember = ScriptValue(ScriptState::current(isolate), prefixGetMemberValue);
     if (!prefixGetMember.isObject()) {
       exceptionState.throwTypeError("member prefixGetMember is not an object.");
       return;
     }
     impl.setPrefixGetMember(prefixGetMember);
   }
 
   v8::Local<v8::Value> recordMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "recordMember")).ToLocal(&recordMemberValue)) {
+  if (!v8Object->Get(context, keys[19].Get(isolate)).ToLocal(&recordMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (recordMemberValue.IsEmpty() || recordMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Vector<std::pair<String, int8_t>> recordMember = NativeValueTraits<IDLRecord<IDLByteString, IDLByte>>::nativeValue(isolate, recordMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setRecordMember(recordMember);
   }
 
   v8::Local<v8::Value> restrictedDoubleMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "restrictedDoubleMember")).ToLocal(&restrictedDoubleMemberValue)) {
+  if (!v8Object->Get(context, keys[20].Get(isolate)).ToLocal(&restrictedDoubleMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     double restrictedDoubleMember = NativeValueTraits<IDLDouble>::nativeValue(isolate, restrictedDoubleMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setRestrictedDoubleMember(restrictedDoubleMember);
   }
 
   if (RuntimeEnabledFeatures::runtimeFeatureEnabled()) {
     v8::Local<v8::Value> runtimeMemberValue;
-    if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "runtimeMember")).ToLocal(&runtimeMemberValue)) {
+    if (!v8Object->Get(context, keys[21].Get(isolate)).ToLocal(&runtimeMemberValue)) {
       exceptionState.rethrowV8Exception(block.Exception());
       return;
     }
     if (runtimeMemberValue.IsEmpty() || runtimeMemberValue->IsUndefined()) {
       // Do nothing.
     } else {
       bool runtimeMember = NativeValueTraits<IDLBoolean>::nativeValue(isolate, runtimeMemberValue, exceptionState);
       if (exceptionState.hadException())
         return;
       impl.setRuntimeMember(runtimeMember);
     }
   }
 
   v8::Local<v8::Value> stringArrayMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringArrayMember")).ToLocal(&stringArrayMemberValue)) {
+  if (!v8Object->Get(context, keys[22].Get(isolate)).ToLocal(&stringArrayMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Vector<String> stringArrayMember = toImplArray<Vector<String>>(stringArrayMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setStringArrayMember(stringArrayMember);
   }
 
   v8::Local<v8::Value> stringMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringMember")).ToLocal(&stringMemberValue)) {
+  if (!v8Object->Get(context, keys[23].Get(isolate)).ToLocal(&stringMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     V8StringResource<> stringMember = stringMemberValue;
     if (!stringMember.prepare(exceptionState))
       return;
     impl.setStringMember(stringMember);
   }
 
   v8::Local<v8::Value> stringOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrNullMember")).ToLocal(&stringOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[24].Get(isolate)).ToLocal(&stringOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (stringOrNullMemberValue->IsNull()) {
     impl.setStringOrNullMemberToNull();
   } else {
     V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
     if (!stringOrNullMember.prepare(exceptionState))
       return;
     impl.setStringOrNullMember(stringOrNullMember);
   }
 
   v8::Local<v8::Value> stringSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringSequenceMember")).ToLocal(&stringSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[25].Get(isolate)).ToLocal(&stringSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     Vector<String> stringSequenceMember = toImplArray<Vector<String>>(stringSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setStringSequenceMember(stringSequenceMember);
   }
 
   v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterface2OrUint8ArrayMember")).ToLocal(&testInterface2OrUint8ArrayMemberValue)) {
+  if (!v8Object->Get(context, keys[26].Get(isolate)).ToLocal(&testInterface2OrUint8ArrayMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
     V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, UnionTypeConversionMode::NotNullable, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedMember")).ToLocal(&testInterfaceGarbageCollectedMemberValue)) {
+  if (!v8Object->Get(context, keys[27].Get(isolate)).ToLocal(&testInterfaceGarbageCollectedMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
     if (!testInterfaceGarbageCollectedMember) {
       exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
       return;
     }
     impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedOrNullMember")).ToLocal(&testInterfaceGarbageCollectedOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[28].Get(isolate)).ToLocal(&testInterfaceGarbageCollectedOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
     impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
   } else {
     TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
     if (!testInterfaceGarbageCollectedOrNullMember) {
       exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
       return;
     }
     impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedSequenceMember")).ToLocal(&testInterfaceGarbageCollectedSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[29].Get(isolate)).ToLocal(&testInterfaceGarbageCollectedSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceGarbageCollectedSequenceMemberValue.IsEmpty() || testInterfaceGarbageCollectedSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedSequenceMember = toMemberNativeArray<TestInterfaceGarbageCollected>(testInterfaceGarbageCollectedSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setTestInterfaceGarbageCollectedSequenceMember(testInterfaceGarbageCollectedSequenceMember);
   }
 
   v8::Local<v8::Value> testInterfaceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceMember")).ToLocal(&testInterfaceMemberValue)) {
+  if (!v8Object->Get(context, keys[30].Get(isolate)).ToLocal(&testInterfaceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
     if (!testInterfaceMember) {
       exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
       return;
     }
     impl.setTestInterfaceMember(testInterfaceMember);
   }
 
   v8::Local<v8::Value> testInterfaceOrNullMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceOrNullMember")).ToLocal(&testInterfaceOrNullMemberValue)) {
+  if (!v8Object->Get(context, keys[31].Get(isolate)).ToLocal(&testInterfaceOrNullMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
     // Do nothing.
   } else if (testInterfaceOrNullMemberValue->IsNull()) {
     impl.setTestInterfaceOrNullMemberToNull();
   } else {
     TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
     if (!testInterfaceOrNullMember) {
       exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
       return;
     }
     impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
   }
 
   v8::Local<v8::Value> testInterfaceSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceSequenceMember")).ToLocal(&testInterfaceSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[32].Get(isolate)).ToLocal(&testInterfaceSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testInterfaceSequenceMemberValue.IsEmpty() || testInterfaceSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<Member<TestInterfaceImplementation>> testInterfaceSequenceMember = toMemberNativeArray<TestInterface>(testInterfaceSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setTestInterfaceSequenceMember(testInterfaceSequenceMember);
   }
 
   v8::Local<v8::Value> testObjectSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "testObjectSequenceMember")).ToLocal(&testObjectSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[33].Get(isolate)).ToLocal(&testObjectSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (testObjectSequenceMemberValue.IsEmpty() || testObjectSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<Member<TestObject>> testObjectSequenceMember = toMemberNativeArray<TestObject>(testObjectSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setTestObjectSequenceMember(testObjectSequenceMember);
   }
 
   v8::Local<v8::Value> uint8ArrayMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "uint8ArrayMember")).ToLocal(&uint8ArrayMemberValue)) {
+  if (!v8Object->Get(context, keys[34].Get(isolate)).ToLocal(&uint8ArrayMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     DOMUint8Array* uint8ArrayMember = uint8ArrayMemberValue->IsUint8Array() ? V8Uint8Array::toImpl(v8::Local<v8::Uint8Array>::Cast(uint8ArrayMemberValue)) : 0;
     if (!uint8ArrayMember) {
       exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
       return;
     }
     impl.setUint8ArrayMember(uint8ArrayMember);
   }
 
   v8::Local<v8::Value> unionInRecordMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionInRecordMember")).ToLocal(&unionInRecordMemberValue)) {
+  if (!v8Object->Get(context, keys[35].Get(isolate)).ToLocal(&unionInRecordMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (unionInRecordMemberValue.IsEmpty() || unionInRecordMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<std::pair<String, LongOrBoolean>> unionInRecordMember = NativeValueTraits<IDLRecord<IDLByteString, LongOrBoolean>>::nativeValue(isolate, unionInRecordMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setUnionInRecordMember(unionInRecordMember);
   }
 
   v8::Local<v8::Value> unionWithTypedefsValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionWithTypedefs")).ToLocal(&unionWithTypedefsValue)) {
+  if (!v8Object->Get(context, keys[36].Get(isolate)).ToLocal(&unionWithTypedefsValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (unionWithTypedefsValue.IsEmpty() || unionWithTypedefsValue->IsUndefined()) {
     // Do nothing.
   } else {
     FloatOrBoolean unionWithTypedefs;
     V8FloatOrBoolean::toImpl(isolate, unionWithTypedefsValue, unionWithTypedefs, UnionTypeConversionMode::NotNullable, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setUnionWithTypedefs(unionWithTypedefs);
   }
 
   v8::Local<v8::Value> unrestrictedDoubleMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "unrestrictedDoubleMember")).ToLocal(&unrestrictedDoubleMemberValue)) {
+  if (!v8Object->Get(context, keys[37].Get(isolate)).ToLocal(&unrestrictedDoubleMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     double unrestrictedDoubleMember = NativeValueTraits<IDLUnrestrictedDouble>::nativeValue(isolate, unrestrictedDoubleMemberValue, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
   }
 }
 
 v8::Local<v8::Value> TestDictionary::toV8Impl(v8::Local<v8::Object> creationContext, v8::Isolate* isolate) const {
   v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
   if (!toV8TestDictionary(*this, v8Object, creationContext, isolate))
     return v8::Undefined(isolate);
   return v8Object;
 }
 
 bool toV8TestDictionary(const TestDictionary& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
+  const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryKeys(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Value> anyMemberValue;
   bool anyMemberHasValueOrDefault = false;
   if (impl.hasAnyMember()) {
     anyMemberValue = impl.anyMember().v8Value();
     anyMemberHasValueOrDefault = true;
   } else {
     anyMemberValue = v8::Null(isolate);
     anyMemberHasValueOrDefault = true;
   }
   if (anyMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "anyMember"), anyMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), anyMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> booleanMemberValue;
   bool booleanMemberHasValueOrDefault = false;
   if (impl.hasBooleanMember()) {
     booleanMemberValue = v8Boolean(impl.booleanMember(), isolate);
     booleanMemberHasValueOrDefault = true;
   }
   if (booleanMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "booleanMember"), booleanMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[1].Get(isolate), booleanMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> createValue;
   bool createHasValueOrDefault = false;
   if (impl.hasCreateMember()) {
     createValue = v8Boolean(impl.createMember(), isolate);
     createHasValueOrDefault = true;
   }
   if (createHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "create"), createValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[2].Get(isolate), createValue))) {
     return false;
   }
 
   v8::Local<v8::Value> deprecatedCreateMemberValue;
   bool deprecatedCreateMemberHasValueOrDefault = false;
   if (impl.hasCreateMember()) {
     deprecatedCreateMemberValue = v8Boolean(impl.createMember(), isolate);
     deprecatedCreateMemberHasValueOrDefault = true;
   }
   if (deprecatedCreateMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "deprecatedCreateMember"), deprecatedCreateMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[3].Get(isolate), deprecatedCreateMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> dictionaryMemberValue;
   bool dictionaryMemberHasValueOrDefault = false;
   if (impl.hasDictionaryMember()) {
     DCHECK(impl.dictionaryMember().isObject());
     dictionaryMemberValue = impl.dictionaryMember().v8Value();
     dictionaryMemberHasValueOrDefault = true;
   }
   if (dictionaryMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "dictionaryMember"), dictionaryMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[4].Get(isolate), dictionaryMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> doubleOrNullMemberValue;
   bool doubleOrNullMemberHasValueOrDefault = false;
   if (impl.hasDoubleOrNullMember()) {
     doubleOrNullMemberValue = v8::Number::New(isolate, impl.doubleOrNullMember());
     doubleOrNullMemberHasValueOrDefault = true;
   } else {
     doubleOrNullMemberValue = v8::Null(isolate);
     doubleOrNullMemberHasValueOrDefault = true;
   }
   if (doubleOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrNullMember"), doubleOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[5].Get(isolate), doubleOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> doubleOrStringMemberValue;
   bool doubleOrStringMemberHasValueOrDefault = false;
   if (impl.hasDoubleOrStringMember()) {
     doubleOrStringMemberValue = ToV8(impl.doubleOrStringMember(), creationContext, isolate);
     doubleOrStringMemberHasValueOrDefault = true;
   } else {
     doubleOrStringMemberValue = ToV8(DoubleOrString::fromDouble(3.14), creationContext, isolate);
     doubleOrStringMemberHasValueOrDefault = true;
   }
   if (doubleOrStringMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringMember"), doubleOrStringMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[6].Get(isolate), doubleOrStringMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> doubleOrStringSequenceMemberValue;
   bool doubleOrStringSequenceMemberHasValueOrDefault = false;
   if (impl.hasDoubleOrStringSequenceMember()) {
     doubleOrStringSequenceMemberValue = ToV8(impl.doubleOrStringSequenceMember(), creationContext, isolate);
     doubleOrStringSequenceMemberHasValueOrDefault = true;
   }
   if (doubleOrStringSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringSequenceMember"), doubleOrStringSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[7].Get(isolate), doubleOrStringSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> elementOrNullMemberValue;
   bool elementOrNullMemberHasValueOrDefault = false;
   if (impl.hasElementOrNullMember()) {
     elementOrNullMemberValue = ToV8(impl.elementOrNullMember(), creationContext, isolate);
     elementOrNullMemberHasValueOrDefault = true;
   } else {
     elementOrNullMemberValue = v8::Null(isolate);
     elementOrNullMemberHasValueOrDefault = true;
   }
   if (elementOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "elementOrNullMember"), elementOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[8].Get(isolate), elementOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> enumMemberValue;
   bool enumMemberHasValueOrDefault = false;
   if (impl.hasEnumMember()) {
     enumMemberValue = v8String(isolate, impl.enumMember());
     enumMemberHasValueOrDefault = true;
   } else {
     enumMemberValue = v8String(isolate, "foo");
     enumMemberHasValueOrDefault = true;
   }
   if (enumMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumMember"), enumMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[9].Get(isolate), enumMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> enumSequenceMemberValue;
   bool enumSequenceMemberHasValueOrDefault = false;
   if (impl.hasEnumSequenceMember()) {
     enumSequenceMemberValue = ToV8(impl.enumSequenceMember(), creationContext, isolate);
     enumSequenceMemberHasValueOrDefault = true;
   }
   if (enumSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumSequenceMember"), enumSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[10].Get(isolate), enumSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> eventTargetMemberValue;
   bool eventTargetMemberHasValueOrDefault = false;
   if (impl.hasEventTargetMember()) {
     eventTargetMemberValue = ToV8(impl.eventTargetMember(), creationContext, isolate);
     eventTargetMemberHasValueOrDefault = true;
   }
   if (eventTargetMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "eventTargetMember"), eventTargetMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[11].Get(isolate), eventTargetMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> garbageCollectedRecordMemberValue;
   bool garbageCollectedRecordMemberHasValueOrDefault = false;
   if (impl.hasGarbageCollectedRecordMember()) {
     garbageCollectedRecordMemberValue = ToV8(impl.garbageCollectedRecordMember(), creationContext, isolate);
     garbageCollectedRecordMemberHasValueOrDefault = true;
   }
   if (garbageCollectedRecordMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "garbageCollectedRecordMember"), garbageCollectedRecordMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[12].Get(isolate), garbageCollectedRecordMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> internalDictionarySequenceMemberValue;
   bool internalDictionarySequenceMemberHasValueOrDefault = false;
   if (impl.hasInternalDictionarySequenceMember()) {
     internalDictionarySequenceMemberValue = ToV8(impl.internalDictionarySequenceMember(), creationContext, isolate);
     internalDictionarySequenceMemberHasValueOrDefault = true;
   }
   if (internalDictionarySequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "internalDictionarySequenceMember"), internalDictionarySequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[13].Get(isolate), internalDictionarySequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> longMemberValue;
   bool longMemberHasValueOrDefault = false;
   if (impl.hasLongMember()) {
     longMemberValue = v8::Integer::New(isolate, impl.longMember());
     longMemberHasValueOrDefault = true;
   } else {
     longMemberValue = v8::Integer::New(isolate, 1);
     longMemberHasValueOrDefault = true;
   }
   if (longMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "longMember"), longMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[14].Get(isolate), longMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> objectMemberValue;
   bool objectMemberHasValueOrDefault = false;
   if (impl.hasObjectMember()) {
     DCHECK(impl.objectMember().isObject());
     objectMemberValue = impl.objectMember().v8Value();
     objectMemberHasValueOrDefault = true;
   }
   if (objectMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectMember"), objectMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[15].Get(isolate), objectMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> objectOrNullMemberValue;
   bool objectOrNullMemberHasValueOrDefault = false;
   if (impl.hasObjectOrNullMember()) {
     DCHECK(impl.objectOrNullMember().isObject());
     objectOrNullMemberValue = impl.objectOrNullMember().v8Value();
     objectOrNullMemberHasValueOrDefault = true;
   } else {
     objectOrNullMemberValue = v8::Null(isolate);
     objectOrNullMemberHasValueOrDefault = true;
   }
   if (objectOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectOrNullMember"), objectOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[16].Get(isolate), objectOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> otherDoubleOrStringMemberValue;
   bool otherDoubleOrStringMemberHasValueOrDefault = false;
   if (impl.hasOtherDoubleOrStringMember()) {
     otherDoubleOrStringMemberValue = ToV8(impl.otherDoubleOrStringMember(), creationContext, isolate);
     otherDoubleOrStringMemberHasValueOrDefault = true;
   } else {
     otherDoubleOrStringMemberValue = ToV8(DoubleOrString::fromString("default string value"), creationContext, isolate);
     otherDoubleOrStringMemberHasValueOrDefault = true;
   }
   if (otherDoubleOrStringMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "otherDoubleOrStringMember"), otherDoubleOrStringMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[17].Get(isolate), otherDoubleOrStringMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> prefixGetMemberValue;
   bool prefixGetMemberHasValueOrDefault = false;
   if (impl.hasPrefixGetMember()) {
     DCHECK(impl.getPrefixGetMember().isObject());
     prefixGetMemberValue = impl.getPrefixGetMember().v8Value();
     prefixGetMemberHasValueOrDefault = true;
   }
   if (prefixGetMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "prefixGetMember"), prefixGetMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[18].Get(isolate), prefixGetMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> recordMemberValue;
   bool recordMemberHasValueOrDefault = false;
   if (impl.hasRecordMember()) {
     recordMemberValue = ToV8(impl.recordMember(), creationContext, isolate);
     recordMemberHasValueOrDefault = true;
   }
   if (recordMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "recordMember"), recordMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[19].Get(isolate), recordMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> restrictedDoubleMemberValue;
   bool restrictedDoubleMemberHasValueOrDefault = false;
   if (impl.hasRestrictedDoubleMember()) {
     restrictedDoubleMemberValue = v8::Number::New(isolate, impl.restrictedDoubleMember());
     restrictedDoubleMemberHasValueOrDefault = true;
   } else {
     restrictedDoubleMemberValue = v8::Number::New(isolate, 3.14);
     restrictedDoubleMemberHasValueOrDefault = true;
   }
   if (restrictedDoubleMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "restrictedDoubleMember"), restrictedDoubleMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[20].Get(isolate), restrictedDoubleMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> runtimeMemberValue;
   bool runtimeMemberHasValueOrDefault = false;
   if (impl.hasRuntimeMember()) {
     runtimeMemberValue = v8Boolean(impl.runtimeMember(), isolate);
     runtimeMemberHasValueOrDefault = true;
   }
   if (runtimeMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "runtimeMember"), runtimeMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[21].Get(isolate), runtimeMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> stringArrayMemberValue;
   bool stringArrayMemberHasValueOrDefault = false;
   if (impl.hasStringArrayMember()) {
     stringArrayMemberValue = ToV8(impl.stringArrayMember(), creationContext, isolate);
     stringArrayMemberHasValueOrDefault = true;
   }
   if (stringArrayMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringArrayMember"), stringArrayMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[22].Get(isolate), stringArrayMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> stringMemberValue;
   bool stringMemberHasValueOrDefault = false;
   if (impl.hasStringMember()) {
     stringMemberValue = v8String(isolate, impl.stringMember());
     stringMemberHasValueOrDefault = true;
   }
   if (stringMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringMember"), stringMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[23].Get(isolate), stringMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> stringOrNullMemberValue;
   bool stringOrNullMemberHasValueOrDefault = false;
   if (impl.hasStringOrNullMember()) {
     stringOrNullMemberValue = v8String(isolate, impl.stringOrNullMember());
     stringOrNullMemberHasValueOrDefault = true;
   } else {
     stringOrNullMemberValue = v8String(isolate, "default string value");
     stringOrNullMemberHasValueOrDefault = true;
   }
   if (stringOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrNullMember"), stringOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[24].Get(isolate), stringOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> stringSequenceMemberValue;
   bool stringSequenceMemberHasValueOrDefault = false;
   if (impl.hasStringSequenceMember()) {
     stringSequenceMemberValue = ToV8(impl.stringSequenceMember(), creationContext, isolate);
     stringSequenceMemberHasValueOrDefault = true;
   } else {
     stringSequenceMemberValue = ToV8(Vector<String>(), creationContext, isolate);
     stringSequenceMemberHasValueOrDefault = true;
   }
   if (stringSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringSequenceMember"), stringSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[25].Get(isolate), stringSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue;
   bool testInterface2OrUint8ArrayMemberHasValueOrDefault = false;
   if (impl.hasTestInterface2OrUint8ArrayMember()) {
     testInterface2OrUint8ArrayMemberValue = ToV8(impl.testInterface2OrUint8ArrayMember(), creationContext, isolate);
     testInterface2OrUint8ArrayMemberHasValueOrDefault = true;
   }
   if (testInterface2OrUint8ArrayMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterface2OrUint8ArrayMember"), testInterface2OrUint8ArrayMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[26].Get(isolate), testInterface2OrUint8ArrayMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue;
   bool testInterfaceGarbageCollectedMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceGarbageCollectedMember()) {
     testInterfaceGarbageCollectedMemberValue = ToV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate);
     testInterfaceGarbageCollectedMemberHasValueOrDefault = true;
   }
   if (testInterfaceGarbageCollectedMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedMember"), testInterfaceGarbageCollectedMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[27].Get(isolate), testInterfaceGarbageCollectedMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue;
   bool testInterfaceGarbageCollectedOrNullMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceGarbageCollectedOrNullMember()) {
     testInterfaceGarbageCollectedOrNullMemberValue = ToV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate);
     testInterfaceGarbageCollectedOrNullMemberHasValueOrDefault = true;
   } else {
     testInterfaceGarbageCollectedOrNullMemberValue = v8::Null(isolate);
     testInterfaceGarbageCollectedOrNullMemberHasValueOrDefault = true;
   }
   if (testInterfaceGarbageCollectedOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedOrNullMember"), testInterfaceGarbageCollectedOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[28].Get(isolate), testInterfaceGarbageCollectedOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceGarbageCollectedSequenceMemberValue;
   bool testInterfaceGarbageCollectedSequenceMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceGarbageCollectedSequenceMember()) {
     testInterfaceGarbageCollectedSequenceMemberValue = ToV8(impl.testInterfaceGarbageCollectedSequenceMember(), creationContext, isolate);
     testInterfaceGarbageCollectedSequenceMemberHasValueOrDefault = true;
   } else {
     testInterfaceGarbageCollectedSequenceMemberValue = ToV8(HeapVector<Member<TestInterfaceGarbageCollected>>(), creationContext, isolate);
     testInterfaceGarbageCollectedSequenceMemberHasValueOrDefault = true;
   }
   if (testInterfaceGarbageCollectedSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedSequenceMember"), testInterfaceGarbageCollectedSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[29].Get(isolate), testInterfaceGarbageCollectedSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceMemberValue;
   bool testInterfaceMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceMember()) {
     testInterfaceMemberValue = ToV8(impl.testInterfaceMember(), creationContext, isolate);
     testInterfaceMemberHasValueOrDefault = true;
   }
   if (testInterfaceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceMember"), testInterfaceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[30].Get(isolate), testInterfaceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceOrNullMemberValue;
   bool testInterfaceOrNullMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceOrNullMember()) {
     testInterfaceOrNullMemberValue = ToV8(impl.testInterfaceOrNullMember(), creationContext, isolate);
     testInterfaceOrNullMemberHasValueOrDefault = true;
   } else {
     testInterfaceOrNullMemberValue = v8::Null(isolate);
     testInterfaceOrNullMemberHasValueOrDefault = true;
   }
   if (testInterfaceOrNullMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceOrNullMember"), testInterfaceOrNullMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[31].Get(isolate), testInterfaceOrNullMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testInterfaceSequenceMemberValue;
   bool testInterfaceSequenceMemberHasValueOrDefault = false;
   if (impl.hasTestInterfaceSequenceMember()) {
     testInterfaceSequenceMemberValue = ToV8(impl.testInterfaceSequenceMember(), creationContext, isolate);
     testInterfaceSequenceMemberHasValueOrDefault = true;
   } else {
     testInterfaceSequenceMemberValue = ToV8(HeapVector<Member<TestInterfaceImplementation>>(), creationContext, isolate);
     testInterfaceSequenceMemberHasValueOrDefault = true;
   }
   if (testInterfaceSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceSequenceMember"), testInterfaceSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[32].Get(isolate), testInterfaceSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> testObjectSequenceMemberValue;
   bool testObjectSequenceMemberHasValueOrDefault = false;
   if (impl.hasTestObjectSequenceMember()) {
     testObjectSequenceMemberValue = ToV8(impl.testObjectSequenceMember(), creationContext, isolate);
     testObjectSequenceMemberHasValueOrDefault = true;
   }
   if (testObjectSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testObjectSequenceMember"), testObjectSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[33].Get(isolate), testObjectSequenceMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> uint8ArrayMemberValue;
   bool uint8ArrayMemberHasValueOrDefault = false;
   if (impl.hasUint8ArrayMember()) {
     uint8ArrayMemberValue = ToV8(impl.uint8ArrayMember(), creationContext, isolate);
     uint8ArrayMemberHasValueOrDefault = true;
   }
   if (uint8ArrayMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "uint8ArrayMember"), uint8ArrayMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[34].Get(isolate), uint8ArrayMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> unionInRecordMemberValue;
   bool unionInRecordMemberHasValueOrDefault = false;
   if (impl.hasUnionInRecordMember()) {
     unionInRecordMemberValue = ToV8(impl.unionInRecordMember(), creationContext, isolate);
     unionInRecordMemberHasValueOrDefault = true;
   }
   if (unionInRecordMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionInRecordMember"), unionInRecordMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[35].Get(isolate), unionInRecordMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> unionWithTypedefsValue;
   bool unionWithTypedefsHasValueOrDefault = false;
   if (impl.hasUnionWithTypedefs()) {
     unionWithTypedefsValue = ToV8(impl.unionWithTypedefs(), creationContext, isolate);
     unionWithTypedefsHasValueOrDefault = true;
   }
   if (unionWithTypedefsHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionWithTypedefs"), unionWithTypedefsValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[36].Get(isolate), unionWithTypedefsValue))) {
     return false;
   }
 
   v8::Local<v8::Value> unrestrictedDoubleMemberValue;
   bool unrestrictedDoubleMemberHasValueOrDefault = false;
   if (impl.hasUnrestrictedDoubleMember()) {
     unrestrictedDoubleMemberValue = v8::Number::New(isolate, impl.unrestrictedDoubleMember());
     unrestrictedDoubleMemberHasValueOrDefault = true;
   } else {
     unrestrictedDoubleMemberValue = v8::Number::New(isolate, 3.14);
     unrestrictedDoubleMemberHasValueOrDefault = true;
   }
   if (unrestrictedDoubleMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unrestrictedDoubleMember"), unrestrictedDoubleMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[37].Get(isolate), unrestrictedDoubleMemberValue))) {
     return false;
   }
 
   return true;
 }
 
 TestDictionary NativeValueTraits<TestDictionary>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
   TestDictionary impl;
   V8TestDictionary::toImpl(isolate, value, impl, exceptionState);
   return impl;
 }
 
 }  // namespace blink