ChangeLog

2022-02-19  Chris Dumez  <cdumez@apple.com>

        Optimize DOM storage event dispatch

        https://bugs.webkit.org/show_bug.cgi?id=236871

        Reviewed by NOBODY (OOPS!).

        Made the following optimization to DOM storage event dispatch:

        1. Pass a SecurityOrigin around instead of a SecurityOriginData. Otherwise,

           dispatchLocalStorageEvents() / dispatchSessionStorageEvents() just keep

           reconstructing the SecurityOrigin from the SecurityOriginData for every

           frame.

        2. When gathering the list of frames where we need to dispatch the storage

           event, discard the ones that do not have a "storage" event listener.

        * inspector/InspectorInstrumentation.cpp:

        (WebCore::InspectorInstrumentation::didDispatchDOMStorageEventImpl):

        * inspector/InspectorInstrumentation.h:

        (WebCore::InspectorInstrumentation::didDispatchDOMStorageEvent):

        * inspector/agents/InspectorDOMStorageAgent.cpp:

        (WebCore::InspectorDOMStorageAgent::storageId):

        (WebCore::InspectorDOMStorageAgent::didDispatchDOMStorageEvent):

        (WebCore::InspectorDOMStorageAgent::findStorageArea):

        * inspector/agents/InspectorDOMStorageAgent.h:

        * loader/EmptyClients.cpp:

        * page/DOMWindow.cpp:

        * storage/StorageEventDispatcher.cpp:

        (WebCore::StorageEventDispatcher::dispatchSessionStorageEvents):

        (WebCore::StorageEventDispatcher::dispatchLocalStorageEvents):

        (WebCore::StorageEventDispatcher::dispatchSessionStorageEventsToFrames):

        (WebCore::StorageEventDispatcher::dispatchLocalStorageEventsToFrames):

        * storage/StorageEventDispatcher.h:

        * storage/StorageNamespace.h:

        * storage/StorageNamespaceProvider.cpp:

        (WebCore::StorageNamespaceProvider::localStorageArea):

2022-02-19  Alan Bujtas  <zalan@apple.com>

        [LFC][IFC] Add support for ideographic baseline with font fallback

Source/WebKit/ChangeLog

2022-02-19  Chris Dumez  <cdumez@apple.com>

        Optimize DOM storage event dispatch

        https://bugs.webkit.org/show_bug.cgi?id=236871

        Reviewed by NOBODY (OOPS!).

        Made the following optimization to DOM storage event dispatch:

        1. Pass a SecurityOrigin around instead of a SecurityOriginData. Otherwise,

           dispatchLocalStorageEvents() / dispatchSessionStorageEvents() just keep

           reconstructing the SecurityOrigin from the SecurityOriginData for every

           frame.

        2. When gathering the list of frames where we need to dispatch the storage

           event, discard the ones that do not have a "storage" event listener.

        * WebProcess/WebStorage/StorageAreaMap.cpp:

        (WebKit::StorageAreaMap::StorageAreaMap):

        (WebKit::framesForEventDispatching):

        (WebKit::StorageAreaMap::dispatchSessionStorageEvent):

        (WebKit::StorageAreaMap::dispatchLocalStorageEvent):

        * WebProcess/WebStorage/StorageAreaMap.h:

        * WebProcess/WebStorage/StorageNamespaceImpl.cpp:

        (WebKit::StorageNamespaceImpl::storageArea):

        * WebProcess/WebStorage/StorageNamespaceImpl.h:

2022-02-19  Wenson Hsieh  <wenson_hsieh@apple.com>

        [macOS] Hovering over "Copy Cropped Image" context menu item should reveal the cropped image

Source/WebKitLegacy/ChangeLog

