Add support for URL.searchParams getter.

third_party/WebKit/Source/core/dom/URLSearchParams.cpp

 // Copyright 2015 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 "core/dom/URLSearchParams.h"
 
+#include "core/dom/DOMURL.h"
 #include "platform/network/FormDataEncoder.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextEncoding.h"
 
 namespace blink {
 
 namespace {
 
 class URLSearchParamsIterationSource final : public PairIterable<String, String>::IterationSource {
@@ skipping 22 matching lines @@
 {
     if (init.isUSVString())
         return new URLSearchParams(init.getAsUSVString());
     if (init.isURLSearchParams())
         return new URLSearchParams(init.getAsURLSearchParams());
 
     DCHECK(init.isNull());
     return new URLSearchParams(String());
 }
 
-URLSearchParams::URLSearchParams(const String& queryString)
+URLSearchParams::URLSearchParams(const String& queryString, DOMURL* urlObject)
+    : m_urlObject(urlObject)
 {
     if (!queryString.isEmpty())
         setInput(queryString);
 }
 
 URLSearchParams::URLSearchParams(URLSearchParams* searchParams)
 {
     DCHECK(searchParams);
     m_params = searchParams->m_params;
 }
 
 URLSearchParams::~URLSearchParams()
 {
 }
 
+DEFINE_TRACE(URLSearchParams)
+{
+    visitor->trace(m_urlObject);
+}
+
+#if ENABLE(ASSERT)
+DOMURL* URLSearchParams::urlObject() const
+{
+    return m_urlObject;
+}
+#endif
+
+void URLSearchParams::runUpdateSteps()
+{
+    if (!m_urlObject)
+        return;
+
+    if (m_urlObject->isInUpdate())
+        return;
+
+    m_urlObject->setSearchInternal(toString());
+}
+
 static String decodeString(String input)
 {
     return decodeURLEscapeSequences(input.replace('+', ' '));
 }
 
 void URLSearchParams::setInput(const String& queryString)
 {
-    DCHECK(m_params.isEmpty());
+    m_params.clear();
+
     size_t start = 0;
     size_t 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));
             String value;
             if (endOfName != nameValueEnd)
                 value = decodeString(queryString.substring(endOfName + 1, nameValueEnd - endOfName - 1));
             if (value.isNull())
                 value = "";
             m_params.append(std::make_pair(name, value));
         }
         start = nameValueEnd + 1;
     }
+    runUpdateSteps();
 }
+
 static String encodeString(const String& input)
 {
     return encodeWithURLEscapeSequences(input).replace("%20", "+");
 }
 
 String URLSearchParams::toString() const
 {
     StringBuilder result;
     for (size_t i = 0; i < m_params.size(); ++i) {
         if (i)
             result.append('&');
         result.append(encodeString(m_params[i].first));
         result.append('=');
         result.append(encodeString(m_params[i].second));
     }
     return result.toString();
 }
 
 void URLSearchParams::append(const String& name, const String& value)
 {
     m_params.append(std::make_pair(name, value));
+    runUpdateSteps();
 }
 
 void URLSearchParams::deleteAllWithName(const String& name)
 {
     for (size_t i = 0; i < m_params.size();) {
         if (m_params[i].first == name)
             m_params.remove(i);
         else
             i++;
     }
+    runUpdateSteps();
 }
 
 String URLSearchParams::get(const String& name) const
 {
     for (const auto& param : m_params) {
         if (param.first == name)
             return param.second;
     }
     return String();
 }
@@ skipping 31 matching lines @@
             } else {
                 m_params.remove(i);
             }
         } else {
             i++;
         }
     }
     // Otherwise, append a new name-value pair to the list.
     if (!foundMatch)
         append(name, value);
+    else
+        runUpdateSteps();
 }
 
 PassRefPtr<EncodedFormData> URLSearchParams::encodeFormData() const
 {
     Vector<char> encodedData;
     for (const auto& param : m_params)
         FormDataEncoder::addKeyValuePairAsFormData(encodedData, param.first.utf8(), param.second.utf8(), EncodedFormData::FormURLEncoded);
     return EncodedFormData::create(encodedData.data(), encodedData.size());
 }
 
-DEFINE_TRACE(URLSearchParams)
-{
-}
-
 PairIterable<String, String>::IterationSource* URLSearchParams::startIteration(ScriptState*, ExceptionState&)
 {
     return new URLSearchParamsIterationSource(m_params);
 }
 
 } // namespace blink