Make pair iterators inherit from %IteratorPrototype%.

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

 {% filter format_blink_cpp_source_code %}
 
 {% include 'copyright_block.txt' %}
 #include "{{v8_class_or_partial}}.h"
 
 {% for filename in cpp_includes if filename != '%s.h' % cpp_class_or_partial %}
 #include "{{filename}}"
 {% endfor %}
 
 namespace blink {
@@ skipping 514 matching lines @@
   {% if iterator_method %}
   {% filter exposed(iterator_method.exposed_test) %}
   {% filter runtime_enabled(iterator_method.runtime_enabled_feature_name) %}
   // Iterator (@@iterator)
   static const V8DOMConfiguration::SymbolKeyedMethodConfiguration symbolKeyedIteratorConfiguration = { v8::Symbol::GetIterator, {{v8_class_or_partial}}::iteratorMethodCallback, 0, v8::DontEnum, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess };
   V8DOMConfiguration::InstallMethod(isolate, world, prototypeTemplate, signature, symbolKeyedIteratorConfiguration);
   {% endfilter %}
   {% endfilter %}
   {% endif %}
 
+  {% if interface_name == 'Iterator' %}
+  // The WebIDL spec says when an interface has pair iterators the iterators it
+  // returns must be instances of the "default iterator object" whose
+  // [[Prototype]] points to an "iterator prototype object" whose
+  // [[Prototype]], on its turn, points to %IteratorPrototype%. next() must be
+  // implemented in the "iterator prototype object", while %IteratorPrototype%
+  // provides @@iterator.
+  // References:
+  // https://heycam.github.io/webidl/#es-default-iterator-object
+  // https://heycam.github.io/webidl/#es-iterator-prototype-object
+  //
+  // The iterators we return from interfaces that have pair interators adhere
+  // to the above by:
+  // - Adding the "next()" property to its prototype object.
+  // - Making the prototype object inherit from %IteratorPrototype% with the
+  //   hack below, which creates another function template with no prototype
+  //   and sets the "prototype" property of its function object.
+  //   When |interfaceTemplate|'s function object is created, its
+  //   prototype.__proto__ will point to the value of the "prototype" property
+  //   of |iteratorPrototypeTemplate|, which is exactly what we want.
+  //
+  // Finally, creating a FunctionTemplate here might look expensive since they
+  // have the same lifetime as their context, but:
+  // - |interfaceTemplate| is cached in V8PerIsolateData, so we create only one
+  //   FunctionTemplate per interface.
+  // - There is only one Iterator interface that creates this FunctionTemplate,
+  //   so there is no need to reuse this FunctionTemplate and register it in
+  //   V8PerIsolateData.
+  v8::Local<v8::FunctionTemplate> intrinsicIteratorPrototypeInterfaceTemplate =
+      v8::FunctionTemplate::New(isolate);
+  intrinsicIteratorPrototypeInterfaceTemplate->RemovePrototype();
+  intrinsicIteratorPrototypeInterfaceTemplate->SetIntrinsicDataProperty(
+      V8AtomicString(isolate, "prototype"), v8::kIteratorPrototype);
+  interfaceTemplate->Inherit(intrinsicIteratorPrototypeInterfaceTemplate);
+  {% endif %}
+
   {% if interface_name == 'Location' %}
   // Symbol.toPrimitive
   // Prevent author scripts to inject Symbol.toPrimitive property into location
   // objects, also prevent the look-up of Symbol.toPrimitive through the
   // prototype chain.
   instanceTemplate->Set(v8::Symbol::GetToPrimitive(isolate),
                         v8::Undefined(isolate),
                         static_cast<v8::PropertyAttribute>(
                             v8::ReadOnly | v8::DontEnum | v8::DontDelete));
   {% endif %}
@@ skipping 210 matching lines @@
 {% endif %}
 }
 {% endif %}
 
 {% endblock %}
 {##############################################################################}
 {% block partial_interface %}{% endblock %}
 }  // namespace blink
 
 {% endfilter %}{# format_blink_cpp_source_code #}