Implement URLSearchParams.

Source/core/dom/DOMURLSearchParams.cpp

+/*
+ * Copyright (c) 2014, Opera Software ASA. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of Opera Software ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/dom/DOMURLSearchParams.h"
+
+#include "core/dom/DOMURLUtils.h"
+#include "platform/weborigin/KURL.h"
+#include "wtf/text/StringBuilder.h"
+#include "wtf/text/TextEncoding.h"
+
+namespace WebCore {
+
+DOMURLSearchParams::DOMURLSearchParams()
+    : m_urlObject(0)
+    , m_isUpdating(false)
+{
+    ScriptWrappable::init(this);
+}
+
+void DOMURLSearchParams::ref()
+{
+    if (m_urlObject)
+        m_urlObject->refURLUtils();
+}
+
+void DOMURLSearchParams::deref()
+{
+    if (m_urlObject)
+        m_urlObject->derefURLUtils();
+}
+
+void DOMURLSearchParams::runUpdateSteps()
+{
+    if (m_urlObject) {
+        m_isUpdating = true;
+        DOMURLUtils::setSearch(m_urlObject, toString());
+        m_isUpdating = false;
+    }
+}
+
+static String decodeString(String input)
+{
+    return decodeURLEscapeSequences(input.replace('+', ' '));
+}
+
+void DOMURLSearchParams::setInput(const String& queryString)
+{
+    if (m_isUpdating)
+        return;
+
+    m_params.clear();
+    unsigned start = 0;
+    unsigned queryStringLength = queryString.length();
+    while (start < queryStringLength) {
+        size_t nameStart = start;
+        size_t nameValueEnd = queryString.find('&', start);
+        if (nameValueEnd == kNotFound)
+            nameValueEnd = queryStringLength;
+
+        if (nameValueEnd > start) {
+            size_t endOfName = queryString.find('=', start);
+
+            if (endOfName == kNotFound || endOfName > nameValueEnd)
+                endOfName = nameValueEnd;
+
+            String name = decodeString(queryString.substring(nameStart, endOfName - nameStart));
+
+            bool validUTF8 = true;
+            if (!name.isEmpty()) {
+                name = name.utf8(StrictUTF8Conversion).data();
+                validUTF8 = !name.isEmpty();
+            }
+
+            String value;
+            if (validUTF8 && endOfName != nameValueEnd) {
+                value = decodeString(queryString.substring(endOfName + 1, nameValueEnd - endOfName - 1));
+                if (!value.isEmpty()) {
+                    value = value.utf8(StrictUTF8Conversion).data();
+                    validUTF8 = !value.isEmpty();
+                }
+            }
+            if (validUTF8 && value.isNull())
+                value = "";
+
+            if (validUTF8)
+                m_params.append(std::make_pair(name, value));
+        }
+        start = nameValueEnd + 1;
+    }
+}
+
+PassRefPtr<DOMURLSearchParams> DOMURLSearchParams::create(const String& queryString)
+{
+    RefPtr<DOMURLSearchParams> searchParams = adoptRef(new DOMURLSearchParams());

[arv (Not doing code reviews), 2014/01/21 14:40:33]

We usually create a matching constructor and then have the create function just
in the .h file forward to that

static PassRefPtr<URLQuery> create(const String& queryString
{
    return adoptRef(new URLQuery(queryString);
}
static PassRefPtr<URLQuery> create(const DOMURLSearchParams& init
{
    return adoptRef(new URLQuery(init);
}

[sof, 2014/01/21 21:16:47]

That's quite doable..and done.

+    if (queryString.isEmpty())
+        return searchParams.release();
+
+    searchParams->setInput(queryString);
+    return searchParams.release();
+}
+
+PassRefPtr<DOMURLSearchParams> DOMURLSearchParams::create(DOMURLSearchParams* init)
+{
+    RefPtr<DOMURLSearchParams> searchParams = adoptRef(new DOMURLSearchParams());
+    if (!init)

[arv (Not doing code reviews), 2014/01/21 14:40:33]

Can this happen? Should we throw an exception if so?

[sof, 2014/01/21 21:16:47]

Typically yes, a TypeError due to failed object conversion. But we can delegate
exception handling to the "super constructor" that handles URLSearchParams
overload resolution -- I notice the generated version wasn't quite right, so
ended up writing a custom one.

+        return searchParams.release();
+
+    searchParams->m_params = init->m_params;
+    return searchParams.release();
+}
+
+static String encodeString(const String& input)
+{
+    String escaped = encodeWithURLEscapeSequences(input);
+    // Encode "%20" as "*"; as required and much prettier.

[arv (Not doing code reviews), 2014/01/21 14:40:33]

Useless comment

[sof, 2014/01/21 21:16:47]

Gone.

+    return escaped.replace("%20", "+");
+}
+
+String DOMURLSearchParams::toString() const
+{
+    StringBuilder result;
+    bool isFirst = true;
+    for (Vector<std::pair<String, String> >::const_iterator it = m_params.begin(); it != m_params.end(); ++it) {

[arv (Not doing code reviews), 2014/01/21 14:40:33]

for (int i = 0; i < m_params.size(); ++i) {

ends up being cleaner since you can then skip isFirst

[sof, 2014/01/21 21:16:47]

Yep, thanks

+        String name = encodeString(it->first);
+        if (!name.isEmpty()) {
+            if (!isFirst)
+                result.append('&');
+            else
+                isFirst = false;
+
+            result.append(name);
+            String value = encodeString(it->second);
+            if (!value.isEmpty()) {

[arv (Not doing code reviews), 2014/01/21 14:40:33]

This does not look correct to me. We should always print "=".

http://url.spec.whatwg.org/#concept-urlencoded-serializer

[sof, 2014/01/21 21:16:47]

Oops, quite right. Fixed + adjusted expected test outcomes.

+                result.append('=');
+                result.append(value);
+            }
+        }
+    }
+    return result.toString();
+}
+
+void DOMURLSearchParams::appendNameValue(const String& name, const String& value)
+{
+    m_params.append(std::make_pair(name, value));
+    runUpdateSteps();
+}
+
+void DOMURLSearchParams::deleteAllWithName(const String& name)
+{
+    for (unsigned i = 0; i < m_params.size();) {
+        if (m_params[i].first == name)
+            m_params.remove(i);
+        else
+            i++;
+    }
+    runUpdateSteps();
+}
+
+String DOMURLSearchParams::getFirstValue(const String& name) const
+{
+    for (Vector<std::pair<String, String> >::const_iterator it = m_params.begin(); it != m_params.end(); ++it) {
+        if (it->first == name)
+            return it->second;
+    }
+    return String();
+}
+
+Vector<String> DOMURLSearchParams::getAllValues(const String& name) const
+{
+    Vector<String> result;
+    for (Vector<std::pair<String, String> >::const_iterator it = m_params.begin(); it != m_params.end(); ++it) {
+        if (it->first == name)
+            result.append(it->second);
+    }
+    return result;
+}
+
+bool DOMURLSearchParams::hasName(const String& name) const
+{
+    for (Vector<std::pair<String, String> >::const_iterator it = m_params.begin(); it != m_params.end(); ++it) {
+        if (it->first == name)
+            return true;
+    }
+    return false;
+}
+
+void DOMURLSearchParams::setNameValue(const String& name, const String& value)
+{
+    bool foundMatch = false;
+    for (unsigned i = 0; i < m_params.size();) {
+        if (m_params[i].first == name) {
+            if (!foundMatch) {
+                m_params[i++].second = value;
+                foundMatch = true;
+            } else {
+                m_params.remove(i);
+            }
+        } else {
+            i++;
+        }
+    }
+    if (!foundMatch)
+        appendNameValue(name, value);
+    else
+        runUpdateSteps();
+}
+
+} // namespace WebCore