bindings: Use an alias for @@iterator in certain declarations.

third_party/WebKit/Source/bindings/core/v8/V8DOMConfiguration.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 315 matching lines @@
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Name> name = V8AtomicString(isolate, constant.name);
   v8::PropertyAttribute attributes =
       static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
   v8::Local<v8::Primitive> value = ValueForConstant(isolate, constant);
   interface->DefineOwnProperty(context, name, value, attributes).ToChecked();
   prototype->DefineOwnProperty(context, name, value, attributes).ToChecked();
 }
 
 template <class Configuration>
+void AddMethodToTemplate(v8::Isolate* isolate,
+                         v8::Local<v8::Template> v8_template,
+                         v8::Local<v8::FunctionTemplate> function_template,
+                         const Configuration& method) {
+  v8_template->Set(method.MethodName(isolate), function_template,
+                   static_cast<v8::PropertyAttribute>(method.attribute));
+}
+
+template <>
+void AddMethodToTemplate(
+    v8::Isolate* isolate,
+    v8::Local<v8::Template> v8_template,
+    v8::Local<v8::FunctionTemplate> function_template,
+    const V8DOMConfiguration::SymbolKeyedMethodConfiguration& method) {
+  // The order matters here: if the Symbol is added first, the Function object
+  // will have no associated name. For example, WebIDL states, among other
+  // things, that a pair iterator's @@iterator Function object's name must be
+  // set to "entries".
+  if (method.symbol_alias) {
+    v8_template->Set(V8AtomicString(isolate, method.symbol_alias),
+                     function_template);
+  }
+  v8_template->Set(method.MethodName(isolate), function_template,
+                   static_cast<v8::PropertyAttribute>(method.attribute));
+}
+
+template <class Configuration>
 void InstallMethodInternal(v8::Isolate* isolate,
                            v8::Local<v8::ObjectTemplate> instance_template,
                            v8::Local<v8::ObjectTemplate> prototype_template,
                            v8::Local<v8::FunctionTemplate> interface_template,
                            v8::Local<v8::Signature> signature,
                            const Configuration& method,
                            const DOMWrapperWorld& world) {
   if (!WorldConfigurationApplies(method, world))
     return;
 
-  v8::Local<v8::Name> name = method.MethodName(isolate);
   v8::FunctionCallback callback = method.callback;
   // Promise-returning functions need to return a reject promise when
   // an exception occurs.  This includes a case that the receiver object is not
   // of the type.  So, we disable the type check of the receiver object on V8
   // side so that V8 won't throw.  Instead, we do the check on Blink side and
   // convert an exception to a reject promise.
   if (method.holder_check_configuration ==
       V8DOMConfiguration::kDoNotCheckHolder)
     signature = v8::Local<v8::Signature>();
 
   DCHECK(method.property_location_configuration);
   if (method.property_location_configuration &
       (V8DOMConfiguration::kOnInstance | V8DOMConfiguration::kOnPrototype)) {
     v8::Local<v8::FunctionTemplate> function_template =
         v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),
                                   signature, method.length);
     function_template->RemovePrototype();
     if (method.access_check_configuration == V8DOMConfiguration::kCheckAccess)
       function_template->SetAcceptAnyReceiver(false);
     if (method.property_location_configuration &
-        V8DOMConfiguration::kOnInstance)
-      instance_template->Set(
-          name, function_template,
-          static_cast<v8::PropertyAttribute>(method.attribute));
+        V8DOMConfiguration::kOnInstance) {
+      AddMethodToTemplate(isolate, instance_template, function_template,
+                          method);
+    }
     if (method.property_location_configuration &
-        V8DOMConfiguration::kOnPrototype)
-      prototype_template->Set(
-          name, function_template,
-          static_cast<v8::PropertyAttribute>(method.attribute));
+        V8DOMConfiguration::kOnPrototype) {
+      AddMethodToTemplate(isolate, prototype_template, function_template,
+                          method);
+    }
   }
   if (method.property_location_configuration &
       V8DOMConfiguration::kOnInterface) {
     // Operations installed on the interface object must be static methods, so
     // no need to specify a signature, i.e. no need to do type check against a
     // holder.
     v8::Local<v8::FunctionTemplate> function_template =
         v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),
                                   v8::Local<v8::Signature>(), method.length);
     function_template->RemovePrototype();
     // Similarly, there is no need to do an access check for static methods, as
     // there is no holder to check against.
-    interface_template->Set(
-        name, function_template,
-        static_cast<v8::PropertyAttribute>(method.attribute));
+    AddMethodToTemplate(isolate, interface_template, function_template, method);
   }
 }
 
 void InstallMethodInternal(
     v8::Isolate* isolate,
     v8::Local<v8::Object> instance,
     v8::Local<v8::Object> prototype,
     v8::Local<v8::Function> interface,
     v8::Local<v8::Signature> signature,
     const V8DOMConfiguration::MethodConfiguration& method,
@@ skipping 293 matching lines @@
     v8::Isolate* isolate,
     v8::Local<v8::ObjectTemplate> object_template,
     const char* class_string) {
   object_template->Set(
       v8::Symbol::GetToStringTag(isolate),
       V8AtomicString(isolate, class_string),
       static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 }
 
 }  // namespace blink