2022-02-19  Chris Dumez  <cdumez@apple.com>

        Optimize DOM storage event dispatch

        https://bugs.webkit.org/show_bug.cgi?id=236871

        Reviewed by NOBODY (OOPS!).

        Made the following optimization to DOM storage event dispatch:

        1. Pass a SecurityOrigin around instead of a SecurityOriginData. Otherwise,

           dispatchLocalStorageEvents() / dispatchSessionStorageEvents() just keep

           reconstructing the SecurityOrigin from the SecurityOriginData for every

           frame.

        2. When gathering the list of frames where we need to dispatch the storage

           event, discard the ones that do not have a "storage" event listener.

        * Storage/StorageAreaImpl.cpp:

        (WebKit::StorageAreaImpl::StorageAreaImpl):

        (WebKit::StorageAreaImpl::create):

        (WebKit::StorageAreaImpl::clearForOriginDeletion):

        (WebKit::StorageAreaImpl::sync):

        (WebKit::StorageAreaImpl::sessionChanged):

        * Storage/StorageAreaImpl.h:

        * Storage/StorageNamespaceImpl.cpp:

        (WebKit::StorageNamespaceImpl::storageArea):

        * Storage/StorageNamespaceImpl.h:

2022-02-09  Sihui Liu  <sihui_liu@apple.com>

        Manage IndexedDB storage by origin

Source/WebCore/inspector/InspectorInstrumentation.cpp

@@void InspectorInstrumentation::didOpenDatabaseImpl(InstrumentingAgents& instrume

        databaseAgent->didOpenDatabase(database);

}

1010 void InspectorInstrumentation::didDispatchDOMStorageEventImpl(InstrumentingAgents& instrumentingAgents, const String& key, const String& oldValue, const String& newValue, StorageType storageType, SecurityOrigin* securityOrigin)

1010void InspectorInstrumentation::didDispatchDOMStorageEventImpl(InstrumentingAgents& instrumentingAgents, const String& key, const String& oldValue, const String& newValue, StorageType storageType, const SecurityOrigin& securityOrigin)

{

    if (auto* domStorageAgent = instrumentingAgents.enabledDOMStorageAgent())

        domStorageAgent->didDispatchDOMStorageEvent(key, oldValue, newValue, storageType, securityOrigin);

Source/WebCore/inspector/InspectorInstrumentation.h

@@public:

    static void didOpenDatabase(Database&);

277 static void didDispatchDOMStorageEvent(Page&, const String& key, const String& oldValue, const String& newValue, StorageType, SecurityOrigin*);

277 static void didDispatchDOMStorageEvent(Page&, const String& key, const String& oldValue, const String& newValue, StorageType, const SecurityOrigin&);

    static bool shouldWaitForDebuggerOnStart(ScriptExecutionContext&);

    static void workerStarted(WorkerInspectorProxy&);

@@private:

    static void didOpenDatabaseImpl(InstrumentingAgents&, Database&);

480 static void didDispatchDOMStorageEventImpl(InstrumentingAgents&, const String& key, const String& oldValue, const String& newValue, StorageType, SecurityOrigin*);

480 static void didDispatchDOMStorageEventImpl(InstrumentingAgents&, const String& key, const String& oldValue, const String& newValue, StorageType, const SecurityOrigin&);

    static bool shouldWaitForDebuggerOnStartImpl(InstrumentingAgents&);

    static void workerStartedImpl(InstrumentingAgents&, WorkerInspectorProxy&);

@@inline void InspectorInstrumentation::didOpenDatabase(Database& database)

        didOpenDatabaseImpl(*agents, database);

}

1328 inline void InspectorInstrumentation::didDispatchDOMStorageEvent(Page& page, const String& key, const String& oldValue, const String& newValue, StorageType storageType, SecurityOrigin* securityOrigin)

1328inline void InspectorInstrumentation::didDispatchDOMStorageEvent(Page& page, const String& key, const String& oldValue, const String& newValue, StorageType storageType, const SecurityOrigin& securityOrigin)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

    didDispatchDOMStorageEventImpl(instrumentingAgents(page), key, oldValue, newValue, storageType, securityOrigin);

Source/WebCore/inspector/agents/InspectorDOMStorageAgent.cpp

@@String InspectorDOMStorageAgent::storageId(Storage& storage)

    ASSERT(window);

    Ref<SecurityOrigin> securityOrigin = document->securityOrigin();

    bool isLocalStorage = window->optionalLocalStorage() == &storage;

171 return InspectorDOMStorageAgent::storageId(securityOrigin~~.ptr()~~, isLocalStorage)->toJSONString();

