[Bindings] Cache handles for dictionary keys on V8PerIsolateData.

third_party/WebKit/Source/bindings/templates/dictionary_v8.cpp.tmpl

 {% filter format_blink_cpp_source_code %}
 
 {% from 'utilities.cpp.tmpl' import declare_enum_validation_variable %}
 {% include 'copyright_block.txt' %}
 #include "{{v8_original_class}}.h"
 
 {% for filename in cpp_includes if filename != '%s.h' % v8_class %}
 #include "{{filename}}"
 {% endfor %}
 
 namespace blink {
 
+{% if members %}
+static const v8::Eternal<v8::Name>* eternal{{v8_class}}Keys(v8::Isolate* isolate) {
+  static const char* const kKeys[] = {
+    {% for member in members %}
+    "{{member.name}}",
+    {% endfor %}
+  };
+  return V8PerIsolateData::from(isolate)->findOrCreateEternalNameCache(
+      kKeys, kKeys, WTF_ARRAY_LENGTH(kKeys));
+}
+{% endif %}
+
 {% from 'utilities.cpp.tmpl' import v8_value_to_local_cpp_value %}
 void {{v8_class}}::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, {{cpp_class}}& impl, ExceptionState& exceptionState) {
   if (isUndefinedOrNull(v8Value)) {
     {% if required_member_names %}
     exceptionState.throwTypeError("Missing required member(s): {{required_member_names|join(', ')}}.");
     {% endif %}
     return;
   }
   if (!v8Value->IsObject()) {
     {% if use_permissive_dictionary_conversion %}
     // Do nothing.
     return;
     {% else %}
     exceptionState.throwTypeError("cannot convert to dictionary.");
     return;
     {% endif %}
   }
   v8::Local<v8::Object> v8Object = v8Value.As<v8::Object>();
   ALLOW_UNUSED_LOCAL(v8Object);
 
   {% if parent_v8_class %}
   {{parent_v8_class}}::toImpl(isolate, v8Value, impl, exceptionState);
   if (exceptionState.hadException())
     return;
 
   {% endif %}
   {# Declare local variables only when the dictionary has members to avoid unused variable warnings. #}
   {% if members %}
+  const v8::Eternal<v8::Name>* keys = eternal{{v8_class}}Keys(isolate);
   v8::TryCatch block(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   {% endif %}
   {% for member in members %}
   {% filter runtime_enabled(member.runtime_enabled_feature_name) %}
   v8::Local<v8::Value> {{member.name}}Value;
-  if (!v8Object->Get(isolate->GetCurrentContext(), v8AtomicString(isolate, "{{member.name}}")).ToLocal(&{{member.name}}Value)) {
+  if (!v8Object->Get(context, keys[{{loop.index0}}].Get(isolate)).ToLocal(&{{member.name}}Value)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return;
   }
   if ({{member.name}}Value.IsEmpty() || {{member.name}}Value->IsUndefined()) {
     {% if member.is_required %}
     exceptionState.throwTypeError("required member {{member.name}} is undefined.");
     return;
     {% else %}
     // Do nothing.
     {% endif %}
@@ skipping 35 matching lines @@
     return v8::Undefined(isolate);
   return v8Object;
 }
 
 bool toV8{{cpp_class}}(const {{cpp_class}}& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
   {% if parent_v8_class %}
   if (!toV8{{parent_cpp_class}}(impl, dictionary, creationContext, isolate))
     return false;
 
   {% endif %}
+  {% if members %}
+  const v8::Eternal<v8::Name>* keys = eternal{{v8_class}}Keys(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  {% endif %}
   {% for member in members %}
   v8::Local<v8::Value> {{member.name}}Value;
   bool {{member.name}}HasValueOrDefault = false;
   if (impl.{{member.has_method_name}}()) {
     {% if member.is_object %}
     DCHECK(impl.{{member.getter_name}}().isObject());
     {% endif %}
     {{member.name}}Value = {{member.cpp_value_to_v8_value}};
     {{member.name}}HasValueOrDefault = true;
   {% if member.v8_default_value %}
   } else {
     {{member.name}}Value = {{member.v8_default_value}};
     {{member.name}}HasValueOrDefault = true;
   {% elif member.is_nullable %}
   } else {
     {{member.name}}Value = v8::Null(isolate);
     {{member.name}}HasValueOrDefault = true;
   {% elif member.is_required %}
   } else {
     NOTREACHED();
   {% endif %}
   }
   {# The HasValueOrDefault variable will be optimized out.
      If there is a default value, the compiler will notice that all branches set it to true.
      If there is not, then the compiler will inline this call into the only branch that sets it to true.
      Either way, the code is efficient and the variable is completely elided. #}
   if ({{member.name}}HasValueOrDefault &&
-      !v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8AtomicString(isolate, "{{member.name}}"), {{member.name}}Value))) {
+      !v8CallBoolean(dictionary->CreateDataProperty(context, keys[{{loop.index0}}].Get(isolate), {{member.name}}Value))) {
     return false;
   }
 
   {% endfor %}
   return true;
 }
 
 {{cpp_class}} NativeValueTraits<{{cpp_class}}>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
   {{cpp_class}} impl;
   {{v8_class}}::toImpl(isolate, value, impl, exceptionState);
   return impl;
 }
 
 }  // namespace blink
 
 {% endfilter %}{# format_blink_cpp_source_code #}