LibWeb/IndexedDB: Remove spin_until from waiting for connection closure

Author: Lubrsi

Libraries/LibWeb/CMakeLists.txt

@@ -682,6 +682,7 @@ set(SOURCES
     IndexedDB/IDBVersionChangeEvent.cpp
     IndexedDB/Internal/Algorithms.cpp
     IndexedDB/Internal/Database.cpp
+    IndexedDB/Internal/IDBDatabaseObserver.cpp
     IndexedDB/Internal/IDBRequestObserver.cpp
     IndexedDB/Internal/Index.cpp
     IndexedDB/Internal/Key.cpp

Libraries/LibWeb/Forward.h

@@ -803,6 +803,7 @@ class Database;
 class IDBCursor;
 class IDBCursorWithValue;
 class IDBDatabase;
+class IDBDatabaseObserver;
 class IDBFactory;
 class IDBIndex;
 class IDBKeyRange;

Libraries/LibWeb/IndexedDB/ConnectionState.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024-2025, stelar7 <dudedbz@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+namespace Web::IndexedDB {
+
+enum ConnectionState {
+    Open,
+    Closed,
+};
+
+}

Libraries/LibWeb/IndexedDB/IDBDatabase.cpp

@@ -11,6 +11,7 @@
 #include <LibWeb/IndexedDB/IDBDatabase.h>
 #include <LibWeb/IndexedDB/IDBObjectStore.h>
 #include <LibWeb/IndexedDB/Internal/Algorithms.h>
+#include <LibWeb/IndexedDB/Internal/IDBDatabaseObserver.h>
 
 namespace Web::IndexedDB {
 
@@ -42,6 +43,7 @@ void IDBDatabase::initialize(JS::Realm& realm)
 void IDBDatabase::visit_edges(Visitor& visitor)
 {
     Base::visit_edges(visitor);
+    visitor.visit(m_database_observers_being_notified);
     visitor.visit(m_object_store_set);
     visitor.visit(m_associated_database);
     visitor.visit(m_transactions);
@@ -241,4 +243,24 @@ WebIDL::ExceptionOr<GC::Ref<IDBTransaction>> IDBDatabase::transaction(Variant<St
     return transaction;
 }
 
+void IDBDatabase::register_database_observer(Badge<IDBDatabaseObserver>, IDBDatabaseObserver& database_observer)
+{
+    auto result = m_database_observers.set(database_observer);
+    VERIFY(result == AK::HashSetResult::InsertedNewEntry);
+}
+
+void IDBDatabase::unregister_database_observer(Badge<IDBDatabaseObserver>, IDBDatabaseObserver& database_observer)
+{
+    bool was_removed = m_database_observers.remove(database_observer);
+    VERIFY(was_removed);
+}
+
+void IDBDatabase::set_state(ConnectionState state)
+{
+    m_state = state;
+    notify_each_database_observer([](IDBDatabaseObserver const& request_observer) {
+        return request_observer.connection_state_changed_observer();
+    });
+}
+
 }

Libraries/LibWeb/IndexedDB/IDBDatabase.h

@@ -10,6 +10,7 @@
 #include <LibWeb/Bindings/IDBDatabasePrototype.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/DOMStringList.h>
+#include <LibWeb/IndexedDB/ConnectionState.h>
 #include <LibWeb/IndexedDB/IDBRequest.h>
 #include <LibWeb/IndexedDB/IDBTransaction.h>
 #include <LibWeb/IndexedDB/Internal/Database.h>
@@ -37,19 +38,14 @@ class IDBDatabase : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(IDBDatabase, DOM::EventTarget);
     GC_DECLARE_ALLOCATOR(IDBDatabase);
 
-    enum ConnectionState {
-        Open,
-        Closed,
-    };
-
 public:
     virtual ~IDBDatabase() override;
 
     [[nodiscard]] static GC::Ref<IDBDatabase> create(JS::Realm&, Database&);
 
     void set_version(u64 version) { m_version = version; }
     void set_close_pending(bool close_pending) { m_close_pending = close_pending; }
-    void set_state(ConnectionState state) { m_state = state; }
+    void set_state(ConnectionState state);
 
     [[nodiscard]] String uuid() const { return m_uuid; }
     [[nodiscard]] String name() const { return m_name; }
@@ -84,13 +80,36 @@ class IDBDatabase : public DOM::EventTarget {
     void set_onversionchange(WebIDL::CallbackType*);
     WebIDL::CallbackType* onversionchange();
 
+    void register_database_observer(Badge<IDBDatabaseObserver>, IDBDatabaseObserver&);
+    void unregister_database_observer(Badge<IDBDatabaseObserver>, IDBDatabaseObserver&);
+
 protected:
     explicit IDBDatabase(JS::Realm&, Database&);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor& visitor) override;
 
 private:
+    template<typename GetNotifier, typename... Args>
+    void notify_each_database_observer(GetNotifier&& get_notifier, Args&&... args)
+    {
+        ScopeGuard guard { [&]() { m_database_observers_being_notified.clear_with_capacity(); } };
+        m_database_observers_being_notified.ensure_capacity(m_database_observers.size());
+
+        for (auto observer : m_database_observers)
+            m_database_observers_being_notified.unchecked_append(observer);
+
+        for (auto database_observer : m_database_observers_being_notified) {
+            if (auto notifier = get_notifier(*database_observer))
+                notifier->function()(forward<Args>(args)...);
+        }
+    }
+
+    // IDBDatabase should not visit IDBDatabaseObserver to avoid leaks.
+    // It's responsibility of object that requires IDBDatabaseObserver to keep it alive.
+    HashTable<GC::RawRef<IDBDatabaseObserver>> m_database_observers;
+    Vector<GC::Ref<IDBDatabaseObserver>> m_database_observers_being_notified;
+
     u64 m_version { 0 };
     String m_name;
 

Libraries/LibWeb/IndexedDB/IDBRequest.cpp

@@ -128,7 +128,7 @@ void IDBRequest::unregister_request_observer(Badge<IDBRequestObserver>, IDBReque
 void IDBRequest::set_processed(bool processed)
 {
     m_processed = processed;
-    notify_each_request_observer([&](IDBRequestObserver const& request_observer) {
+    notify_each_request_observer([](IDBRequestObserver const& request_observer) {
         return request_observer.request_processed_changed_observer();
     });
 }

Libraries/LibWeb/IndexedDB/Internal/Algorithms.cpp

@@ -164,51 +164,43 @@ void open_a_database_connection(JS::Realm& realm, StorageAPI::StorageKey storage
                 // 4. If any of the connections in openConnections are still not closed,
                 //    queue a database task to fire a version change event named blocked at request with db’s version and version.
                 for (auto const& entry : open_connections) {
-                    if (entry->state() != IDBDatabase::ConnectionState::Closed) {
+                    if (entry->state() != ConnectionState::Closed) {
                         queue_a_database_task(GC::create_function(realm.vm().heap(), [&realm, entry, db, version]() {
                             fire_a_version_change_event(realm, HTML::EventNames::blocked, *entry, db->version(), version);
                         }));
                     }
                 }
 
                 // 5. Wait until all connections in openConnections are closed.
-                HTML::main_thread_event_loop().spin_until(GC::create_function(realm.vm().heap(), [open_connections]() {
-                    if constexpr (IDB_DEBUG) {
-                        dbgln("open_a_database_connection: waiting for step 10.5");
-                        dbgln("open connections: {}", open_connections.size());
-                        for (auto const& connection : open_connections) {
-                            dbgln("  - {}", connection->uuid());
-                        }
-                    }
-
-                    for (auto const& entry : open_connections) {
-                        if (entry->state() != IDBDatabase::ConnectionState::Closed) {
-                            return false;
-                        }
+                if constexpr (IDB_DEBUG) {
+                    dbgln("open_a_database_connection: waiting for step 10.5");
+                    dbgln("open connections: {}", open_connections.size());
+                    for (auto const& open_connection : open_connections) {
+                        dbgln("  - {}", open_connection->uuid());
                     }
+                }
 
-                    return true;
-                }));
-
-                // 6. Run upgrade a database using connection, version and request.
-                upgrade_a_database(realm, connection, version, request);
+                db->wait_for_connections_to_close(open_connections, GC::create_function(realm.heap(), [&realm, connection, version, request, on_complete] {
+                    // 6. Run upgrade a database using connection, version and request.
+                    upgrade_a_database(realm, connection, version, request);
 
-                // 7. If connection was closed, return a newly created "AbortError" DOMException and abort these steps.
-                if (connection->state() == IDBDatabase::ConnectionState::Closed) {
-                    on_complete->function()(WebIDL::AbortError::create(realm, "Connection was closed"_utf16));
-                    return;
-                }
+                    // 7. If connection was closed, return a newly created "AbortError" DOMException and abort these steps.
+                    if (connection->state() == ConnectionState::Closed) {
+                        on_complete->function()(WebIDL::AbortError::create(realm, "Connection was closed"_utf16));
+                        return;
+                    }
 
-                // 8. If request's error is set, run the steps to close a database connection with connection,
-                //    return a newly created "AbortError" DOMException and abort these steps.
-                if (request->has_error()) {
-                    close_a_database_connection(*connection);
-                    on_complete->function()(WebIDL::AbortError::create(realm, "Upgrade transaction was aborted"_utf16));
-                    return;
-                }
+                    // 8. If request's error is set, run the steps to close a database connection with connection,
+                    //    return a newly created "AbortError" DOMException and abort these steps.
+                    if (request->has_error()) {
+                        close_a_database_connection(*connection);
+                        on_complete->function()(WebIDL::AbortError::create(realm, "Upgrade transaction was aborted"_utf16));
+                        return;
+                    }
 
-                // 11. Return connection.
-                on_complete->function()(connection);
+                    // 11. Return connection.
+                    on_complete->function()(connection);
+                }));
             });
 
             if (task_counter_state) {
@@ -396,7 +388,7 @@ void close_a_database_connection(GC::Ref<IDBDatabase> connection, bool forced)
         return true;
     }));
 
-    connection->set_state(IDBDatabase::ConnectionState::Closed);
+    connection->set_state(ConnectionState::Closed);
 
     // 4. If the forced flag is true, then fire an event named close at connection.
     if (forced)
@@ -535,44 +527,36 @@ void delete_a_database(JS::Realm& realm, StorageAPI::StorageKey storage_key, Str
         auto after_all = GC::create_function(realm.heap(), [&realm, open_connections, db, storage_key = move(storage_key), name = move(name), on_complete] {
             // 8. If any of the connections in openConnections are still not closed, queue a database task to fire a version change event named blocked at request with db’s version and null.
             for (auto const& entry : open_connections) {
-                if (entry->state() != IDBDatabase::ConnectionState::Closed) {
+                if (entry->state() != ConnectionState::Closed) {
                     queue_a_database_task(GC::create_function(realm.vm().heap(), [&realm, entry, db]() {
                         fire_a_version_change_event(realm, HTML::EventNames::blocked, *entry, db->version(), {});
                     }));
                 }
             }
 
             // 9. Wait until all connections in openConnections are closed.
-            HTML::main_thread_event_loop().spin_until(GC::create_function(realm.vm().heap(), [open_connections]() {
-                if constexpr (IDB_DEBUG) {
-                    dbgln("delete_a_database: waiting for step 9");
-                    dbgln("open connections: {}", open_connections.size());
-                    for (auto const& connection : open_connections) {
-                        dbgln("  - {}", connection->uuid());
-                    }
+            if constexpr (IDB_DEBUG) {
+                dbgln("delete_a_database: waiting for step 9");
+                dbgln("open connections: {}", open_connections.size());
+                for (auto const& connection : open_connections) {
+                    dbgln("  - {}", connection->uuid());
                 }
+            }
 
-                for (auto const& entry : open_connections) {
-                    if (entry->state() != IDBDatabase::ConnectionState::Closed) {
-                        return false;
-                    }
+            db->wait_for_connections_to_close(open_connections, GC::create_function(realm.heap(), [&realm, db, storage_key = move(storage_key), name = move(name), on_complete] {
+                // 10. Let version be db’s version.
+                auto version = db->version();
+
+                // 11. Delete db. If this fails for any reason, return an appropriate error (e.g. "QuotaExceededError" or "UnknownError" DOMException).
+                auto maybe_deleted = Database::delete_for_key_and_name(storage_key, name);
+                if (maybe_deleted.is_error()) {
+                    on_complete->function()(WebIDL::OperationError::create(realm, "Unable to delete database"_utf16));
+                    return;
                 }
 
-                return true;
+                // 12. Return version.
+                on_complete->function()(version);
             }));
-
-            // 10. Let version be db’s version.
-            auto version = db->version();
-
-            // 11. Delete db. If this fails for any reason, return an appropriate error (e.g. "QuotaExceededError" or "UnknownError" DOMException).
-            auto maybe_deleted = Database::delete_for_key_and_name(storage_key, name);
-            if (maybe_deleted.is_error()) {
-                on_complete->function()(WebIDL::OperationError::create(realm, "Unable to delete database"_utf16));
-                return;
-            }
-
-            // 12. Return version.
-            on_complete->function()(version);
         });
 
         if (task_counter_state) {