New FormData methods: get, getAll, has, set, delete and iterable

Source/core/html/FormDataList.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/html/FormDataList.h"
 
 #include "core/fileapi/File.h"
 #include "platform/network/FormDataBuilder.h"
 #include "platform/text/LineEnding.h"
+#include "wtf/CurrentTime.h"
 
 namespace blink {
 
 FormDataList::FormDataList(const WTF::TextEncoding& c)
     : m_encoding(c)
 {
 }
 
 void FormDataList::appendString(const String& string)
 {
-    CString encodedString = m_encoding.encode(string, WTF::EntitiesForUnencodables);
-    m_items.append(normalizeLineEndingsToCRLF(encodedString));
+    m_items.append(encodeAndNormalize(string));
 }
 
 void FormDataList::appendString(const CString& string)
 {
     m_items.append(string);
 }
 
 void FormDataList::appendBlob(PassRefPtrWillBeRawPtr<Blob> blob, const String& filename)
 {
     m_items.append(Item(blob, filename));
 }
 
+void FormDataList::deleteEntry(const String& key)
+{
+    const CString keyData = encodeAndNormalize(key);
+    ASSERT(!(m_items.size() % 2));
+    size_t i = 0;
+    while (i < m_items.size()) {
+        if (m_items[i].data() == keyData) {
+            m_items.remove(i, 2);

[arv (Not doing code reviews), 2014/09/17 19:49:38]

I'm not sure what your plan is to fix this to make iteration behave correctly
when items are removed?

[jsbell, 2014/09/18 16:18:59]

I don't have a firm plan yet. IMHO we should remove the Vector<Item> and use a
Vector<Entry> instead as the definitive storage, which would simplify these new
methods a fair bit, and align more closely with the spec (it would touch the
previously existing code, though, which I was initially trying to avoid). We
could then either follow the model of the ES6 spec and allow 'empty' values in
the list to maintain iteration ordering, or expose the Vector<Entry> itself to
the Iterator object (if WTF Vector iterators behave properly; I haven't checked)

Feedback welcome.

[arv (Not doing code reviews), 2014/09/18 17:33:45]

There are two ways to do this.

1. Keep a list if weak refs to you iterators from the form data. When an item is
removed, update all the iterators.

2. The iterator points to the storage (not the form data). When the storage
changes due to rehash (in your case due to removing holes?) create a new storage
object and an object with the removed indexes. Then when the iterator next
method is called, you check if there is a newer storage version, and if so
transition the iterator and make it point to the newer storage. Once there are
no iterators depending on the storage the storage gets gc'ed (ref counting
should work too). This is what V8 Map/Set does and the main reason for this
approach was so that we did not depend on any weak refs. Take a look at 

+        } else {
+            i += 2;
+        }
+    }
+    ASSERT(!(m_items.size() % 2));
+    return;
+}
+
+FormDataList::Entry FormDataList::getEntry(const String& key) const
+{
+    const CString keyData = encodeAndNormalize(key);
+    const WillBeHeapVector<Item>& items = this->items();
+    size_t formDataListSize = items.size();
+    ASSERT(!(formDataListSize % 2));
+    for (size_t i = 0; i < formDataListSize; i += 2) {
+        const FormDataList::Item& key = items[i];
+        if (key.data() != keyData)
+            continue;
+        const FormDataList::Item& value = items[i + 1];
+        return itemsToEntry(key, value);
+    }
+    return Entry();
+}
+
+FormDataList::Entry FormDataList::getEntry(size_t index) const
+{
+    const WillBeHeapVector<Item>& items = this->items();
+    size_t formDataListSize = items.size();
+    ASSERT(!(formDataListSize % 2));
+    if (index >= formDataListSize / 2)
+        return Entry();
+    const FormDataList::Item& key = items[index * 2];
+    const FormDataList::Item& value = items[index * 2 + 1];
+    return itemsToEntry(key, value);
+}
+
+WillBeHeapVector<FormDataList::Entry> FormDataList::getAll(const String& key) const
+{
+    WillBeHeapVector<FormDataList::Entry> matches;
+
+    const CString keyData = encodeAndNormalize(key);
+    const WillBeHeapVector<Item>& items = this->items();
+    size_t formDataListSize = items.size();
+    ASSERT(!(formDataListSize % 2));
+    for (size_t i = 0; i < formDataListSize; i += 2) {
+        const FormDataList::Item& key = items[i];
+        if (key.data() != keyData)
+            continue;
+        const FormDataList::Item& value = items[i + 1];
+        matches.append(itemsToEntry(key, value));
+    }
+
+    return matches;
+}
+
+FormDataList::Entry FormDataList::itemsToEntry(const FormDataList::Item& key, const FormDataList::Item& value) const
+{
+    const CString nameData = key.data();
+    const String name = m_encoding.decode(nameData.data(), nameData.length());
+
+    if (!value.blob()) {
+        const CString valueData = value.data();
+        return Entry(name, m_encoding.decode(valueData.data(), valueData.length()));
+    }
+
+    // The spec uses the passed filename when inserting entries into the list.
+    // Here, we apply the filename (if present) as an override when extracting
+    // items.
+    // FIXME: Consider applying the name during insertion.
+
+    if (value.blob()->isFile()) {
+        RefPtrWillBeRawPtr<File> file = toFile(value.blob());
+        if (value.filename().isNull())
+            return Entry(name, file);
+        return Entry(name, file->clone(value.filename()));
+    }
+
+    String filename = value.filename();
+    if (filename.isNull())
+        filename = "blob";
+    return Entry(name, File::create(filename, currentTime(), value.blob()->blobDataHandle()));
+}
+
+bool FormDataList::hasEntry(const String& key) const
+{
+    const CString keyData = encodeAndNormalize(key);
+    const WillBeHeapVector<Item>& items = this->items();
+    size_t formDataListSize = items.size();
+    ASSERT(!(formDataListSize % 2));
+    for (size_t i = 0; i < formDataListSize; i += 2) {
+        const FormDataList::Item& key = items[i];
+        if (key.data() == keyData)
+            return true;
+    }
+    return false;
+}
+
+void FormDataList::setBlob(const String& key, PassRefPtrWillBeRawPtr<Blob> blob, const String& filename)
+{
+    setEntry(key, Item(blob, filename));
+}
+
+void FormDataList::setData(const String& key, const String& value)
+{
+    setEntry(key, encodeAndNormalize(value));
+}
+
+void FormDataList::setEntry(const String& key, const Item& item)
+{
+    const CString keyData = encodeAndNormalize(key);
+    ASSERT(!(m_items.size() % 2));
+    bool found = false;
+    size_t i = 0;
+    while (i < m_items.size()) {
+        if (m_items[i].data() != keyData) {
+            i += 2;
+        } else if (found) {
+            m_items.remove(i, 2);
+        } else {
+            found = true;
+            m_items[i + 1] = item;
+            i += 2;
+        }
+    }
+    if (!found) {
+        m_items.append(keyData);
+        m_items.append(item);
+    }
+    ASSERT(!(m_items.size() % 2));
+    return;
+}
+
 PassRefPtr<FormData> FormDataList::createFormData(FormData::EncodingType encodingType)
 {
     RefPtr<FormData> result = FormData::create();
     appendKeyValuePairItemsTo(result.get(), m_encoding, false, encodingType);
     return result.release();
 }
 
 PassRefPtr<FormData> FormDataList::createMultiPartFormData()
 {
     RefPtr<FormData> result = FormData::create();
@@ skipping 72 matching lines @@
             FormDataBuilder::addKeyValuePairAsFormData(encodedData, key.data(), value.data(), encodingType);
         }
     }
 
     if (isMultiPartForm)
         FormDataBuilder::addBoundaryToMultiPartHeader(encodedData, formData->boundary().data(), true);
 
     formData->appendData(encodedData.data(), encodedData.size());
 }
 
+CString FormDataList::encodeAndNormalize(const String& string) const
+{
+    CString encodedString = m_encoding.encode(string, WTF::EntitiesForUnencodables);
+    return normalizeLineEndingsToCRLF(encodedString);
+}
+
 void FormDataList::trace(Visitor* visitor)
 {
     visitor->trace(m_items);
 }
 
+
+void FormDataList::Entry::trace(Visitor* visitor)
+{
+    visitor->trace(m_file);
+}
+
 void FormDataList::Item::trace(Visitor* visitor)
 {
     visitor->trace(m_blob);
 }
 
 } // namespace