LibWeb: Implement CookieStore::get(options)

Libraries/LibWeb/CookieStore/CookieStore.cpp

@@ -5,11 +5,13 @@
  */
 
 #include <LibJS/Runtime/Array.h>
+#include <LibURL/Parser.h>
 #include <LibWeb/Bindings/CookieStorePrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/CookieStore/CookieStore.h>
 #include <LibWeb/HTML/Scripting/Environments.h>
 #include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
+#include <LibWeb/HTML/Window.h>
 #include <LibWeb/Page/Page.h>
 #include <LibWeb/Platform/EventLoopPlugin.h>
 #include <LibWeb/WebIDL/DOMException.h>
@@ -130,6 +132,78 @@ GC::Ref<WebIDL::Promise> CookieStore::get(String name)
     return promise;
 }
 
+// https://cookiestore.spec.whatwg.org/#dom-cookiestore-get-options
+GC::Ref<WebIDL::Promise> CookieStore::get(CookieStoreGetOptions const& options)
+{
+    auto& realm = this->realm();
+
+    // 1. Let settings be this’s relevant settings object.
+    auto const& settings = HTML::relevant_settings_object(*this);
+
+    // 2. Let origin be settings’s origin.
+    auto const& origin = settings.origin();
+
+    // 3. If origin is an opaque origin, then return a promise rejected with a "SecurityError" DOMException.
+    if (origin.is_opaque())
+        return WebIDL::create_rejected_promise(realm, WebIDL::SecurityError::create(realm, "Document origin is opaque"_string));
+
+    // 4. Let url be settings’s creation URL.
+    auto url = settings.creation_url;
+
+    // 5. If options is empty, then return a promise rejected with a TypeError.
+    if (!options.name.has_value() && !options.url.has_value())
+        return WebIDL::create_rejected_promise(realm, JS::TypeError::create(realm, "CookieStoreGetOptions is empty"sv));
+
+    // 6. If options["url"] is present, then run these steps:
+    if (options.url.has_value()) {
+        // 1. Let parsed be the result of parsing options["url"] with settings’s API base URL.
+        auto parsed = URL::Parser::basic_parse(options.url.value(), settings.api_base_url());
+
+        // AD-HOC: This isn't explicitly mentioned in the specification, but we have to reject invalid URLs as well
+        if (!parsed.has_value())
+            return WebIDL::create_rejected_promise(realm, JS::TypeError::create(realm, "url is invalid"sv));
+
+        // 2. If this’s relevant global object is a Window object and parsed does not equal url with exclude fragments
+        //    set to true, then return a promise rejected with a TypeError.
+        if (is<HTML::Window>(HTML::relevant_global_object(*this)) && !parsed->equals(url, URL::ExcludeFragment::Yes))
+            return WebIDL::create_rejected_promise(realm, JS::TypeError::create(realm, "url does not match creation URL"sv));
+
+        // 3. If parsed’s origin and url’s origin are not the same origin, then return a promise rejected with a TypeError.
+        if (parsed->origin() != url.origin())
+            return WebIDL::create_rejected_promise(realm, JS::TypeError::create(realm, "url's origin does not match creation URL's origin"sv));
+
+        // 4. Set url to parsed.
+        url = parsed.value();
+    }
+
+    // 7. Let p be a new promise.
+    auto promise = WebIDL::create_promise(realm);
+
+    // 8. Run the following steps in parallel:
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, client = m_client, promise, url = move(url), name = options.name]() {
+        // 1. Let list be the results of running query cookies with url and options["name"] (if present).
+        auto list = query_cookies(client, url, name);
+
+        // AD-HOC: Queue a global task to perform the next steps
+        // Spec issue: https://github.com/whatwg/cookiestore/issues/239
+        queue_global_task(HTML::Task::Source::Unspecified, realm.global_object(), GC::create_function(realm.heap(), [&realm, promise, list = move(list)]() {
+            HTML::TemporaryExecutionContext execution_context { realm };
+            // 2. If list is failure, then reject p with a TypeError and abort these steps.
+
+            // 3. If list is empty, then resolve p with null.
+            if (list.is_empty())
+                WebIDL::resolve_promise(realm, promise, JS::js_null());
+
+            // 4. Otherwise, resolve p with the first item of list.
+            else
+                WebIDL::resolve_promise(realm, promise, Bindings::cookie_list_item_to_value(realm, list[0]));
+        }));
+    }));
+
+    // 9. Return p.
+    return promise;
+}
+
 static JS::Value cookie_list_to_value(JS::Realm& realm, Vector<CookieListItem> const& cookie_list)
 {
     return JS::Array::create_from<CookieListItem>(realm, cookie_list, [&](auto const& cookie) {

Libraries/LibWeb/CookieStore/CookieStore.h

@@ -19,6 +19,12 @@ struct CookieListItem {
     Optional<String> value;
 };
 
+// https://cookiestore.spec.whatwg.org/#dictdef-cookiestoregetoptions
+struct CookieStoreGetOptions {
+    Optional<String> name;
+    Optional<String> url;
+};
+
 // https://cookiestore.spec.whatwg.org/#cookiestore
 class CookieStore final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(CookieStore, DOM::EventTarget);
@@ -26,6 +32,7 @@ class CookieStore final : public DOM::EventTarget {
 
 public:
     GC::Ref<WebIDL::Promise> get(String name);
+    GC::Ref<WebIDL::Promise> get(CookieStoreGetOptions const&);
 
     GC::Ref<WebIDL::Promise> get_all(String name);
 

Libraries/LibWeb/CookieStore/CookieStore.idl

@@ -11,10 +11,16 @@ dictionary CookieListItem {
 
 typedef sequence<CookieListItem> CookieList;
 
+dictionary CookieStoreGetOptions {
+    USVString name;
+    USVString url;
+};
+
 // https://cookiestore.spec.whatwg.org/#cookiestore
 [Exposed=(ServiceWorker,Window), SecureContext]
 interface CookieStore : EventTarget {
     Promise<CookieListItem?> get(USVString name);
+    Promise<CookieListItem?> get(optional CookieStoreGetOptions options = {});
 
     Promise<CookieList> getAll(USVString name);
 };