171 return InspectorDOMStorageAgent::storageId(securityOrigin, isLocalStorage)->toJSONString();

172172}

173173

174 Ref<Protocol::DOMStorage::StorageId> InspectorDOMStorageAgent::storageId(SecurityOrigin* securityOrigin, bool isLocalStorage)

174Ref<Protocol::DOMStorage::StorageId> InspectorDOMStorageAgent::storageId(const SecurityOrigin& securityOrigin, bool isLocalStorage)

175175{

176176 return Protocol::DOMStorage::StorageId::create()

177 .setSecurityOrigin(securityOrigin->toRawString())

177 .setSecurityOrigin(securityOrigin.toRawString())

        .setIsLocalStorage(isLocalStorage)

        .release();

}

182 void InspectorDOMStorageAgent::didDispatchDOMStorageEvent(const String& key, const String& oldValue, const String& newValue, StorageType storageType, SecurityOrigin* securityOrigin)

182void InspectorDOMStorageAgent::didDispatchDOMStorageEvent(const String& key, const String& oldValue, const String& newValue, StorageType storageType, const SecurityOrigin& securityOrigin)

{

    auto id = InspectorDOMStorageAgent::storageId(securityOrigin, storageType == StorageType::Local);

@@RefPtr<StorageArea> InspectorDOMStorageAgent::findStorageArea(Protocol::ErrorStr

    }

    if (!*isLocalStorage)

217 return m_inspectedPage.sessionStorage()->storageArea(targetFrame->document()->securityOrigin()~~.data()~~);

217 return m_inspectedPage.sessionStorage()->storageArea(targetFrame->document()->securityOrigin());

    return m_inspectedPage.storageNamespaceProvider().localStorageArea(*targetFrame->document());

}

Source/WebCore/inspector/agents/InspectorDOMStorageAgent.h

@@public:

    Inspector::Protocol::ErrorStringOr<void> clearDOMStorageItems(Ref<JSON::Object>&& storageId);

    // InspectorInstrumentation

68 void didDispatchDOMStorageEvent(const String& key, const String& oldValue, const String& newValue, StorageType, SecurityOrigin*);

68 void didDispatchDOMStorageEvent(const String& key, const String& oldValue, const String& newValue, StorageType, const SecurityOrigin&);

    // CommandLineAPI

    static String storageId(Storage&);

72 static Ref<Inspector::Protocol::DOMStorage::StorageId> storageId(SecurityOrigin*, bool isLocalStorage);

72 static Ref<Inspector::Protocol::DOMStorage::StorageId> storageId(const SecurityOrigin&, bool isLocalStorage);

private:

    RefPtr<StorageArea> findStorageArea(Inspector::Protocol::ErrorString&, Ref<JSON::Object>&& storageId, Frame*&);

Source/WebCore/loader/EmptyClients.cpp

@@class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {

        {

        }

    private:

501 Ref<StorageArea> storageArea(const SecurityOrigin~~Data~~&) final { return adoptRef(*new EmptyStorageArea); }

501 Ref<StorageArea> storageArea(const SecurityOrigin&) final { return adoptRef(*new EmptyStorageArea); }

        Ref<StorageNamespace> copy(Page&) final { return adoptRef(*new EmptyStorageNamespace { m_sessionID }); }

        PAL::SessionID sessionID() const final { return m_sessionID; }

        void setSessionIDForTesting(PAL::SessionID sessionID) final { m_sessionID = sessionID; };

Source/WebCore/page/DOMWindow.cpp

@@ExceptionOr<Storage*> DOMWindow::sessionStorage()

    if (!page)

        return nullptr;

833 auto storageArea = page->sessionStorage()->storageArea(document->securityOrigin()~~.data()~~);

833 auto storageArea = page->sessionStorage()->storageArea(document->securityOrigin());

    m_sessionStorage = Storage::create(*this, WTFMove(storageArea));

    return m_sessionStorage.get();

}

Source/WebCore/storage/StorageEventDispatcher.cpp

namespace WebCore {

43 void StorageEventDispatcher::dispatchSessionStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin~~Data~~& securityOrigin, Frame* sourceFrame)

