IDL: Add forEach() method to iterable<>/maplike<>/setlike<> interfaces

Source/core/dom/Iterable.h

 // Copyright 2015 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.
 
 #ifndef Iterable_h
 #define Iterable_h
 
 #include "bindings/core/v8/V8IteratorResultValue.h"
+#include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Iterator.h"
 
 namespace blink {
 
 // Typically, use one of ValueIterable<> and PairIterable<> (below) instead!
 template <typename KeyType, typename ValueType>
 class Iterable {
 public:
     Iterator* keys(ScriptState* scriptState, ExceptionState& exceptionState)
     {
@@ skipping 12 matching lines @@
     }
 
     Iterator* entries(ScriptState* scriptState, ExceptionState& exceptionState)
     {
         IterationSource* source = this->startIteration(scriptState, exceptionState);
         if (!source)
             return nullptr;
         return new IterableIterator<EntrySelector>(source);
     }
 
+    void forEach(ScriptState* scriptState, const ScriptValue& thisValue, const ScriptValue& callback, const ScriptValue& thisArg, ExceptionState& exceptionState)
+    {
+        IterationSource* source = this->startIteration(scriptState, exceptionState);
+
+        v8::Isolate* isolate = scriptState->isolate();
+
+        v8::Context::Scope contextScope(scriptState->context());
+        v8::HandleScope handleScope(isolate);

[yhirano, 2015/01/23 11:49:03]

Can you tell me why v8::Context::Scope is necessary here?

[Jens Widell, 2015/01/23 11:53:55]

I don't know that it is, to be honest. I put it here because V8ScriptRunner.h
has this comment:

  // For the following methods, the caller sites have to hold
  // a HandleScope and a ContextScope.

[haraken, 2015/01/23 11:55:39]

Given that forEach is always called from JavaScript, we should already be in a
correct ContextScope and have a HandleScope. Thus I guess we won't need either
of them.

[Jens Widell, 2015/01/23 11:58:14]

Yeah, that makes sense.

+        v8::TryCatch tryCatch(isolate);
+
+        v8::Local<v8::Object> creationContext(scriptState->context()->Global());
+        v8::Local<v8::Function> v8Callback(callback.v8Value().As<v8::Function>());
+        v8::Local<v8::Value> v8ThisArg(thisArg.v8Value());
+        v8::Local<v8::Value> args[3];
+
+        args[2] = thisValue.v8Value();
+
+        while (true) {
+            KeyType key;
+            ValueType value;
+
+            if (!source->next(scriptState, key, value, exceptionState))
+                return;
+
+            ASSERT(!exceptionState.hadException());
+
+            args[0] = toV8(value, creationContext, isolate);
+            args[1] = toV8(key, creationContext, isolate);
+
+            V8ScriptRunner::callFunction(v8Callback, scriptState->executionContext(), v8ThisArg, 3, args, isolate);
+
+            if (tryCatch.HasCaught()) {
+                exceptionState.rethrowV8Exception(tryCatch.Exception());
+                return;
+            }
+        }
+    }
+
     class IterationSource : public GarbageCollectedFinalized<IterationSource> {
     public:
         virtual ~IterationSource() { }
 
         // If end of iteration has been reached or an exception thrown: return false.
         // Otherwise: set |key| and |value| and return true.
         virtual bool next(ScriptState*, KeyType&, ValueType&, ExceptionState&) = 0;
 
         virtual void trace(Visitor*) { }
     };
@@ skipping 105 matching lines @@
 public:
     Iterator* iterator(ScriptState* scriptState, ExceptionState& exceptionState)
     {
         return this->entries(scriptState, exceptionState);
     }
 };
 
 } // namespace blink
 
 #endif // Iterable_h