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) { }

[haraken, 2015/01/13 12:46:31]

Add explicit.

[Jens Widell, 2015/01/13 12:57:40]

Done.

 
-    HeadersIterator(FetchHeaderList* headers, IterationType type) : m_headers(headers), m_type(type), m_current(0) { }
-
-    virtual ScriptValue next(ScriptState* scriptState, ExceptionState& exception) override
+    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())

[haraken, 2015/01/13 12:46:31]

m_current => m_index

[Jens Widell, 2015/01/13 13:07:22]

Joshua made a similar comment earlier, so I'll just copy my response to that:

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.

-            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();
+        key = header.first;
+        value = header.second;
+        return true;
     }
 
-    virtual ScriptValue next(ScriptState* scriptState, ScriptValue, ExceptionState& exceptionState) override
+    void trace(Visitor* visitor) override
     {
-        return next(scriptState, exceptionState);
-    }
-
-    virtual void trace(Visitor* visitor)
-    {
-        Iterator::trace(visitor);
+        PairIterable<String, String>::IterationSource::trace(visitor);

[haraken, 2015/01/13 12:46:31]

Make this a tail call of trace() (Just a convention.)

[Jens Widell, 2015/01/13 12:57:40]

Done.

         visitor->trace(m_headers);
     }
 
 private:
     const Member<FetchHeaderList> m_headers;
-    const IterationType m_type;
     size_t m_current;
 };
 
 } // namespace
 
 Headers* Headers::create()
 {
     return new Headers;
 }
 
@@ skipping 254 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