webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 142 insertions, 56 deletions

diff --git a/Source/WebKit2/WebProcess/Storage/StorageNamespaceImpl.cpp b/Source/WebKit2/WebProcess/Storage/StorageNamespaceImpl.cpp
index 3845913b2..2abbc5c21 100644
--- a/Source/WebKit2/WebProcess/Storage/StorageNamespaceImpl.cpp
+++ b/Source/WebKit2/WebProcess/Storage/StorageNamespaceImpl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,103 +31,189 @@
 #include "WebPage.h"
 #include "WebPageGroupProxy.h"
 #include "WebProcess.h"
-#include <WebCore/GroupSettings.h>
+#include <WebCore/Frame.h>
 #include <WebCore/PageGroup.h>
 #include <WebCore/SecurityOrigin.h>
 #include <WebCore/Settings.h>
-#include <wtf/NeverDestroyed.h>
+#include <WebCore/StorageType.h>
 
 using namespace WebCore;
 
 namespace WebKit {
 
-typedef HashMap<uint64_t, StorageNamespaceImpl*> LocalStorageNamespaceMap;
-
-static LocalStorageNamespaceMap& localStorageNamespaceMap()
+RefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createSessionStorageNamespace(uint64_t identifier, unsigned quotaInBytes)
 {
-    static NeverDestroyed<LocalStorageNamespaceMap> localStorageNamespaceMap;
-    return localStorageNamespaceMap;
+    return adoptRef(new StorageNamespaceImpl(StorageType::Session, identifier, nullptr, quotaInBytes));
 }
 
-PassRefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createLocalStorageNamespace(PageGroup* pageGroup)
+RefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createEphemeralLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes)
 {
-    uint64_t pageGroupID = WebProcess::shared().webPageGroup(pageGroup)->pageGroupID();
-
-    LocalStorageNamespaceMap::AddResult result = localStorageNamespaceMap().add(pageGroupID, nullptr);
-    if (!result.isNewEntry)
-        return result.iterator->value;
-
-    unsigned quota = pageGroup->groupSettings().localStorageQuotaBytes();
-    RefPtr<StorageNamespaceImpl> localStorageNamespace = adoptRef(new StorageNamespaceImpl(LocalStorage, pageGroupID, quota));
+    return adoptRef(new StorageNamespaceImpl(StorageType::EphemeralLocal, identifier, nullptr, quotaInBytes));
+}
 
-    result.iterator->value = localStorageNamespace.get();
-    return localStorageNamespace.release();
+RefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createLocalStorageNamespace(uint64_t identifier, unsigned quotaInBytes)
+{
+    return adoptRef(new StorageNamespaceImpl(StorageType::Local, identifier, nullptr, quotaInBytes));
 }
 
-PassRefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createSessionStorageNamespace(WebPage* webPage)
+RefPtr<StorageNamespaceImpl> StorageNamespaceImpl::createTransientLocalStorageNamespace(uint64_t identifier, WebCore::SecurityOrigin& topLevelOrigin, uint64_t quotaInBytes)
 {
-    return adoptRef(new StorageNamespaceImpl(SessionStorage, webPage->pageID(), webPage->corePage()->settings().sessionStorageQuota()));
+    return adoptRef(new StorageNamespaceImpl(StorageType::TransientLocal, identifier, &topLevelOrigin, quotaInBytes));
 }
 
-StorageNamespaceImpl::StorageNamespaceImpl(WebCore::StorageType storageType, uint64_t storageNamespaceID, unsigned quotaInBytes)
+StorageNamespaceImpl::StorageNamespaceImpl(WebCore::StorageType storageType, uint64_t storageNamespaceID, WebCore::SecurityOrigin* topLevelOrigin, unsigned quotaInBytes)
     : m_storageType(storageType)
     , m_storageNamespaceID(storageNamespaceID)
+    , m_topLevelOrigin(topLevelOrigin)
     , m_quotaInBytes(quotaInBytes)
 {
 }
 
 StorageNamespaceImpl::~StorageNamespaceImpl()
 {
-    if (m_storageType == LocalStorage) {
-        ASSERT(localStorageNamespaceMap().contains(m_storageNamespaceID));
-        localStorageNamespaceMap().remove(m_storageNamespaceID);
-    }
 }
 
-PassRefPtr<StorageArea> StorageNamespaceImpl::storageArea(PassRefPtr<SecurityOrigin> securityOrigin)
+void StorageNamespaceImpl::didDestroyStorageAreaMap(StorageAreaMap& map)
 {
-    auto result = m_storageAreaMaps.add(securityOrigin.get(), nullptr);
-    if (result.isNewEntry)
-        result.iterator->value = StorageAreaMap::create(this, securityOrigin);
-
-    return StorageAreaImpl::create(result.iterator->value);
+    m_storageAreaMaps.remove(SecurityOriginData::fromSecurityOrigin(map.securityOrigin()));
 }
 
-PassRefPtr<StorageNamespace> StorageNamespaceImpl::copy(Page* newPage)
+RefPtr<StorageArea> StorageNamespaceImpl::storageArea(const SecurityOriginData& securityOrigin)
 {
-    ASSERT(m_storageNamespaceID);
+    if (m_storageType == StorageType::EphemeralLocal)
+        return ephemeralLocalStorageArea(securityOrigin);
 
-    return createSessionStorageNamespace(WebPage::fromCorePage(newPage));
-}
+    RefPtr<StorageAreaMap> map;
 
