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

Changeset 246079 in webkit


Ignore:
Timestamp:
Jun 4, 2019, 1:54:31 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.

Reland r245943 as test has been fixed in r246012.

  • 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

    r246077 r246079  
     12019-06-04  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        Reland r245943 as test has been fixed in r246012.
     13
     14        * NetworkProcess/WebStorage/StorageManager.cpp:
     15        (WebKit::StorageManager::StorageArea::isEphemeral const):
     16        (WebKit::StorageManager::StorageArea::removeListener):
     17        (WebKit::StorageManager::StorageArea::setItems):
     18        (WebKit::StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded const):
     19        (WebKit::StorageManager::LocalStorageNamespace::~LocalStorageNamespace):
     20        (WebKit::StorageManager::LocalStorageNamespace::getOrCreateStorageArea):
     21        (WebKit::StorageManager::LocalStorageNamespace::clearAllStorageAreas):
     22        (WebKit::StorageManager::LocalStorageNamespace::ephemeralOrigins const):
     23        (WebKit::StorageManager::LocalStorageNamespace::cloneTo):
     24        (WebKit::StorageManager::StorageManager):
     25        (WebKit::StorageManager::cloneSessionStorageNamespace):
     26        (WebKit::StorageManager::getLocalStorageOrigins):
     27        (WebKit::StorageManager::getLocalStorageOriginDetails):
     28        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
     29        (WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
     30        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):
     31        (WebKit::StorageManager::createLocalStorageMap):
     32        (WebKit::StorageManager::createTransientLocalStorageMap):
     33        (WebKit::StorageManager::createSessionStorageMap):
     34        (WebKit::StorageManager::destroyStorageMap):
     35        (WebKit::StorageManager::getValues):
     36        (WebKit::StorageManager::setItem):
     37        (WebKit::StorageManager::removeItem):
     38        (WebKit::StorageManager::clear):
     39        (WebKit::StorageManager::suspend):
     40        (WebKit::StorageManager::resume):
     41        (WebKit::StorageManager::StorageArea::isSessionStorage const): Deleted.
     42        * NetworkProcess/WebStorage/StorageManager.h:
     43        (): Deleted.
     44        * WebProcess/WebStorage/StorageAreaMap.cpp:
     45        (WebKit::StorageAreaMap::dispatchStorageEvent):
     46        (WebKit::StorageAreaMap::dispatchSessionStorageEvent):
     47        (WebKit::StorageAreaMap::connect):
     48        * WebProcess/WebStorage/StorageNamespaceImpl.cpp:
     49        (WebKit::StorageNamespaceImpl::createEphemeralLocalStorageNamespace):
     50        (WebKit::StorageNamespaceImpl::createLocalStorageNamespace):
     51        * WebProcess/WebStorage/StorageNamespaceImpl.h:
     52        * WebProcess/WebStorage/WebStorageNamespaceProvider.cpp:
     53        (WebKit::WebStorageNamespaceProvider::createLocalStorageNamespace):
     54
    1552019-06-04  Alex Christensen  <achristensen@apple.com>
    256

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

    r246011 r246079  
    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
    … …  
    725769        ASSERT(localStorageNamespace);
    726770
    727         auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
     771        auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData), m_localStorageDatabaseTracker ? StorageManager::LocalStorageNamespace::IsEphemeral::No : StorageManager::LocalStorageNamespace::IsEphemeral::Yes);
    728772        storageArea->addListener(connectionID, storageMapID);
    729773
    … …  
    743787                continue;
    744788            Ref<StorageArea> area = *it->value;
    745             if (!area->isSessionStorage())
     789            if (!area->isEphemeral())
    746790                continue;
    747791            if (!origin.securityOrigin()->isSameSchemeHostPort(area->securityOrigin().securityOrigin().get()))
    … …  
    773817{
    774818    m_queue->dispatch([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID(), storageMapID, storageNamespaceID, securityOriginData = securityOriginData.isolatedCopy()]() mutable {
    775         if (m_isEphemeral) {
    776             m_ephemeralStorage.add(securityOriginData, WebCore::StorageMap::create(localStorageDatabaseQuotaInBytes));
    777             return;
    778         }
    779 
    780819        ASSERT(m_sessionStorageNamespaces.isValidKey(storageNamespaceID));
    781820
    … …  
    815854
    816855        // Don't remove session storage maps. The web process may reconnect and expect the data to still be around.
    817         if (it->value->isSessionStorage())
     856        if (it->value->isEphemeral())
    818857            return;
    819858
    … …  
    833872    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, storageMapSeed, completionHandler = WTFMove(completionHandler)]() mutable {
    834873        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    835         if (!storageArea) {
    836             if (m_isEphemeral) {
    837                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData))
    838                     return didGetValues(connection.get(), storageMapID, storageMap->items(), WTFMove(completionHandler));
    839             }
    840             // This is a session storage area for a page that has already been closed. Ignore it.
     874
     875        // This is a session storage area for a page that has already been closed. Ignore it.
     876        if (!storageArea)
    841877            return didGetValues(connection.get(), storageMapID, { }, WTFMove(completionHandler));
    842         }
     878
    843879        didGetValues(connection.get(), storageMapID, storageArea->items(), WTFMove(completionHandler));
    844880        connection->send(Messages::StorageAreaMap::DidGetValues(storageMapSeed), storageMapID);
    … …  
    850886    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 {
    851887        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    852         if (!storageArea) {
    853             if (m_isEphemeral) {
    854                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
    855                     String oldValue;
    856                     bool quotaException;
    857                     storageMap->setItem(key, value, oldValue, quotaException);
    858                 }
    859             }
    860             // This is a session storage area for a page that has already been closed. Ignore it.
     888
     889        // This is a session storage area for a page that has already been closed. Ignore it.
     890        if (!storageArea)
    861891            return;
    862         }
    863892
    864893        bool quotaError;
    … …  
    880909    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, sourceStorageAreaID, storageMapSeed, key = key.isolatedCopy(), urlString = urlString.isolatedCopy()]() mutable {
    881910        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    882         if (!storageArea) {
    883             if (m_isEphemeral) {
    884                 if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
    885                     String oldValue;
    886                     storageMap->removeItem(key, oldValue);
    887                 }
    888             }
    889             // This is a session storage area for a page that has already been closed. Ignore it.
     911
     912        // This is a session storage area for a page that has already been closed. Ignore it.
     913        if (!storageArea)
    890914            return;
    891         }
    892915
    893916        storageArea->removeItem(connection->uniqueID(), sourceStorageAreaID, key, urlString);
    … …  
    900923    m_queue->dispatch([this, protectedThis = makeRef(*this), connection = makeRef(connection), securityOriginData = securityOriginData.isolatedCopy(), storageMapID, sourceStorageAreaID, storageMapSeed, urlString = urlString.isolatedCopy()]() mutable {
    901924        auto* storageArea = findStorageArea(connection.get(), storageMapID);
    902         if (!storageArea) {
    903             if (m_isEphemeral)
    904                 m_ephemeralStorage.remove(securityOriginData);
    905             // This is a session storage area for a page that has already been closed. Ignore it.
     925
     926        // This is a session storage area for a page that has already been closed. Ignore it.
     927        if (!storageArea)
    906928            return;
    907         }
    908929
    909930        storageArea->clear(connection->uniqueID(), sourceStorageAreaID, urlString);
    … …  
    932953void StorageManager::suspend(CompletionHandler<void()>&& completionHandler)
    933954{
    934     if (m_isEphemeral)
     955    if (!m_localStorageDatabaseTracker)
    935956        return;
    936957
    … …  
    957978void StorageManager::resume()
    958979{
    959     if (m_isEphemeral)
     980    if (!m_localStorageDatabaseTracker)
    960981        return;
    961982

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

    r245978 r246079  
    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

    r245978 r246079  
    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

    r245978 r246079  
    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

    r245978 r246079  
    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

    r245978 r246079  
    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

    r246076 r246079  
     12019-06-04  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-06-04  Takashi Komori  <Takashi.Komori@sony.com>
    212

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

    r245979 r246079  
    351351}
    352352
    353 }
     353TEST(WKWebsiteDataStore, FetchNonPersistentWebStorage)
     354{
     355    auto nonPersistentDataStore = [WKWebsiteDataStore nonPersistentDataStore];
     356    auto configuration = adoptNS([WKWebViewConfiguration new]);
     357    [configuration setWebsiteDataStore:nonPersistentDataStore];
     358    auto webView = adoptNS([[TestWKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
     359    auto navigationDelegate = adoptNS([[NavigationTestDelegate alloc] init]);
     360    [webView setNavigationDelegate:navigationDelegate.get()];
     361    [webView loadHTMLString:@"<script>sessionStorage.setItem('session', 'storage');localStorage.setItem('local', 'storage');</script>" baseURL:[NSURL URLWithString:@"http://localhost"]];
     362    [navigationDelegate waitForDidFinishNavigation];
     363
     364    readyToContinue = false;
     365    [webView evaluateJavaScript:@"window.sessionStorage.getItem('session')" completionHandler:^(id result, NSError *) {
     366        EXPECT_TRUE([@"storage" isEqualToString:result]);
     367        readyToContinue = true;
     368    }];
     369    TestWebKitAPI::Util::run(&readyToContinue);
     370
     371    readyToContinue = false;
     372    [webView evaluateJavaScript:@"window.localStorage.getItem('local')" completionHandler:^(id result, NSError *) {
     373        EXPECT_TRUE([@"storage" isEqualToString:result]);
     374        readyToContinue = true;
     375    }];
     376    TestWebKitAPI::Util::run(&readyToContinue);
     377
     378    readyToContinue = false;
     379    [nonPersistentDataStore fetchDataRecordsOfTypes:[NSSet setWithObject:WKWebsiteDataTypeSessionStorage] completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
     380        EXPECT_EQ((int)dataRecords.count, 1);
     381        EXPECT_TRUE([[[dataRecords objectAtIndex:0] displayName] isEqualToString:@"localhost"]);
     382        readyToContinue = true;
     383    }];
     384    TestWebKitAPI::Util::run(&readyToContinue);
     385
     386    readyToContinue = false;
     387    [nonPersistentDataStore fetchDataRecordsOfTypes:[NSSet setWithObject:WKWebsiteDataTypeLocalStorage] completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
     388        EXPECT_EQ((int)dataRecords.count, 1);
     389        EXPECT_TRUE([[[dataRecords objectAtIndex:0] displayName] isEqualToString:@"localhost"]);
     390        readyToContinue = true;
     391    }];
     392    TestWebKitAPI::Util::run(&readyToContinue);
     393}
     394
     395}
Note: See TracChangeset for help on using the changeset viewer.