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::deleteItem(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);
+        } else {
+            i += 2;
+        }
+    }
+    ASSERT(!(m_items.size() % 2));
+    return;
+}
+
+FormDataList::EntryValue FormDataList::getItem(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 itemToEntryValue(value);
+    }
+    return EntryValue();
+}
+
+Vector<FormDataList::EntryValue> FormDataList::getAll(const String& key) const
+{
+    Vector<FormDataList::EntryValue> matches;

[sof, 2014/09/12 15:21:26]

Vector => WillBeHeapVector

[jsbell, 2014/09/12 16:30:09]

Done.

+
+    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(itemToEntryValue(value));
+    }
+
+    return matches;
+}
+
+FormDataList::EntryValue FormDataList::itemToEntryValue(const FormDataList::Item& value) const
+{
+    if (!value.blob()) {
+        const CString data = value.data();
+        return EntryValue(m_encoding.decode(data.data(), data.length()));
+    }
+
+    if (value.blob()->isFile()) {
+        // FIXME: Overwrite file's name with value.filename().
+        return EntryValue(toFile(value.blob()));
+    }
+
+    String filename = value.filename();
+    if (filename.isNull())
+        filename = "blob";
+    return EntryValue(File::create(filename, currentTimeMS(), value.blob()->blobDataHandle()));

[tyoshino (SeeGerritForStatus), 2014/09/12 07:29:32]

this looks equivalent to what's specified in the spec. just curious if we should
make the spec also create a File with name="blob" on get(), getAll() or not.
regarding editorial cost, current spec seems shorter than writing that in get(),
getAll() definition.

[jsbell, 2014/09/12 16:30:09]

Thanks! 
In the spec this is done during append/set, when adding the value to the
internal entries list. I'm currently leaving that existing logic alone and doing
the work on extraction from the list, which is why it's more complicated than
the spec.

I should at least add a FIXME to consider moving this to the append/set methods,
and it would simplify Item, and Blob->File conversion should not be a
performance hit. I need figure out how to handle File+filename, though.

+}
+
+bool FormDataList::hasItem(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)
+{
+    setItem(key, Item(blob, filename));
+}
+
+void FormDataList::setData(const String& key, const String& value)
+{
+    setItem(key, encodeAndNormalize(value));
+}
+
+void FormDataList::setItem(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::Item::trace(Visitor* visitor)
 {
     visitor->trace(m_blob);
 }
 
 } // namespace