⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 245943 in webkit


Ignore:
Timestamp:
May 30, 2019, 7:19:12 PM (7 years ago)
Author:
sihui_liu@apple.com
Message:

WKWebsiteDataStore API fails to fetch web storage data for non-persistent data store
​https://bugs.webkit.org/show_bug.cgi?id=198317
Source/WebKit:

<rdar://problem/51244662>

Reviewed by Alex Christensen.

Use LocalStorageNameSpace instead of SessionStorageNameSpace for localStorage in ephemeral session or
websiteDataStore.

  • NetworkProcess/WebStorage/StorageManager.cpp:

(WebKit::StorageManager::StorageArea::isEphemeral const):
(WebKit::StorageManager::StorageArea::removeListener):
(WebKit::StorageManager::StorageArea::setItems):
(WebKit::StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded const):
(WebKit::StorageManager::LocalStorageNamespace::~LocalStorageNamespace):
(WebKit::StorageManager::LocalStorageNamespace::getOrCreateStorageArea):
(WebKit::StorageManager::LocalStorageNamespace::clearAllStorageAreas):
(WebKit::StorageManager::LocalStorageNamespace::ephemeralOrigins const):
(WebKit::StorageManager::LocalStorageNamespace::cloneTo):
(WebKit::StorageManager::StorageManager):
(WebKit::StorageManager::cloneSessionStorageNamespace):
(WebKit::StorageManager::getLocalStorageOrigins):
(WebKit::StorageManager::getLocalStorageOriginDetails):
(WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
(WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
(WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):
(WebKit::StorageManager::createLocalStorageMap):
(WebKit::StorageManager::createTransientLocalStorageMap):
(WebKit::StorageManager::createSessionStorageMap):
(WebKit::StorageManager::destroyStorageMap):
(WebKit::StorageManager::getValues):
(WebKit::StorageManager::setItem):
(WebKit::StorageManager::removeItem):
(WebKit::StorageManager::clear):
(WebKit::StorageManager::suspend):
(WebKit::StorageManager::resume):
(WebKit::StorageManager::StorageArea::isSessionStorage const): Deleted.

  • NetworkProcess/WebStorage/StorageManager.h:

(): Deleted.

  • WebProcess/WebStorage/StorageAreaMap.cpp:

(WebKit::StorageAreaMap::dispatchStorageEvent):
(WebKit::StorageAreaMap::dispatchSessionStorageEvent):
(WebKit::StorageAreaMap::connect):

  • WebProcess/WebStorage/StorageNamespaceImpl.cpp:

(WebKit::StorageNamespaceImpl::createEphemeralLocalStorageNamespace):
(WebKit::StorageNamespaceImpl::createLocalStorageNamespace):

  • WebProcess/WebStorage/StorageNamespaceImpl.h:
  • WebProcess/WebStorage/WebStorageNamespaceProvider.cpp:

(WebKit::WebStorageNamespaceProvider::createLocalStorageNamespace):

Tools:

Reviewed by Alex Christensen.

  • TestWebKitAPI/Tests/WebKitCocoa/WKWebsiteDatastore.mm:

(TestWebKitAPI::TEST):

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r245913 r245943  
     12019-05-30  Sihui Liu  <sihui_liu@apple.com>
     2
     3        WKWebsiteDataStore API fails to fetch web storage data for non-persistent data store
     4        https://bugs.webkit.org/show_bug.cgi?id=198317
     5        <rdar://problem/51244662>
     6
     7        Reviewed by Alex Christensen.
     8
     9        Use LocalStorageNameSpace instead of SessionStorageNameSpace for localStorage in ephemeral session or
     10        websiteDataStore.
     11
     12        * NetworkProcess/WebStorage/StorageManager.cpp:
     13        (WebKit::StorageManager::StorageArea::isEphemeral const):
     14        (WebKit::StorageManager::StorageArea::removeListener):
     15        (WebKit::StorageManager::StorageArea::setItems):
     16        (WebKit::StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded const):
     17        (WebKit::StorageManager::LocalStorageNamespace::~LocalStorageNamespace):
     18        (WebKit::StorageManager::LocalStorageNamespace::getOrCreateStorageArea):
     19        (WebKit::StorageManager::LocalStorageNamespace::clearAllStorageAreas):
     20        (WebKit::StorageManager::LocalStorageNamespace::ephemeralOrigins const):
     21        (WebKit::StorageManager::LocalStorageNamespace::cloneTo):
     22        (WebKit::StorageManager::StorageManager):
     23        (WebKit::StorageManager::cloneSessionStorageNamespace):
     24        (WebKit::StorageManager::getLocalStorageOrigins):
     25        (WebKit::StorageManager::getLocalStorageOriginDetails):
     26        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
     27        (WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
     28        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):
     29        (WebKit::StorageManager::createLocalStorageMap):
     30        (WebKit::StorageManager::createTransientLocalStorageMap):
     31        (WebKit::StorageManager::createSessionStorageMap):
     32        (WebKit::StorageManager::destroyStorageMap):
     33        (WebKit::StorageManager::getValues):
     34        (WebKit::StorageManager::setItem):
     35        (WebKit::StorageManager::removeItem):
     36        (WebKit::StorageManager::clear):
     37        (WebKit::StorageManager::suspend):
     38        (WebKit::StorageManager::resume):
     39        (WebKit::StorageManager::StorageArea::isSessionStorage const): Deleted.
     40        * NetworkProcess/WebStorage/StorageManager.h:
     41        (): Deleted.
     42        * WebProcess/WebStorage/StorageAreaMap.cpp:
     43        (WebKit::StorageAreaMap::dispatchStorageEvent):
     44        (WebKit::StorageAreaMap::dispatchSessionStorageEvent):
     45        (WebKit::StorageAreaMap::connect):
     46        * WebProcess/WebStorage/StorageNamespaceImpl.cpp:
     47        (WebKit::StorageNamespaceImpl::createEphemeralLocalStorageNamespace):
     48        (WebKit::StorageNamespaceImpl::createLocalStorageNamespace):
     49        * WebProcess/WebStorage/StorageNamespaceImpl.h:
     50        * WebProcess/WebStorage/WebStorageNamespaceProvider.cpp:
     51        (WebKit::WebStorageNamespaceProvider::createLocalStorageNamespace):
     52
    1532019-05-30  Youenn Fablet  <youenn@apple.com>
    254

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManager.cpp

    r245904 r245943  
    6464    void clear();
    6565
    66     bool isSessionStorage() const { return !m_localStorageNamespace; }
     66    bool isEphemeral() const { return !m_localStorageNamespace; }
    6767
    6868private:
    … …  
    7373    void dispatchEvents(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString) const;
    7474
    75     // Will be null if the storage area belongs to a session storage namespace.
     75    // Will be null if the storage area belongs to a session storage namespace or the storage area is in an ephemeral session.
    7676    LocalStorageNamespace* m_localStorageNamespace;
    7777    mutable RefPtr<LocalStorageDatabase> m_localStorageDatabase;
    … …  
    9292    StorageManager* storageManager() const { return &m_storageManager; }
    9393
    94     Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&);
     94    enum class IsEphemeral : bool { No, Yes };
     95    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&, IsEphemeral);
    9596    void didDestroyStorageArea(StorageArea*);
    9697
    9798    void clearStorageAreasMatchingOrigin(const SecurityOriginData&);
    9899    void clearAllStorageAreas();
     100
     101    Vector<SecurityOriginData> ephemeralOrigins() const;
     102    void cloneTo(LocalStorageNamespace& newLocalStorageNamespace);
    99103
    100104private:
    … …  
    105109    unsigned m_quotaInBytes;
    106110
    107     // We don't hold an explicit reference to the StorageAreas; they are kept alive by the m_storageAreasByConnection map in StorageManager.
    108     HashMap<SecurityOriginData, StorageArea*> m_storageAreaMap;
     111    HashMap<SecurityOriginData, RefPtr<StorageArea>> m_storageAreaMap;
    109112};
    110113
    … …  
    197200void StorageManager::StorageArea::removeListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID)
    198201{
    199     ASSERT(isSessionStorage() || m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
     202    ASSERT(isEphemeral() || m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
    200203    m_eventListeners.remove(std::make_pair(connectionID, storageMapID));
    201204}
    … …  
    237240void StorageManager::StorageArea::setItems(const HashMap<String, String>& items)
    238241{
    239     ASSERT(!m_localStorageDatabase);
     242    // Import items from web process if items are not stored on disk.
     243    if (!isEphemeral())
     244        return;
     245
    240246    for (auto& item : items) {
    241247        String oldValue;
    … …  
    312318        return;
    313319
     320    ASSERT(m_localStorageNamespace->storageManager()->m_localStorageDatabaseTracker);
    314321    // We open the database here even if we've already imported our items to ensure that the database is open if we need to write to it.
    315322    if (!m_localStorageDatabase)
    316         m_localStorageDatabase = LocalStorageDatabase::create(m_localStorageNamespace->storageManager()->m_queue.copyRef(), m_localStorageNamespace->storageManager()->m_localStorageDatabaseTracker.copyRef(), m_securityOrigin);
     323        m_localStorageDatabase = LocalStorageDatabase::create(m_localStorageNamespace->storageManager()->m_queue.copyRef(), *m_localStorageNamespace->storageManager()->m_localStorageDatabaseTracker, m_securityOrigin);
    317324
    318325    if (m_didImportItemsFromDatabase)
    … …  
    351358StorageManager::LocalStorageNamespace::~LocalStorageNamespace()
    352359{
    353     ASSERT(m_storageAreaMap.isEmpty());
    354 }
    355 
    356 auto StorageManager::LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin) -> Ref<StorageArea>
     360}
     361
     362auto StorageManager::LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, IsEphemeral isEphemeral) -> Ref<StorageArea>
    357363{
    358364    RefPtr<StorageArea> protectedStorageArea;
    359365    return *m_storageAreaMap.ensure(securityOrigin, [&]() mutable {
    360         protectedStorageArea = StorageArea::create(this, WTFMove(securityOrigin), m_quotaInBytes);
     366        protectedStorageArea = StorageArea::create(isEphemeral == IsEphemeral::Yes ? nullptr : this, WTFMove(securityOrigin), m_quotaInBytes);
    361367        return protectedStorageArea.get();
    362368    }).iterator->value;
    … …  
    384390void StorageManager::LocalStorageNamespace::clearAllStorageAreas()
    385391{
    386     for (auto* storageArea : m_storageAreaMap.values())
     392    for (auto storageArea : m_storageAreaMap.values())
    387393        storageArea->clear();
     394}
     395
     396Vector<SecurityOriginData> StorageManager::LocalStorageNamespace::ephemeralOrigins() const
     397{
     398    Vector<SecurityOriginData> origins;
     399    for (const auto& storageArea : m_storageAreaMap.values()) {
     400        if (!storageArea->items().isEmpty())
     401            origins.append(storageArea->securityOrigin());
     402    }
     403    return origins;
     404}
     405
     406void StorageManager::LocalStorageNamespace::cloneTo(LocalStorageNamespace& newLocalStorageNamespace)
     407{
     408    for (auto& pair : m_storageAreaMap)
     409        newLocalStorageNamespace.m_storageAreaMap.add(pair.key, pair.value->clone());
    388410}
    389411
    … …  
    484506StorageManager::StorageManager(const String& localStorageDirectory)
    485507    : m_queue(WorkQueue::create("com.apple.WebKit.StorageManager"))
    486     , m_localStorageDatabaseTracker(LocalStorageDatabaseTracker::create(m_queue.copyRef(), localStorageDirectory))
    487     , m_isEphemeral(localStorageDirectory.isNull())
    488508{
    489509    // Make sure the encoding is initialized before we start dispatching things to the queue.
    490510    UTF8Encoding();
     511    if (!localStorageDirectory.isNull())
     512        m_localStorageDatabaseTracker = LocalStorageDatabaseTracker::create(m_queue.copyRef(), localStorageDirectory);
    491513}
    492514
    … …  
    549571
    550572        sessionStorageNamespace->cloneTo(*newSessionStorageNamespace);
     573
     574        if (!m_localStorageDatabaseTracker) {
     575            if (auto* localStorageNamespace = m_localStorageNamespaces.get(storageNamespaceID)) {
     576                LocalStorageNamespace* newlocalStorageNamespace = getOrCreateLocalStorageNamespace(newStorageNamespaceID);
     577                localStorageNamespace->cloneTo(*newlocalStorageNamespace);
     578            }
     579        }
    551580    });
    552581}
    … …  
    630659        HashSet<SecurityOriginData> origins;
    631660
    632         for (auto& origin : m_localStorageDatabaseTracker->origins())
    633             origins.add(origin);
     661        if (m_localStorageDatabaseTracker) {
     662            for (auto& origin : m_localStorageDatabaseTracker->origins())
     663                origins.add(origin);
     664        } else {
     665            for (const auto& localStorageNameSpace : m_localStorageNamespaces.values()) {
     666                for (auto& origin : localStorageNameSpace->ephemeralOrigins())
     667                    origins.add(origin);
     668            }
     669        }
    634670
    635671        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values()) {
    … …  
    647683{
    648684    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
    649         auto originDetails = m_localStorageDatabaseTracker->originDetails();
     685        Vector<LocalStorageDatabaseTracker::OriginDetails> originDetails;
     686        if (m_localStorageDatabaseTracker)
     687            originDetails = m_localStorageDatabaseTracker->originDetails();
    650688
    651689        RunLoop::main().dispatch([originDetails = WTFMove(originDetails), completionHandler = WTFMove(completionHandler)]() mutable {
    … …  
    664702            transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
    665703
    666         m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin);
     704        if (m_localStorageDatabaseTracker)
     705            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin);
    667706    });
    668707}
    … …  
    671710{
    672711    m_queue->dispatch([this, protectedThis = makeRef(*this), time, completionHandler = WTFMove(completionHandler)]() mutable {
    673         auto originsToDelete = m_localStorageDatabaseTracker->databasesModifiedSince(time);
    674        
    675         for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
    676             transientLocalStorageNamespace->clearAllStorageAreas();
    677 
    678         for (const auto& origin : originsToDelete) {
     712        if (m_localStorageDatabaseTracker) {
     713            auto originsToDelete = m_localStorageDatabaseTracker->databasesModifiedSince(time);
     714           
     715            for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
     716                transientLocalStorageNamespace->clearAllStorageAreas();
     717
     718            for (const auto& origin : originsToDelete) {
     719                for (auto& localStorageNamespace : m_localStorageNamespaces.values())
     720                    localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
     721               
     722                m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
     723            }
     724        } else {
    679725            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
    680                 localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
    681            
    682             m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
     726                localStorageNamespace->clearAllStorageAreas();
    683727        }
    684728
    … …  
    703747                transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(origin);
    704748
    705             m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
     749            if (m_localStorageDatabaseTracker)
     750                m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
    706751        }
    707752
    … …  
    713758{
    714759    m_queue->dispatch([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID(), storageMapID, storageNamespaceID, securityOriginData = securityOriginData.isolatedCopy()]() mutable {
    715         ASSERT(!m_isEphemeral);
    716760        std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connectionID, storageMapID);
    717761
    … …  
    730774        ASSERT(localStorageNamespace);
    731775
    732         auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
     776        auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData), m_localStorageDatabaseTracker ? StorageManager::LocalStorageNamespace::IsEphemeral::No : StorageManager::LocalStorageNamespace::IsEphemeral::Yes);
    733777        storageArea->addListener(connectionID, storageMapID);
    734778
    … …  
    749793                continue;
    750794            Ref<StorageArea> area = *it->value;
    751             if (!area->isSessionStorage())
     795            if (!area->isEphemeral())
    752796                continue;
    753797            if (!origin.securityOrigin()->isSameSchemeHostPort(area->securityOrigin().securityOrigin().get()))
    … …  
    781825{
    782826    m_queue->dispatch([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID(), storageMapID, storageNamespaceID, securityOriginData = securityOriginData.isolatedCopy()]() mutable {
    783         if (m_isEphemeral) {
    784             m_ephemeralStorage.add(securityOriginData, WebCore::StorageMap::create(localStorageDatabaseQuotaInBytes));
    785             return;
    786         }
    787827        // FIXME: This should be a message check.
    788828        ASSERT(m_sessionStorageNamespaces.isValidKey(storageNamespaceID));
    … …  
    830870
    831871        // Don't remove session storage maps. The web process may reconnect and expect the data to still be around.
    832         if (it->value->isSessionStorage())
     872        if (it->value->isEphemeral())
    833873            return;
    834874
    … …  
    848888    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, storageMapSeed, completionHandler = WTFMove(completionHandler)]() mutable {
    849889        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    850         if (!storageArea) {
    851             if (m_isEphemeral) {
    852                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData))
    853                     return didGetValues(connection.get(), storageMapID, storageMap->items(), WTFMove(completionHandler));
    854             }
    855             // This is a session storage area for a page that has already been closed. Ignore it.
     890
     891        // This is a session storage area for a page that has already been closed. Ignore it.
     892        if (!storageArea)
    856893            return didGetValues(connection.get(), storageMapID, { }, WTFMove(completionHandler));
    857         }
     894
    858895        didGetValues(connection.get(), storageMapID, storageArea->items(), WTFMove(completionHandler));
    859896        connection->send(Messages::StorageAreaMap::DidGetValues(storageMapSeed), storageMapID);
    … …  
    865902    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, sourceStorageAreaID, storageMapSeed, key = key.isolatedCopy(), value = value.isolatedCopy(), urlString = urlString.isolatedCopy()]() mutable {
    866903        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    867         if (!storageArea) {
    868             if (m_isEphemeral) {
    869                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
    870                     String oldValue;
    871                     bool quotaException;
    872                     storageMap->setItem(key, value, oldValue, quotaException);
    873                 }
    874             }
    875             // This is a session storage area for a page that has already been closed. Ignore it.
     904
     905        // This is a session storage area for a page that has already been closed. Ignore it.
     906        if (!storageArea)
    876907            return;
    877         }
    878908
    879909        bool quotaError;
    … …  
    895925    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, sourceStorageAreaID, storageMapSeed, key = key.isolatedCopy(), urlString = urlString.isolatedCopy()]() mutable {
    896926        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    897         if (!storageArea) {
    898             if (m_isEphemeral) {
    899                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
    900                     String oldValue;
    901                     storageMap->removeItem(key, oldValue);
    902                 }
    903             }
    904             // This is a session storage area for a page that has already been closed. Ignore it.
     927
     928        // This is a session storage area for a page that has already been closed. Ignore it.
     929        if (!storageArea)
    905930            return;
    906         }
    907931
    908932        storageArea->removeItem(connection->uniqueID(), sourceStorageAreaID, key, urlString);
    … …  
    915939    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, sourceStorageAreaID, storageMapSeed, urlString = urlString.isolatedCopy()]() mutable {
    916940        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    917         if (!storageArea) {
    918             if (m_isEphemeral)
    919                 m_ephemeralStorage.remove(securityOriginData);
    920             // This is a session storage area for a page that has already been closed. Ignore it.
     941
     942        // This is a session storage area for a page that has already been closed. Ignore it.
     943        if (!storageArea)
    921944            return;
    922         }
    923945
    924946        storageArea->clear(connection->uniqueID(), sourceStorageAreaID, urlString);
    … …  
    947969void StorageManager::suspend(CompletionHandler<void()>&& completionHandler)
    948970{
    949     if (m_isEphemeral)
     971    if (!m_localStorageDatabaseTracker)
    950972        return;
    951973
    … …  
    972994void StorageManager::resume()
    973995{
    974     if (m_isEphemeral)
     996    if (!m_localStorageDatabaseTracker)
    975997        return;
    976998

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManager.h

    r245904 r245943  
    104104    Ref<WorkQueue> m_queue;
    105105
    106     Ref<LocalStorageDatabaseTracker> m_localStorageDatabaseTracker;
     106    RefPtr<LocalStorageDatabaseTracker> m_localStorageDatabaseTracker;
    107107    HashMap<uint64_t, RefPtr<LocalStorageNamespace>> m_localStorageNamespaces;
    108108
    … …  
    113113
    114114    HashMap<std::pair<IPC::Connection::UniqueID, uint64_t>, RefPtr<StorageArea>> m_storageAreasByConnection;
    115 
    116     HashMap<WebCore::SecurityOriginData, Ref<WebCore::StorageMap>> m_ephemeralStorage;
    117     bool m_isEphemeral { false };
    118115
    119116    enum class State {

  • trunk/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp

    r245891 r245943  
    295295    }
    296296
    297     if (storageType() == StorageType::Session)
     297    if (storageType() == StorageType::Session || storageType() == StorageType::EphemeralLocal)
    298298        dispatchSessionStorageEvent(sourceStorageAreaID, key, oldValue, newValue, urlString);
    299299    else
    … …  
    308308void StorageAreaMap::dispatchSessionStorageEvent(uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString)
    309309{
    310     ASSERT(storageType() == StorageType::Session);
    311 
    312     // Namespace IDs for session storage namespaces are equivalent to web page IDs
     310    // Namespace IDs for session storage namespaces and ephemeral local storage namespaces are equivalent to web page IDs
    313311    // so we can get the right page here.
    314312    WebPage* webPage = WebProcess::singleton().webPage(makeObjectIdentifier<PageIdentifierType>(m_storageNamespaceID));
    … …  
    378376    switch (m_storageType) {
    379377    case StorageType::Local:
     378    case StorageType::EphemeralLocal:
    380379    case StorageType::TransientLocal:
    381380        if (SecurityOrigin* topLevelOrigin = m_storageNamespace->topLevelOrigin())
    … …  
    386385    case StorageType::Session:
    387386        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::CreateSessionStorageMap(m_storageMapID, m_storageNamespace->storageNamespaceID(), m_securityOrigin->data()), 0);
    388         if (m_storageMap)
    389             WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::SetItems(m_storageMapID, m_storageMap->items()), 0);
    390         break;
    391     case StorageType::EphemeralLocal:
    392         ASSERT_NOT_REACHED();
    393         return;
    394     }
    395 
     387    }
     388
     389    if (m_storageMap)
     390        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::SetItems(m_storageMapID, m_storageMap->items()), 0);
    396391    m_isDisconnected = false;
    397392}

  • trunk/Source/WebKit/WebProcess/WebStorage/StorageNamespaceImpl.cpp

    r245891 r245943  
    4848Ref<StorageNamespaceImpl> StorageNamespaceImpl::createEphemeralLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes)
    4949{
    50     return createSessionStorageNamespace(identifier, quotaInBytes);
     50    return createLocalStorageNamespace(identifier, quotaInBytes, IsEphemeral::Yes);
    5151}
    5252
    53 Ref<StorageNamespaceImpl> StorageNamespaceImpl::createLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes)
     53Ref<StorageNamespaceImpl> StorageNamespaceImpl::createLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes, IsEphemeral isEphemeral)
    5454{
    55     return adoptRef(*new StorageNamespaceImpl(StorageType::Local, identifier, nullptr, quotaInBytes));
     55    return adoptRef(*new StorageNamespaceImpl(isEphemeral == IsEphemeral::Yes ? StorageType::EphemeralLocal : StorageType::Local, identifier, nullptr, quotaInBytes));
    5656}
    5757

  • trunk/Source/WebKit/WebProcess/WebStorage/StorageNamespaceImpl.h

    r245891 r245943  
    4242    static Ref<StorageNamespaceImpl> createSessionStorageNamespace(uint64_t identifier, unsigned quotaInBytes);
    4343    static Ref<StorageNamespaceImpl> createEphemeralLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes);
    44     static Ref<StorageNamespaceImpl> createLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes);
     44
     45    enum class IsEphemeral : bool { No, Yes };
     46    static Ref<StorageNamespaceImpl> createLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes, IsEphemeral isEphemeral);
    4547    static Ref<StorageNamespaceImpl> createTransientLocalStorageNamespace(uint64_t identifier, WebCore::SecurityOrigin& topLevelOrigin, uint64_t quotaInBytes);
    4648

  • trunk/Source/WebKit/WebProcess/WebStorage/WebStorageNamespaceProvider.cpp

    r245891 r245943  
    7878Ref<WebCore::StorageNamespace> WebStorageNamespaceProvider::createLocalStorageNamespace(unsigned quota)
    7979{
    80     return StorageNamespaceImpl::createLocalStorageNamespace(m_identifier, quota);
     80    return StorageNamespaceImpl::createLocalStorageNamespace(m_identifier, quota, StorageNamespaceImpl::IsEphemeral::No);
    8181}
    8282

  • trunk/Tools/ChangeLog

    r245912 r245943  
     12019-05-30  Sihui Liu  <sihui_liu@apple.com>
     2
     3        WKWebsiteDataStore API fails to fetch web storage data for non-persistent data store
     4        https://bugs.webkit.org/show_bug.cgi?id=198317
     5
     6        Reviewed by Alex Christensen.
     7
     8        * TestWebKitAPI/Tests/WebKitCocoa/WKWebsiteDatastore.mm:
     9        (TestWebKitAPI::TEST):
     10
    1112019-05-30  Andres Gonzalez  <andresg_22@apple.com>
    212

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/WKWebsiteDatastore.mm

    r245891 r245943  
    305305}
    306306
    307 }
     307TEST(WKWebsiteDataStore, FetchNonPersistentWebStorage)
     308{
     309    auto nonPersistentDataStore = [WKWebsiteDataStore nonPersistentDataStore];
     310    auto configuration = adoptNS([WKWebViewConfiguration new]);
     311    [configuration setWebsiteDataStore:nonPersistentDataStore];
     312    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
     313    auto navigationDelegate = adoptNS([[NavigationTestDelegate alloc] init]);
     314    [webView setNavigationDelegate:navigationDelegate.get()];
     315    [webView loadHTMLString:@"<script>sessionStorage.setItem('session', 'storage');localStorage.setItem('local', 'storage');</script>" baseURL:[NSURL URLWithString:@"http://localhost"]];
     316    [navigationDelegate waitForDidFinishNavigation];
     317
     318    readyToContinue = false;
     319    [webView evaluateJavaScript:@"window.sessionStorage.getItem('session')" completionHandler:^(id result, NSError *) {
     320        EXPECT_TRUE([@"storage" isEqualToString:result]);
     321        readyToContinue = true;
     322    }];
     323    TestWebKitAPI::Util::run(&readyToContinue);
     324
     325    readyToContinue = false;
     326    [webView evaluateJavaScript:@"window.localStorage.getItem('local')" completionHandler:^(id result, NSError *) {
     327        EXPECT_TRUE([@"storage" isEqualToString:result]);
     328        readyToContinue = true;
     329    }];
     330    TestWebKitAPI::Util::run(&readyToContinue);
     331
     332    readyToContinue = false;
     333    [nonPersistentDataStore fetchDataRecordsOfTypes:[NSSet setWithObject:WKWebsiteDataTypeSessionStorage] completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
     334        EXPECT_EQ((int)dataRecords.count, 1);
     335        EXPECT_TRUE([[[dataRecords objectAtIndex:0] displayName] isEqualToString:@"localhost"]);
     336        readyToContinue = true;
     337    }];
     338    TestWebKitAPI::Util::run(&readyToContinue);
     339
     340    readyToContinue = false;
     341    [nonPersistentDataStore fetchDataRecordsOfTypes:[NSSet setWithObject:WKWebsiteDataTypeLocalStorage] completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
     342        EXPECT_EQ((int)dataRecords.count, 1);
     343        EXPECT_TRUE([[[dataRecords objectAtIndex:0] displayName] isEqualToString:@"localhost"]);
     344        readyToContinue = true;
     345    }];
     346    TestWebKitAPI::Util::run(&readyToContinue);
     347}
     348
     349}
Note: See TracChangeset for help on using the changeset viewer.