43void StorageEventDispatcher::dispatchSessionStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin& securityOrigin, Frame* sourceFrame)

{

    Page* page = sourceFrame->page();

    if (!page)

        return;

49 Vector<Ref~~Ptr~~<Frame>> frames;

49 Vector<Ref<Frame>> frames;

    // Send events only to our page.

    for (Frame* frame = &page->mainFrame(); frame; frame = frame->tree().traverseNext()) {

53 if (!frame->document())

53 if (!frame->document() || !frame->window())

5454 continue;

55 if (sourceFrame != frame && frame->document()->securityOrigin().equal(securityOrigin.securityOrigin().ptr()))

56 frames.append(frame);

        if (!frame->window()->hasEventListeners(eventNames().storageEvent))

            continue;

        if (sourceFrame != frame && frame->document()->securityOrigin().equal(&securityOrigin))

            frames.append(*frame);

    }

    dispatchSessionStorageEventsToFrames(*page, frames, key, oldValue, newValue, sourceFrame->document()->url().string(), securityOrigin);

}

62 void StorageEventDispatcher::dispatchLocalStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin~~Data~~& securityOrigin, Frame* sourceFrame)

64void StorageEventDispatcher::dispatchLocalStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin& securityOrigin, Frame* sourceFrame)

{

    Page* page = sourceFrame->page();

    if (!page)

        return;

68 Vector<Ref~~Ptr~~<Frame>> frames;

70 Vector<Ref<Frame>> frames;

    // Send events to every page.

    for (auto& pageInGroup : page->group().pages()) {

        for (auto* frame = &pageInGroup.mainFrame(); frame; frame = frame->tree().traverseNext()) {

73 if (!frame->document())

            if (!frame->document() || !frame->window())

                continue;

            if (!frame->window()->hasEventListeners(eventNames().storageEvent))

7478 continue;

75 if (sourceFrame != frame && frame->document()->securityOrigin().equal(securityOrigin~~.securityOrigin().ptr()))~~

76 frames.append(frame);

79 if (sourceFrame != frame && frame->document()->securityOrigin().equal(&securityOrigin))

80 frames.append(*frame);

        }

    }

    dispatchLocalStorageEventsToFrames(page->group(), frames, key, oldValue, newValue, sourceFrame->document()->url().string(), securityOrigin);

}

83 void StorageEventDispatcher::dispatchSessionStorageEventsToFrames(Page& page, const Vector<Ref~~Ptr~~<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin~~Data~~& securityOrigin)

87void StorageEventDispatcher::dispatchSessionStorageEventsToFrames(Page& page, const Vector<Ref<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin& securityOrigin)