-void StorageNamespaceImpl::close()
-{
-    // FIXME: Implement this.
-    ASSERT_NOT_REACHED();
-}
+    auto& slot = m_storageAreaMaps.add(securityOrigin, nullptr).iterator->value;
+    if (!slot) {
+        map = StorageAreaMap::create(this, securityOrigin.securityOrigin());
+        slot = map.get();
+    } else
+        map = slot;
 
-void StorageNamespaceImpl::clearOriginForDeletion(SecurityOrigin*)
-{
-    // FIXME: Implement this.
-    ASSERT_NOT_REACHED();
+    return StorageAreaImpl::create(map.releaseNonNull());
 }
 
-void StorageNamespaceImpl::clearAllOriginsForDeletion()
-{
-    // FIXME: Implement this.
-    ASSERT_NOT_REACHED();
-}
+class StorageNamespaceImpl::EphemeralStorageArea final : public StorageArea {
+public:
+    static Ref<EphemeralStorageArea> create(const SecurityOriginData& origin, unsigned quotaInBytes)
+    {
+        return adoptRef(*new EphemeralStorageArea(origin, quotaInBytes));
+    }
+
+    Ref<EphemeralStorageArea> copy()
+    {
+        return adoptRef(*new EphemeralStorageArea(*this));
+    }
+
+private:
+    EphemeralStorageArea(const SecurityOriginData& origin, unsigned quotaInBytes)
+        : m_securityOriginData(origin)
+        , m_storageMap(StorageMap::create(quotaInBytes))
+    {
+    }
+
+    EphemeralStorageArea(EphemeralStorageArea& other)
+        : m_securityOriginData(other.m_securityOriginData)
+        , m_storageMap(other.m_storageMap)
+    {
+    }
+
+    // WebCore::StorageArea.
+    unsigned length()
+    {
+        return m_storageMap->length();
+    }
+
+    String key(unsigned index)
+    {
+        return m_storageMap->key(index);
+    }
+
+    String item(const String& key)
+    {
+        return m_storageMap->getItem(key);
+    }
+
+    void setItem(Frame*, const String& key, const String& value, bool& quotaException)
+    {
+        String oldValue;
+        if (auto newMap = m_storageMap->setItem(key, value, oldValue, quotaException))
+            m_storageMap = WTFMove(newMap);
+    }
+
+    void removeItem(Frame*, const String& key)
+    {
+        String oldValue;
+        if (auto newMap = m_storageMap->removeItem(key, oldValue))
+            m_storageMap = WTFMove(newMap);
+    }
+
+    void clear(Frame*)
+    {
+        if (!m_storageMap->length())
+            return;
+
+        m_storageMap = StorageMap::create(m_storageMap->quota());
+    }
+
+    bool contains(const String& key)
+    {
+        return m_storageMap->contains(key);
+    }
+
+    bool canAccessStorage(Frame* frame)
+    {
+        return frame && frame->page();
+    }
+
+    StorageType storageType() const
+    {
+        return StorageType::EphemeralLocal;
+    }
+
+    size_t memoryBytesUsedByCache()
+    {
+        return 0;
+    }
+
+    void incrementAccessCount() { }
+    void decrementAccessCount() { }
+    void closeDatabaseIfIdle() { }
+
+    SecurityOriginData securityOrigin() const
+    {
+        return m_securityOriginData;
+    }
+
+    SecurityOriginData m_securityOriginData;
+    RefPtr<StorageMap> m_storageMap;
+};
 
-void StorageNamespaceImpl::sync()
+RefPtr<StorageArea> StorageNamespaceImpl::ephemeralLocalStorageArea(const SecurityOriginData& securityOrigin)
 {
-    // FIXME: Implement this.
-    ASSERT_NOT_REACHED();
+    auto& slot = m_ephemeralLocalStorageAreas.add(securityOrigin, nullptr).iterator->value;
+    if (!slot)
+        slot = StorageNamespaceImpl::EphemeralStorageArea::create(securityOrigin, m_quotaInBytes);
+
+    return slot.get();
 }
 
-void StorageNamespaceImpl::closeIdleLocalStorageDatabases()
+RefPtr<StorageNamespace> StorageNamespaceImpl::copy(Page* newPage)
 {
-    // FIXME: Implement this.
-    ASSERT_NOT_REACHED();
+    ASSERT(m_storageNamespaceID);
+
+    if (m_storageType == StorageType::Session)
+        return createSessionStorageNamespace(WebPage::fromCorePage(newPage)->pageID(), m_quotaInBytes);
+
+    ASSERT(m_storageType == StorageType::EphemeralLocal);
+    RefPtr<StorageNamespaceImpl> newNamespace = adoptRef(new StorageNamespaceImpl(m_storageType, m_storageNamespaceID, m_topLevelOrigin.get(), m_quotaInBytes));
+
+    for (auto& iter : m_ephemeralLocalStorageAreas)
+        newNamespace->m_ephemeralLocalStorageAreas.set(iter.key, iter.value->copy());
+
+    return newNamespace;
 }
 
 } // namespace WebKit