[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)->findOrCreateKeys(
+      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();
   if (impl.hasAnyMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "anyMember"), impl.anyMember().v8Value())))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "anyMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), impl.anyMember().v8Value())))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasBooleanMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "booleanMember"), v8Boolean(impl.booleanMember(), isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[1].Get(isolate), v8Boolean(impl.booleanMember(), isolate))))
       return false;
   }
 
   if (impl.hasCreateMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "create"), v8Boolean(impl.createMember(), isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[2].Get(isolate), v8Boolean(impl.createMember(), isolate))))
       return false;
   }
 
   if (impl.hasCreateMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "deprecatedCreateMember"), v8Boolean(impl.createMember(), isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[3].Get(isolate), v8Boolean(impl.createMember(), isolate))))
       return false;
   }
 
   if (impl.hasDictionaryMember()) {
     DCHECK(impl.dictionaryMember().isObject());
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "dictionaryMember"), impl.dictionaryMember().v8Value())))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[4].Get(isolate), impl.dictionaryMember().v8Value())))
       return false;
   }
 
   if (impl.hasDoubleOrNullMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrNullMember"), v8::Number::New(isolate, impl.doubleOrNullMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrNullMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[5].Get(isolate), v8::Number::New(isolate, impl.doubleOrNullMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[5].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasDoubleOrStringMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringMember"), ToV8(impl.doubleOrStringMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringMember"), ToV8(DoubleOrString::fromDouble(3.14), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[6].Get(isolate), ToV8(impl.doubleOrStringMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[6].Get(isolate), ToV8(DoubleOrString::fromDouble(3.14), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasDoubleOrStringSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "doubleOrStringSequenceMember"), ToV8(impl.doubleOrStringSequenceMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[7].Get(isolate), ToV8(impl.doubleOrStringSequenceMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasElementOrNullMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "elementOrNullMember"), ToV8(impl.elementOrNullMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "elementOrNullMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[8].Get(isolate), ToV8(impl.elementOrNullMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[8].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasEnumMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumMember"), v8String(isolate, impl.enumMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumMember"), v8String(isolate, "foo"))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[9].Get(isolate), v8String(isolate, impl.enumMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[9].Get(isolate), v8String(isolate, "foo"))))
       return false;
   }
 
   if (impl.hasEnumSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "enumSequenceMember"), ToV8(impl.enumSequenceMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[10].Get(isolate), ToV8(impl.enumSequenceMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasEventTargetMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "eventTargetMember"), ToV8(impl.eventTargetMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[11].Get(isolate), ToV8(impl.eventTargetMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasGarbageCollectedRecordMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "garbageCollectedRecordMember"), ToV8(impl.garbageCollectedRecordMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[12].Get(isolate), ToV8(impl.garbageCollectedRecordMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasInternalDictionarySequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "internalDictionarySequenceMember"), ToV8(impl.internalDictionarySequenceMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[13].Get(isolate), ToV8(impl.internalDictionarySequenceMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasLongMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "longMember"), v8::Integer::New(isolate, impl.longMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "longMember"), v8::Integer::New(isolate, 1))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[14].Get(isolate), v8::Integer::New(isolate, impl.longMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[14].Get(isolate), v8::Integer::New(isolate, 1))))
       return false;
   }
 
   if (impl.hasObjectMember()) {
     DCHECK(impl.objectMember().isObject());
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectMember"), impl.objectMember().v8Value())))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[15].Get(isolate), impl.objectMember().v8Value())))
       return false;
   }
 
   if (impl.hasObjectOrNullMember()) {
     DCHECK(impl.objectOrNullMember().isObject());
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectOrNullMember"), impl.objectOrNullMember().v8Value())))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "objectOrNullMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[16].Get(isolate), impl.objectOrNullMember().v8Value())))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[16].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasOtherDoubleOrStringMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "otherDoubleOrStringMember"), ToV8(impl.otherDoubleOrStringMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "otherDoubleOrStringMember"), ToV8(DoubleOrString::fromString("default string value"), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[17].Get(isolate), ToV8(impl.otherDoubleOrStringMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[17].Get(isolate), ToV8(DoubleOrString::fromString("default string value"), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasPrefixGetMember()) {
     DCHECK(impl.getPrefixGetMember().isObject());
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "prefixGetMember"), impl.getPrefixGetMember().v8Value())))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[18].Get(isolate), impl.getPrefixGetMember().v8Value())))
       return false;
   }
 
   if (impl.hasRecordMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "recordMember"), ToV8(impl.recordMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[19].Get(isolate), ToV8(impl.recordMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasRestrictedDoubleMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, impl.restrictedDoubleMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[20].Get(isolate), v8::Number::New(isolate, impl.restrictedDoubleMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[20].Get(isolate), v8::Number::New(isolate, 3.14))))
       return false;
   }
 
   if (impl.hasRuntimeMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "runtimeMember"), v8Boolean(impl.runtimeMember(), isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[21].Get(isolate), v8Boolean(impl.runtimeMember(), isolate))))
       return false;
   }
 
   if (impl.hasStringArrayMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringArrayMember"), ToV8(impl.stringArrayMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[22].Get(isolate), ToV8(impl.stringArrayMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasStringMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringMember"), v8String(isolate, impl.stringMember()))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[23].Get(isolate), v8String(isolate, impl.stringMember()))))
       return false;
   }
 
   if (impl.hasStringOrNullMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrNullMember"), v8String(isolate, impl.stringOrNullMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrNullMember"), v8String(isolate, "default string value"))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[24].Get(isolate), v8String(isolate, impl.stringOrNullMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[24].Get(isolate), v8String(isolate, "default string value"))))
       return false;
   }
 
   if (impl.hasStringSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringSequenceMember"), ToV8(impl.stringSequenceMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringSequenceMember"), ToV8(Vector<String>(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[25].Get(isolate), ToV8(impl.stringSequenceMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[25].Get(isolate), ToV8(Vector<String>(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestInterface2OrUint8ArrayMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterface2OrUint8ArrayMember"), ToV8(impl.testInterface2OrUint8ArrayMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[26].Get(isolate), ToV8(impl.testInterface2OrUint8ArrayMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceGarbageCollectedMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedMember"), ToV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[27].Get(isolate), ToV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceGarbageCollectedOrNullMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedOrNullMember"), ToV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedOrNullMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[28].Get(isolate), ToV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[28].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceGarbageCollectedSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedSequenceMember"), ToV8(impl.testInterfaceGarbageCollectedSequenceMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceGarbageCollectedSequenceMember"), ToV8(HeapVector<Member<TestInterfaceGarbageCollected>>(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[29].Get(isolate), ToV8(impl.testInterfaceGarbageCollectedSequenceMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[29].Get(isolate), ToV8(HeapVector<Member<TestInterfaceGarbageCollected>>(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceMember"), ToV8(impl.testInterfaceMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[30].Get(isolate), ToV8(impl.testInterfaceMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceOrNullMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceOrNullMember"), ToV8(impl.testInterfaceOrNullMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceOrNullMember"), v8::Null(isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[31].Get(isolate), ToV8(impl.testInterfaceOrNullMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[31].Get(isolate), v8::Null(isolate))))
       return false;
   }
 
   if (impl.hasTestInterfaceSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceSequenceMember"), ToV8(impl.testInterfaceSequenceMember(), creationContext, isolate))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testInterfaceSequenceMember"), ToV8(HeapVector<Member<TestInterfaceImplementation>>(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[32].Get(isolate), ToV8(impl.testInterfaceSequenceMember(), creationContext, isolate))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[32].Get(isolate), ToV8(HeapVector<Member<TestInterfaceImplementation>>(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasTestObjectSequenceMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "testObjectSequenceMember"), ToV8(impl.testObjectSequenceMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[33].Get(isolate), ToV8(impl.testObjectSequenceMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasUint8ArrayMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "uint8ArrayMember"), ToV8(impl.uint8ArrayMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[34].Get(isolate), ToV8(impl.uint8ArrayMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasUnionInRecordMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionInRecordMember"), ToV8(impl.unionInRecordMember(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[35].Get(isolate), ToV8(impl.unionInRecordMember(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasUnionWithTypedefs()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unionWithTypedefs"), ToV8(impl.unionWithTypedefs(), creationContext, isolate))))
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[36].Get(isolate), ToV8(impl.unionWithTypedefs(), creationContext, isolate))))
       return false;
   }
 
   if (impl.hasUnrestrictedDoubleMember()) {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, impl.unrestrictedDoubleMember()))))
-      return false;
-  } else {
-    if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
-      return false;
-  }
-
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[37].Get(isolate), v8::Number::New(isolate, impl.unrestrictedDoubleMember()))))
+      return false;
+  } else {
+    if (!v8CallBoolean(dictionary->CreateDataProperty(context, keys[37].Get(isolate), v8::Number::New(isolate, 3.14))))
+      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