8488{

85 InspectorInstrumentation::didDispatchDOMStorageEvent(page, key, oldValue, newValue, StorageType::Session, securityOrigin~~.securityOrigin().ptr()~~);

89 InspectorInstrumentation::didDispatchDOMStorageEvent(page, key, oldValue, newValue, StorageType::Session, securityOrigin);

    for (auto& frame : frames) {

        RefPtr document = frame->document();

@@void StorageEventDispatcher::dispatchSessionStorageEventsToFrames(Page& page, co

    }

}

95 void StorageEventDispatcher::dispatchLocalStorageEventsToFrames(PageGroup& pageGroup, const Vector<Ref~~Ptr~~<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin~~Data~~& securityOrigin)

99void StorageEventDispatcher::dispatchLocalStorageEventsToFrames(PageGroup& pageGroup, const Vector<Ref<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin& securityOrigin)

96100{

97101 for (auto& page : pageGroup.pages())

98 InspectorInstrumentation::didDispatchDOMStorageEvent(page, key, oldValue, newValue, StorageType::Local, securityOrigin~~.securityOrigin().ptr()~~);

102 InspectorInstrumentation::didDispatchDOMStorageEvent(page, key, oldValue, newValue, StorageType::Local, securityOrigin);

    for (auto& frame : frames) {

        RefPtr document = frame->document();

Source/WebCore/storage/StorageEventDispatcher.h

@@namespace WebCore {

class Frame;

class Page;

class PageGroup;

39 ~~struct~~ SecurityOrigin~~Data~~;

39class SecurityOrigin;

class StorageEventDispatcher {

public:

43 WEBCORE_EXPORT static void dispatchSessionStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin~~Data~~&, Frame* sourceFrame);

44 WEBCORE_EXPORT static void dispatchLocalStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin~~Data~~&, Frame* sourceFrame);

43 WEBCORE_EXPORT static void dispatchSessionStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin&, Frame* sourceFrame);

44 WEBCORE_EXPORT static void dispatchLocalStorageEvents(const String& key, const String& oldValue, const String& newValue, const SecurityOrigin&, Frame* sourceFrame);

4545

46 WEBCORE_EXPORT static void dispatchSessionStorageEventsToFrames(Page&, const Vector<Ref~~Ptr~~<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin~~Data~~&);

47 WEBCORE_EXPORT static void dispatchLocalStorageEventsToFrames(PageGroup&, const Vector<Ref~~Ptr~~<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin~~Data~~&);

46 WEBCORE_EXPORT static void dispatchSessionStorageEventsToFrames(Page&, const Vector<Ref<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin&);

47 WEBCORE_EXPORT static void dispatchLocalStorageEventsToFrames(PageGroup&, const Vector<Ref<Frame>>& frames, const String& key, const String& oldValue, const String& newValue, const String& url, const SecurityOrigin&);

private:

    // Do not instantiate.

    StorageEventDispatcher();

Source/WebCore/storage/StorageNamespace.h

@@class SessionID;

namespace WebCore {

class Page;

38class SecurityOrigin;

3839class StorageArea;

39 struct SecurityOriginData;

class StorageNamespace : public RefCounted<StorageNamespace> {

public:

    virtual ~StorageNamespace() = default;

44 virtual Ref<StorageArea> storageArea(const SecurityOrigin~~Data~~&) = 0;

44 virtual Ref<StorageArea> storageArea(const SecurityOrigin&) = 0;

    // FIXME: This is only valid for session storage and should probably be moved to a subclass.

    virtual Ref<StorageNamespace> copy(Page& newPage) = 0;

Source/WebCore/storage/StorageNamespaceProvider.cpp

@@Ref<StorageArea> StorageNamespaceProvider::localStorageArea(Document& document)

    else

        storageNamespace = &localStorageNamespace(document.page()->sessionID());

63 return storageNamespace->storageArea(document.securityOrigin()~~.data()~~);

63 return storageNamespace->storageArea(document.securityOrigin());

}

StorageNamespace& StorageNamespaceProvider::localStorageNamespace(PAL::SessionID sessionID)

Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp

#include "WebProcess.h"

#include <WebCore/DOMWindow.h>

#include <WebCore/Document.h>

41#include <WebCore/EventNames.h>

#include <WebCore/Frame.h>

#include <WebCore/Page.h>

#include <WebCore/PageGroup.h>

namespace WebKit {

using namespace WebCore;

53 StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<WebCore::SecurityOrigin>&& securityOrigin)

54StorageAreaMap::StorageAreaMap(StorageNamespaceImpl& storageNamespace, Ref<const WebCore::SecurityOrigin>&& securityOrigin)

    : m_identifier(StorageAreaMapIdentifier::generate())

    , m_namespace(storageNamespace)

    , m_securityOrigin(WTFMove(securityOrigin))

@@void StorageAreaMap::clearCache(uint64_t messageIdentifier)

    resetValues();

}

298 static Vector<Ref~~Ptr~~<Frame>> framesForEventDispatching(Page& page, SecurityOrigin& origin, StorageType storageType, const std::optional<StorageAreaImplIdentifier>& storageAreaImplID)

299static Vector<Ref<Frame>> framesForEventDispatching(Page& page, const SecurityOrigin& origin, StorageType storageType, const std::optional<StorageAreaImplIdentifier>& storageAreaImplID)

299300{

300 Vector<Ref~~Ptr~~<Frame>> frames;

301 Vector<Ref<Frame>> frames;

    page.forEachDocument([&](auto& document) {

        if (!document.securityOrigin().equal(&origin))

            return;

@@static Vector<RefPtr<Frame>> framesForEventDispatching(Page& page, SecurityOrigi

        auto* window = document.domWindow();

        if (!window)

            return;

        if (!window->hasEventListeners(eventNames().storageEvent))

            return;

        
        Storage* storage = nullptr;

        switch (storageType) {

@@static Vector<RefPtr<Frame>> framesForEventDispatching(Page& page, SecurityOrigi

        }

        if (auto* frame = document.frame())

330 frames.append(frame);

334 frames.append(*frame);

    });

    return frames;

}

@@void StorageAreaMap::dispatchSessionStorageEvent(const std::optional<StorageArea

        return;

    auto frames = framesForEventDispatching(*page, m_securityOrigin, StorageType::Session, storageAreaImplID);

348 StorageEventDispatcher::dispatchSessionStorageEventsToFrames(*page, frames, key, oldValue, newValue, urlString, m_securityOrigin~~->data()~~);

352 StorageEventDispatcher::dispatchSessionStorageEventsToFrames(*page, frames, key, oldValue, newValue, urlString, m_securityOrigin);

}

void StorageAreaMap::dispatchLocalStorageEvent(const std::optional<StorageAreaImplIdentifier>& storageAreaImplID, const String& key, const String& oldValue, const String& newValue, const String& urlString)

{

    ASSERT(isLocalStorage(type()));

355 Vector<Ref~~Ptr~~<Frame>> frames;

359 Vector<Ref<Frame>> frames;

    // Namespace IDs for local storage namespaces are currently equivalent to web page group IDs.

    auto& pageGroup = *WebProcess::singleton().webPageGroup(m_namespace.pageGroupID())->corePageGroup();

    for (auto& page : pageGroup.pages())

        frames.appendVector(framesForEventDispatching(page, m_securityOrigin, StorageType::Local, storageAreaImplID));

362 StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin~~->data()~~);

366 StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin);

}

void StorageAreaMap::sendConnectMessage(SendMode mode)

Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h

@@class StorageNamespaceImpl;

class StorageAreaMap final : public IPC::MessageReceiver {

    WTF_MAKE_FAST_ALLOCATED;

public:

53 StorageAreaMap(StorageNamespaceImpl&, Ref<WebCore::SecurityOrigin>&&);

53 StorageAreaMap(StorageNamespaceImpl&, Ref<const WebCore::SecurityOrigin>&&);

    ~StorageAreaMap();

    WebCore::StorageType type() const { return m_type; }

@@private:

    StorageAreaMapIdentifier m_identifier;

    uint64_t m_lastHandledMessageIdentifier { 0 };

    StorageNamespaceImpl& m_namespace;

103 Ref<WebCore::SecurityOrigin> m_securityOrigin;

103 Ref<const WebCore::SecurityOrigin> m_securityOrigin;

    std::unique_ptr<WebCore::StorageMap> m_map;

    std::optional<StorageAreaIdentifier> m_remoteAreaIdentifier;

    HashCountedSet<String> m_pendingValueChanges;

Source/WebKit/WebProcess/WebStorage/StorageNamespaceImpl.cpp

@@void StorageNamespaceImpl::destroyStorageAreaMap(StorageAreaMap& map)

    m_storageAreaMaps.remove(map.securityOrigin().data());

}

103 Ref<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOrigin~~Data~~& securityOrigin~~Data~~)

103Ref<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOrigin& securityOrigin)

