Fetch: Make Headers' constructor match the current spec IDL.

third_party/WebKit/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 "modules/fetch/Headers.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8IteratorResultValue.h"
+#include "bindings/modules/v8/ByteStringSequenceSequenceOrDictionaryOrHeaders.h"
 #include "core/dom/Iterator.h"
 #include "platform/loader/fetch/FetchUtils.h"
 #include "wtf/NotFound.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 namespace {
@@ skipping 27 matching lines @@
     PairIterable<String, String>::IterationSource::trace(visitor);
   }
 
  private:
   const Member<FetchHeaderList> m_headers;
   size_t m_current;
 };
 
 }  // namespace
 
-Headers* Headers::create() {
+Headers* Headers::create(ExceptionState&) {
   return new Headers;
 }
 
-Headers* Headers::create(ExceptionState&) {
-  return create();
-}
-
-Headers* Headers::create(const Headers* init, ExceptionState& exceptionState) {
+Headers* Headers::create(
+    const ByteStringSequenceSequenceOrDictionaryOrHeaders& init,
+    ExceptionState& exceptionState) {
   // "The Headers(|init|) constructor, when invoked, must run these steps:"
-  // "1. Let |headers| be a new Headers object."
-  Headers* headers = create();
+  // "1. Let |headers| be a new Headers object whose guard is "none".
+  Headers* headers = create(exceptionState);
   // "2. If |init| is given, fill headers with |init|. Rethrow any exception."
-  headers->fillWith(init, exceptionState);
+  if (init.isByteStringSequenceSequence()) {
+    headers->fillWith(init.getAsByteStringSequenceSequence(), exceptionState);
+  } else if (init.isDictionary()) {
+    headers->fillWith(init.getAsDictionary(), exceptionState);
+  } else if (init.isHeaders()) {
+    // This branch will not be necessary once http://crbug.com/690428 is fixed.
+    headers->fillWith(init.getAsHeaders(), exceptionState);
+  }
   // "3. Return |headers|."
   return headers;
 }
-
-Headers* Headers::create(const Vector<Vector<String>>& init,
-                         ExceptionState& exceptionState) {
-  // The same steps as above.
-  Headers* headers = create();
-  headers->fillWith(init, exceptionState);
-  return headers;
-}
-
-Headers* Headers::create(const Dictionary& init,
-                         ExceptionState& exceptionState) {
-  // "The Headers(|init|) constructor, when invoked, must run these steps:"
-  // "1. Let |headers| be a new Headers object."
-  Headers* headers = create();
-  // "2. If |init| is given, fill headers with |init|. Rethrow any exception."
-  headers->fillWith(init, exceptionState);
-  // "3. Return |headers|."
-  return headers;
-}
 
 Headers* Headers::create(FetchHeaderList* headerList) {
   return new Headers(headerList);
 }
 
 Headers* Headers::clone() const {
   FetchHeaderList* headerList = m_headerList->clone();
   Headers* headers = create(headerList);
   headers->m_guard = m_guard;
   return headers;
@@ skipping 141 matching lines @@
   //     header name, return."
   if (m_guard == ResponseGuard &&
       FetchUtils::isForbiddenResponseHeaderName(name))
     return;
   // "6. Set |name|/|value| in header list."
   m_headerList->set(name, value);
 }
 
 void Headers::fillWith(const Headers* object, ExceptionState& exceptionState) {
   ASSERT(m_headerList->size() == 0);
-  // "To fill a Headers object (|this|) with a given object (|object|), run
-  // these steps:"
-  // "1. If |object| is a Headers object, copy its header list as
-  //     |headerListCopy| and then for each |header| in |headerListCopy|,
-  //     retaining order, append header's |name|/|header|'s value to
-  //     |headers|. Rethrow any exception."
+  // There used to be specific steps describing filling a Headers object with
+  // another Headers object, but it has since been removed because it should be
+  // handled like a sequence (http://crbug.com/690428).
   for (size_t i = 0; i < object->m_headerList->list().size(); ++i) {
     append(object->m_headerList->list()[i]->first,
            object->m_headerList->list()[i]->second, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 }
 
 void Headers::fillWith(const Vector<Vector<String>>& object,
                        ExceptionState& exceptionState) {
   ASSERT(!m_headerList->size());
-  // "2. Otherwise, if |object| is a sequence, then for each |header| in
-  //     |object|, run these substeps:
-  //    1. If |header| does not contain exactly two items, throw a
-  //       TypeError.
-  //    2. Append |header|'s first item/|header|'s second item to
-  //       |headers|. Rethrow any exception."
+  // "1. If |object| is a sequence, then for each |header| in |object|, run
+  //     these substeps:
+  //     1. If |header| does not contain exactly two items, then throw a
+  //        TypeError.
+  //     2. Append |header|’s first item/|header|’s second item to |headers|.
+  //        Rethrow any exception."
   for (size_t i = 0; i < object.size(); ++i) {
     if (object[i].size() != 2) {
       exceptionState.throwTypeError("Invalid value");
       return;
     }
     append(object[i][0], object[i][1], exceptionState);
     if (exceptionState.hadException())
       return;
   }
 }
 
 void Headers::fillWith(const Dictionary& object,
                        ExceptionState& exceptionState) {
   ASSERT(!m_headerList->size());
   const Vector<String>& keys = object.getPropertyNames(exceptionState);
   if (exceptionState.hadException() || !keys.size())
     return;
 
-  // "3. Otherwise, if |object| is an open-ended dictionary, then for each
-  //    |header| in object, run these substeps:
-  //    1. Set |header|'s key to |header|'s key, converted to ByteString.
-  //       Rethrow any exception.
-  //    2. Append |header|'s key/|header|'s value to |headers|. Rethrow any
-  //       exception."
-  // FIXME: Support OpenEndedDictionary<ByteString>.
+  // "2. Otherwise, |object| is a record, then for each mapping (|key|,
+  //    |value|) in |object|, append |key|/|value| to |headers|. Rethrow any
+  //    exception."
+  // FIXME: This method's signature must change once we support record<K,V> in

[yhirano, 2017/02/13 05:56:51]

TODO(rakuco):

+  //        the WebIDL code (http://crbug.com/685754).
   for (size_t i = 0; i < keys.size(); ++i) {
     String value;
     if (!DictionaryHelper::get(object, keys[i], value)) {
       exceptionState.throwTypeError("Invalid value");
       return;
     }
     append(keys[i], value, exceptionState);
     if (exceptionState.hadException())
       return;
   }
 }
 
 Headers::Headers()
     : m_headerList(FetchHeaderList::create()), m_guard(NoneGuard) {}
 
 Headers::Headers(FetchHeaderList* headerList)
     : m_headerList(headerList), m_guard(NoneGuard) {}
 
 DEFINE_TRACE(Headers) {
   visitor->trace(m_headerList);
 }
 
 PairIterable<String, String>::IterationSource* Headers::startIteration(
     ScriptState*,
     ExceptionState&) {
   return new HeadersIterationSource(m_headerList);
 }
 
 }  // namespace blink