Add keys(), values() and entries() methods on iterable<> interfaces

Source/modules/fetch/Headers.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.
 
 #include "config.h"
 #include "modules/fetch/Headers.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8IteratorResultValue.h"
 #include "core/dom/Iterator.h"
 #include "core/fetch/FetchUtils.h"
 #include "wtf/NotFound.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 namespace {
 
-class HeadersIterator final : public Iterator {
+class HeadersIterationSource final : public PairIterable<String, String>::IterationSource {
 public:
-    // Only KeyValue is currently used; the other types are to support
-    // Map-like iteration with entries(), keys() and values(), but this has
-    // not yet been added to any spec.
-    enum IterationType { KeyValue, Key, Value };
+    HeadersIterationSource(FetchHeaderList* headers) : m_headers(headers), m_current(0) { }
 
-    HeadersIterator(FetchHeaderList* headers, IterationType type) : m_headers(headers), m_type(type), m_current(0) { }
-
-    virtual ScriptValue next(ScriptState* scriptState, ExceptionState& exception) override
+    virtual bool next(ScriptState* scriptState, String& key, String& value, ExceptionState& exception) override
     {
         // FIXME: This simply advances an index and returns the next value if
         // any, so if the iterated object is mutated values may be skipped.
         if (m_current >= m_headers->size())
-            return v8IteratorResultDone(scriptState);
+            return false;
 
         const FetchHeaderList::Header& header = m_headers->entry(m_current++);
-        switch (m_type) {
-        case KeyValue: {
-            Vector<String> pair;
-            pair.append(header.first);
-            pair.append(header.second);
-            return v8IteratorResult(scriptState, pair);
-        }
-        case Key:
-            return v8IteratorResult(scriptState, header.first);
-        case Value:
-            return v8IteratorResult(scriptState, header.second);
-        }
-        ASSERT_NOT_REACHED();
-        return ScriptValue();
-    }
-
-    virtual ScriptValue next(ScriptState* scriptState, ScriptValue, ExceptionState& exceptionState) override
-    {
-        return next(scriptState, exceptionState);
+        key = header.first;
+        value = header.second;
+        return true;
     }
 
     virtual void trace(Visitor* visitor)
     {
-        Iterator::trace(visitor);
+        PairIterable<String, String>::IterationSource::trace(visitor);
         visitor->trace(m_headers);
     }
 
 private:
     const Member<FetchHeaderList> m_headers;
-    const IterationType m_type;
     size_t m_current;

[jsbell, 2015/01/12 17:14:08]

Why not use m_index here?

[Jens Widell, 2015/01/12 17:24:14]

There is no m_index in scope here, since we're inheriting PairIterable<>, not
ValueIterable<>, and only ValueIterable<> has its own IterationSource which
tracks an index (since that's implicitly the key.)

That could be changed of course. But there's no guarantee an "iteration source"
uses an index counter to produce values; it could be using some other underlying
iteration mechanism.

 };
 
 } // namespace
 
 Headers* Headers::create()
 {
     return new Headers;
 }
 
 Headers* Headers::create(ExceptionState&)
@@ skipping 253 matching lines @@
     , m_guard(NoneGuard)
 {
 }
 
 Headers::Headers(FetchHeaderList* headerList)
     : m_headerList(headerList)
     , m_guard(NoneGuard)
 {
 }
 
-Iterator* Headers::iterator(ScriptState*, ExceptionState&)
-{
-    return new HeadersIterator(m_headerList, HeadersIterator::KeyValue);
-}
-
 void Headers::trace(Visitor* visitor)
 {
     visitor->trace(m_headerList);
 }
 
+PairIterable<String, String>::IterationSource* Headers::startIteration(ScriptState*, ExceptionState&)
+{
+    return new HeadersIterationSource(m_headerList);
+}
+
 } // namespace blink