[Bindings] Cache handles for dictionary keys on V8PerIsolateData.

third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionaryDerived.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
 
 // clang-format off
 #include "V8TestDictionaryDerived.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/IDLTypes.h"
 #include "bindings/core/v8/NativeValueTraitsImpl.h"
 #include "bindings/core/v8/V8TestDictionary.h"
 
 namespace blink {
 
+static const v8::Eternal<v8::Name>* eternalV8TestDictionaryDerivedImplementedAsKeys(v8::Isolate* isolate) {
+  static const char* const kKeys[] = {
+    "derivedStringMember",
+    "derivedStringMemberWithDefault",
+    "requiredLongMember",
+    "stringOrDoubleSequenceMember",
+  };
+  return V8PerIsolateData::from(isolate)->findOrCreateEternalNameCache(
+      kKeys, kKeys, WTF_ARRAY_LENGTH(kKeys));
+}
+
 void V8TestDictionaryDerivedImplementedAs::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionaryDerivedImplementedAs& impl, ExceptionState& exceptionState) {
   if (isUndefinedOrNull(v8Value)) {
     exceptionState.throwTypeError("Missing required member(s): requiredLongMember.");
     return;
   }
   if (!v8Value->IsObject()) {
     exceptionState.throwTypeError("cannot convert to dictionary.");
     return;
   }
   v8::Local<v8::Object> v8Object = v8Value.As<v8::Object>();
   ALLOW_UNUSED_LOCAL(v8Object);
 
   V8TestDictionary::toImpl(isolate, v8Value, impl, exceptionState);
   if (exceptionState.hadException())
     return;
 
+  const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryDerivedImplementedAsKeys(isolate);
   v8::TryCatch block(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Value> derivedStringMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "derivedStringMember")).ToLocal(&derivedStringMemberValue)) {
+  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&derivedStringMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (derivedStringMemberValue.IsEmpty() || derivedStringMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     V8StringResource<> derivedStringMember = derivedStringMemberValue;
     if (!derivedStringMember.prepare(exceptionState))
       return;
     impl.setDerivedStringMember(derivedStringMember);
   }
 
   v8::Local<v8::Value> derivedStringMemberWithDefaultValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "derivedStringMemberWithDefault")).ToLocal(&derivedStringMemberWithDefaultValue)) {
+  if (!v8Object->Get(context, keys[1].Get(isolate)).ToLocal(&derivedStringMemberWithDefaultValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (derivedStringMemberWithDefaultValue.IsEmpty() || derivedStringMemberWithDefaultValue->IsUndefined()) {
     // Do nothing.
   } else {
     V8StringResource<> derivedStringMemberWithDefault = derivedStringMemberWithDefaultValue;
     if (!derivedStringMemberWithDefault.prepare(exceptionState))
       return;
     impl.setDerivedStringMemberWithDefault(derivedStringMemberWithDefault);
   }
 
   v8::Local<v8::Value> requiredLongMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "requiredLongMember")).ToLocal(&requiredLongMemberValue)) {
+  if (!v8Object->Get(context, keys[2].Get(isolate)).ToLocal(&requiredLongMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (requiredLongMemberValue.IsEmpty() || requiredLongMemberValue->IsUndefined()) {
     exceptionState.throwTypeError("required member requiredLongMember is undefined.");
     return;
   } else {
     int32_t requiredLongMember = NativeValueTraits<IDLLong>::nativeValue(isolate, requiredLongMemberValue, exceptionState, NormalConversion);
     if (exceptionState.hadException())
       return;
     impl.setRequiredLongMember(requiredLongMember);
   }
 
   v8::Local<v8::Value> stringOrDoubleSequenceMemberValue;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrDoubleSequenceMember")).ToLocal(&stringOrDoubleSequenceMemberValue)) {
+  if (!v8Object->Get(context, keys[3].Get(isolate)).ToLocal(&stringOrDoubleSequenceMemberValue)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if (stringOrDoubleSequenceMemberValue.IsEmpty() || stringOrDoubleSequenceMemberValue->IsUndefined()) {
     // Do nothing.
   } else {
     HeapVector<StringOrDouble> stringOrDoubleSequenceMember = toImplArray<HeapVector<StringOrDouble>>(stringOrDoubleSequenceMemberValue, 0, isolate, exceptionState);
     if (exceptionState.hadException())
       return;
     impl.setStringOrDoubleSequenceMember(stringOrDoubleSequenceMember);
   }
 }
 
 v8::Local<v8::Value> TestDictionaryDerivedImplementedAs::toV8Impl(v8::Local<v8::Object> creationContext, v8::Isolate* isolate) const {
   v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
   if (!toV8TestDictionaryDerivedImplementedAs(*this, v8Object, creationContext, isolate))
     return v8::Undefined(isolate);
   return v8Object;
 }
 
 bool toV8TestDictionaryDerivedImplementedAs(const TestDictionaryDerivedImplementedAs& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
   if (!toV8TestDictionary(impl, dictionary, creationContext, isolate))
     return false;
 
+  const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryDerivedImplementedAsKeys(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Value> derivedStringMemberValue;
   bool derivedStringMemberHasValueOrDefault = false;
   if (impl.hasDerivedStringMember()) {
     derivedStringMemberValue = v8String(isolate, impl.derivedStringMember());
     derivedStringMemberHasValueOrDefault = true;
   }
   if (derivedStringMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "derivedStringMember"), derivedStringMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), derivedStringMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> derivedStringMemberWithDefaultValue;
   bool derivedStringMemberWithDefaultHasValueOrDefault = false;
   if (impl.hasDerivedStringMemberWithDefault()) {
     derivedStringMemberWithDefaultValue = v8String(isolate, impl.derivedStringMemberWithDefault());
     derivedStringMemberWithDefaultHasValueOrDefault = true;
   } else {
     derivedStringMemberWithDefaultValue = v8String(isolate, "default string value");
     derivedStringMemberWithDefaultHasValueOrDefault = true;
   }
   if (derivedStringMemberWithDefaultHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "derivedStringMemberWithDefault"), derivedStringMemberWithDefaultValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[1].Get(isolate), derivedStringMemberWithDefaultValue))) {
     return false;
   }
 
   v8::Local<v8::Value> requiredLongMemberValue;
   bool requiredLongMemberHasValueOrDefault = false;
   if (impl.hasRequiredLongMember()) {
     requiredLongMemberValue = v8::Integer::New(isolate, impl.requiredLongMember());
     requiredLongMemberHasValueOrDefault = true;
   } else {
     NOTREACHED();
   }
   if (requiredLongMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "requiredLongMember"), requiredLongMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[2].Get(isolate), requiredLongMemberValue))) {
     return false;
   }
 
   v8::Local<v8::Value> stringOrDoubleSequenceMemberValue;
   bool stringOrDoubleSequenceMemberHasValueOrDefault = false;
   if (impl.hasStringOrDoubleSequenceMember()) {
     stringOrDoubleSequenceMemberValue = ToV8(impl.stringOrDoubleSequenceMember(), creationContext, isolate);
     stringOrDoubleSequenceMemberHasValueOrDefault = true;
   }
   if (stringOrDoubleSequenceMemberHasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "stringOrDoubleSequenceMember"), stringOrDoubleSequenceMemberValue))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[3].Get(isolate), stringOrDoubleSequenceMemberValue))) {
     return false;
   }
 
   return true;
 }
 
 TestDictionaryDerivedImplementedAs NativeValueTraits<TestDictionaryDerivedImplementedAs>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
   TestDictionaryDerivedImplementedAs impl;
   V8TestDictionaryDerivedImplementedAs::toImpl(isolate, value, impl, exceptionState);
   return impl;
 }
 
 }  // namespace blink