104104{

105 auto& map = m_storageAreaMaps.ensure(securityOriginData, [&] {

106 return makeUnique<StorageAreaMap>(*this, securityOrigin~~Data.securityOrigin()~~);

105 auto& map = m_storageAreaMaps.ensure(securityOrigin.data(), [&] {

106 return makeUnique<StorageAreaMap>(*this, securityOrigin);

    }).iterator->value;

    return StorageAreaImpl::create(*map);

}

Source/WebKit/WebProcess/WebStorage/StorageNamespaceImpl.h

@@public:

private:

    StorageNamespaceImpl(WebCore::StorageType, Identifier, const std::optional<WebCore::PageIdentifier>&, WebCore::SecurityOrigin* topLevelOrigin, unsigned quotaInBytes);

70 Ref<WebCore::StorageArea> storageArea(const WebCore::SecurityOrigin~~Data~~&) ~~override~~;

70 Ref<WebCore::StorageArea> storageArea(const WebCore::SecurityOrigin&) final;

    uint64_t storageAreaMapCountForTesting() const final { return m_storageAreaMaps.size(); }

    // FIXME: This is only valid for session storage and should probably be moved to a subclass.

Source/WebKitLegacy/Storage/StorageAreaImpl.cpp

@@StorageAreaImpl::~StorageAreaImpl()

    ASSERT(isMainThread());

}

47 inline StorageAreaImpl::StorageAreaImpl(StorageType storageType, const SecurityOrigin~~Data~~& origin, RefPtr<StorageSyncManager>&& syncManager, unsigned quota)

47inline StorageAreaImpl::StorageAreaImpl(StorageType storageType, const SecurityOrigin& origin, RefPtr<StorageSyncManager>&& syncManager, unsigned quota)

    : m_storageType(storageType)

    , m_securityOrigin(origin)

    , m_storageMap(quota)

@@inline StorageAreaImpl::StorageAreaImpl(StorageType storageType, const SecurityO

    , m_closeDatabaseTimer(*this, &StorageAreaImpl::closeDatabaseTimerFired)

{

    ASSERT(isMainThread());

56

57 // Accessing the shared global StorageTracker when a StorageArea is created

56

57 // Accessing the shared global StorageTracker when a StorageArea is created

    // ensures that the tracker is properly initialized before anyone actually needs to use it.

    StorageTracker::tracker();

}

62 Ref<StorageAreaImpl> StorageAreaImpl::create(StorageType storageType, const SecurityOrigin~~Data~~& origin, RefPtr<StorageSyncManager>&& syncManager, unsigned quota)

62Ref<StorageAreaImpl> StorageAreaImpl::create(StorageType storageType, const SecurityOrigin& origin, RefPtr<StorageSyncManager>&& syncManager, unsigned quota)

{

    Ref<StorageAreaImpl> area = adoptRef(*new StorageAreaImpl(storageType, origin, WTFMove(syncManager), quota));

    // FIXME: If there's no backing storage for LocalStorage, the default WebKit behavior should be that of private browsing,

    // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894

    if (area->m_storageSyncManager) {

68 area->m_storageAreaSync = StorageAreaSync::create(area->m_storageSyncManager.get(), area.copyRef(), area->m_securityOrigin.databaseIdentifier());

68 area->m_storageAreaSync = StorageAreaSync::create(area->m_storageSyncManager.get(), area.copyRef(), area->m_securityOrigin->data().databaseIdentifier());

        ASSERT(area->m_storageAreaSync);

    }

    return area;

@@void StorageAreaImpl::clearForOriginDeletion()

{

    ASSERT(!m_isShutdown);

    blockUntilImportComplete();

206

    m_storageMap.clear();

    if (m_storageAreaSync) {

@@void StorageAreaImpl::clearForOriginDeletion()

        m_storageAreaSync->scheduleCloseDatabase();

    }

}

214

void StorageAreaImpl::sync()

{

    ASSERT(!m_isShutdown);

    blockUntilImportComplete();

219

    if (m_storageAreaSync)

        m_storageAreaSync->scheduleSync();

}

@@void StorageAreaImpl::sessionChanged(bool isNewSessionPersistent)

    m_storageMap.clear();

    if (isNewSessionPersistent && !m_storageAreaSync && m_storageSyncManager) {

290 m_storageAreaSync = StorageAreaSync::create(m_storageSyncManager.get(), *this, m_securityOrigin.databaseIdentifier());

290 m_storageAreaSync = StorageAreaSync::create(m_storageSyncManager.get(), *this, m_securityOrigin->data().databaseIdentifier());

        return;

    }

Source/WebKitLegacy/Storage/StorageAreaImpl.h

@@class StorageAreaSync;

class StorageAreaImpl : public WebCore::StorageArea {

public:

46 static Ref<StorageAreaImpl> create(WebCore::StorageType, const WebCore::SecurityOrigin~~Data~~&, RefPtr<WebCore::StorageSyncManager>&&, unsigned quota);

46 static Ref<StorageAreaImpl> create(WebCore::StorageType, const WebCore::SecurityOrigin&, RefPtr<WebCore::StorageSyncManager>&&, unsigned quota);

    virtual ~StorageAreaImpl();

    unsigned length() override;

@@public:

    void sessionChanged(bool isNewSessionPersistent);

private:

79 StorageAreaImpl(WebCore::StorageType, const WebCore::SecurityOrigin~~Data~~&, RefPtr<WebCore::StorageSyncManager>&&, unsigned quota);

79 StorageAreaImpl(WebCore::StorageType, const WebCore::SecurityOrigin&, RefPtr<WebCore::StorageSyncManager>&&, unsigned quota);

    explicit StorageAreaImpl(const StorageAreaImpl&);

    void blockUntilImportComplete() const;

@@private:

    void dispatchStorageEvent(const String& key, const String& oldValue, const String& newValue, WebCore::Frame* sourceFrame);

    WebCore::StorageType m_storageType;

88 WebCore::SecurityOrigin~~Data~~ m_securityOrigin;

88 Ref<const WebCore::SecurityOrigin> m_securityOrigin;

    WebCore::StorageMap m_storageMap;

    RefPtr<StorageAreaSync> m_storageAreaSync;

Source/WebKitLegacy/Storage/StorageNamespaceImpl.cpp

#include "StorageAreaImpl.h"

#include "StorageSyncManager.h"

#include "StorageTracker.h"

31#include <WebCore/SecurityOrigin.h>

#include <WebCore/StorageMap.h>

#include <WebCore/StorageType.h>

#include <wtf/MainThread.h>

@@Ref<StorageNamespace> StorageNamespaceImpl::copy(Page&)

    return WTFMove(newNamespace);

}

105 Ref<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOrigin~~Data~~& origin)

106Ref<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOrigin& origin)

{

    ASSERT(isMainThread());

    ASSERT(!m_isShutdown);

    if (RefPtr<StorageAreaImpl> storageArea = m_storageAreaMap.get(origin))

        return storageArea.releaseNonNull();

    auto storageArea = StorageAreaImpl::create(m_storageType, origin, m_syncManager.get(), m_quota);

    m_storageAreaMap.set(origin, storageArea.ptr());

    return WTFMove(storageArea);

    return *m_storageAreaMap.ensure(origin.data(), [&] {

        return StorageAreaImpl::create(m_storageType, origin, m_syncManager.get(), m_quota);

    }).iterator->value;

}

void StorageNamespaceImpl::close()

Source/WebKitLegacy/Storage/StorageNamespaceImpl.h

@@namespace WebKit {

class StorageAreaImpl;

40 class StorageNamespaceImpl : public WebCore::StorageNamespace {

40class StorageNamespaceImpl final : public WebCore::StorageNamespace {

public:

    static Ref<StorageNamespaceImpl> createSessionStorageNamespace(unsigned quota, PAL::SessionID);

    static Ref<StorageNamespaceImpl> getOrCreateLocalStorageNamespace(const String& databasePath, unsigned quota, PAL::SessionID);

@@public:

    void sync();

    void closeIdleLocalStorageDatabases();

57 PAL::SessionID sessionID() const ~~override~~ { return m_sessionID; }

58 void setSessionIDForTesting(PAL::SessionID) ~~override~~;

57 PAL::SessionID sessionID() const final { return m_sessionID; }

58 void setSessionIDForTesting(PAL::SessionID) final;

private:

    StorageNamespaceImpl(WebCore::StorageType, const String& path, unsigned quota, PAL::SessionID);

63 Ref<WebCore::StorageArea> storageArea(const WebCore::SecurityOrigin~~Data~~&) ~~override~~;

64 Ref<StorageNamespace> copy(WebCore::Page& newPage) ~~override~~;

63 Ref<WebCore::StorageArea> storageArea(const WebCore::SecurityOrigin&) final;

64 Ref<StorageNamespace> copy(WebCore::Page& newPage) final;

    typedef HashMap<WebCore::SecurityOriginData, RefPtr<StorageAreaImpl>> StorageAreaMap;

    StorageAreaMap m_storageAreaMap;