Adjust heuristics for reported quota

https://bugs.webkit.org/show_bug.cgi?id=256615
rdar://problem/109173368

Reviewed by Youenn Fablet.

In existing implementation, StorageManager API returns a fixed value when existing usage is smaller than the fixed value
(standardReportedQuota, and default value is 10 GB). This patch makes a few improvements:
1. Calculate standardReportedQuota based on originQuotaRatio and standardVolumeCapacity, instead of directly setting
value for standardReportedQuota -- standardReportedQuota = standardVolumeCapacity * originQuotaRatio.
2. Unlike defaultStandardReportedQuota, defaultStandardVolumeCapacity is different on different platforms by default,
which will make the reported quota value more reasonable.
3. Ensure reported quota is at least twice the current usage. A problem in existing implementation is client needs to
store over 10 GB to find out the quota that is bigger than 10 GB, but if client sees the reported quota as 10 GB, they
may never store over that.
4. OriginQuotaManager::reportedQuota() uses reported usage (`OriginQuotaManager::usage()`) instead of actual disk usage
(`m_usage`). Reported usage tracks the realtime usage which includes the granted space, and we use that in
quota check for storage operation.

Test: WKWebsiteDataStoreConfiguration.StandardVolumeCapacity

* Source/WebKit/NetworkProcess/NetworkSession.cpp:
(WebKit::createNetworkStorageManager):
* Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp:
(WebKit::NetworkSessionCreationParameters::encode const):
(WebKit::NetworkSessionCreationParameters::decode):
* Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h:
* Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp:
(WebKit::NetworkStorageManager::create):
(WebKit::NetworkStorageManager::NetworkStorageManager):
(WebKit::NetworkStorageManager::originStorageManager):
* Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h:
* Source/WebKit/NetworkProcess/storage/OriginQuotaManager.cpp:
(WebKit::OriginQuotaManager::reportedQuota):
(WebKit::OriginQuotaManager::reportedQuota const): Deleted.
* Source/WebKit/NetworkProcess/storage/OriginQuotaManager.h:
* Source/WebKit/UIProcess/API/Cocoa/_WKWebsiteDataStoreConfiguration.h:
* Source/WebKit/UIProcess/API/Cocoa/_WKWebsiteDataStoreConfiguration.mm:
(-[_WKWebsiteDataStoreConfiguration standardVolumeCapacity]):
(-[_WKWebsiteDataStoreConfiguration setStandardVolumeCapacity:]):
* Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp:
(WebKit::WebsiteDataStore::parameters):
* Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h:
(WebKit::WebsiteDataStore::defaultStandardVolumeCapacity):
* Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp:
(WebKit::WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration):
(WebKit::WebsiteDataStoreConfiguration::copy const):
* Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.h:
(WebKit::WebsiteDataStoreConfiguration::standardVolumeCapacity const):
(WebKit::WebsiteDataStoreConfiguration::setStandardVolumeCapacity):
* Tools/TestWebKitAPI/Tests/WebKitCocoa/WKWebsiteDatastore.mm:
(TestWebKitAPI::TEST):

Canonical link: https://commits.webkit.org/264446@main

Source/WebKit/NetworkProcess/NetworkSession.cpp

@@ -118,7 +118,7 @@ static Ref<NetworkStorageManager> createNetworkStorageManager(NetworkProcess& ne
     serviceWorkerStorageDirectory = parameters.serviceWorkerRegistrationDirectory;
     SandboxExtension::consumePermanently(parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
 #endif
-    return NetworkStorageManager::create(networkProcess, parameters.sessionID, parameters.dataStoreIdentifier, connectionID, parameters.generalStorageDirectory, parameters.localStorageDirectory, parameters.indexedDBDirectory, parameters.cacheStorageDirectory, serviceWorkerStorageDirectory, parameters.perOriginStorageQuota, parameters.originQuotaRatio, parameters.totalQuotaRatio, parameters.volumeCapacityOverride, parameters.unifiedOriginStorageLevel);
+    return NetworkStorageManager::create(networkProcess, parameters.sessionID, parameters.dataStoreIdentifier, connectionID, parameters.generalStorageDirectory, parameters.localStorageDirectory, parameters.indexedDBDirectory, parameters.cacheStorageDirectory, serviceWorkerStorageDirectory, parameters.perOriginStorageQuota, parameters.originQuotaRatio, parameters.totalQuotaRatio, parameters.standardVolumeCapacity, parameters.volumeCapacityOverride, parameters.unifiedOriginStorageLevel);
 }
 
 NetworkSession::NetworkSession(NetworkProcess& networkProcess, const NetworkSessionCreationParameters& parameters)

Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp

@@ -100,7 +100,7 @@ void NetworkSessionCreationParameters::encode(IPC::Encoder& encoder) const
     encoder << isBlobRegistryTopOriginPartitioningEnabled;
 
     encoder << unifiedOriginStorageLevel;
-    encoder << perOriginStorageQuota << originQuotaRatio << totalQuotaRatio << volumeCapacityOverride;
+    encoder << perOriginStorageQuota << originQuotaRatio << totalQuotaRatio << standardVolumeCapacity << volumeCapacityOverride;
     encoder << localStorageDirectory << localStorageDirectoryExtensionHandle;
     encoder << indexedDBDirectory << indexedDBDirectoryExtensionHandle;
     encoder << cacheStorageDirectory << cacheStorageDirectoryExtensionHandle;
@@ -382,6 +382,11 @@ std::optional<NetworkSessionCreationParameters> NetworkSessionCreationParameters
     if (!totalQuotaRatio)
         return std::nullopt;
 
+    std::optional<std::optional<uint64_t>> standardVolumeCapacity;
+    decoder >> standardVolumeCapacity;
+    if (!standardVolumeCapacity)
+        return std::nullopt;
+
     std::optional<std::optional<uint64_t>> volumeCapacityOverride;
     decoder >> volumeCapacityOverride;
     if (!volumeCapacityOverride)
@@ -512,6 +517,7 @@ std::optional<NetworkSessionCreationParameters> NetworkSessionCreationParameters
         , WTFMove(*perOriginStorageQuota)
         , WTFMove(*originQuotaRatio)
         , WTFMove(*totalQuotaRatio)
+        , WTFMove(*standardVolumeCapacity)
         , WTFMove(*volumeCapacityOverride)
         , WTFMove(*localStorageDirectory)
         , WTFMove(*localStorageDirectoryExtensionHandle)

Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h

@@ -121,6 +121,7 @@ struct NetworkSessionCreationParameters {
     uint64_t perOriginStorageQuota;
     std::optional<double> originQuotaRatio;
     std::optional<double> totalQuotaRatio;
+    std::optional<uint64_t> standardVolumeCapacity;
     std::optional<uint64_t> volumeCapacityOverride;
     String localStorageDirectory;
     SandboxExtension::Handle localStorageDirectoryExtensionHandle;

Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp

@@ -70,7 +70,6 @@ static const Seconds defaultBackupExclusionPeriod { 24_h };
 #endif
 
 static constexpr double defaultThirdPartyOriginQuotaRatio = 0.1; // third-party_origin_quota / origin_quota
-static constexpr uint64_t defaultStandardReportedQuota = 10 * GB;
 static constexpr uint64_t defaultVolumeCapacityUnit = 1 * GB;
 static constexpr auto persistedFileName = "persisted"_s;
 
@@ -150,12 +149,12 @@ String NetworkStorageManager::persistedFilePath(const WebCore::ClientOrigin& ori
     return FileSystem::pathByAppendingComponent(directory, persistedFileName);
 }
 
-Ref<NetworkStorageManager> NetworkStorageManager::create(NetworkProcess& process, PAL::SessionID sessionID, Markable<UUID> identifier, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel level)
+Ref<NetworkStorageManager> NetworkStorageManager::create(NetworkProcess& process, PAL::SessionID sessionID, Markable<UUID> identifier, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> standardVolumeCapacity, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel level)
 {
-    return adoptRef(*new NetworkStorageManager(process, sessionID, identifier, connection, path, customLocalStoragePath, customIDBStoragePath, customCacheStoragePath, customServiceWorkerStoragePath, defaultOriginQuota, originQuotaRatio, totalQuotaRatio, volumeCapacityOverride, level));
+    return adoptRef(*new NetworkStorageManager(process, sessionID, identifier, connection, path, customLocalStoragePath, customIDBStoragePath, customCacheStoragePath, customServiceWorkerStoragePath, defaultOriginQuota, originQuotaRatio, totalQuotaRatio, standardVolumeCapacity, volumeCapacityOverride, level));
 }
 
-NetworkStorageManager::NetworkStorageManager(NetworkProcess& process, PAL::SessionID sessionID, Markable<UUID> identifier, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel level)
+NetworkStorageManager::NetworkStorageManager(NetworkProcess& process, PAL::SessionID sessionID, Markable<UUID> identifier, IPC::Connection::UniqueID connection, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> standardVolumeCapacity, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel level)
     : m_process(process)
     , m_sessionID(sessionID)
     , m_queueName(makeString("com.apple.WebKit.Storage.", sessionID.toUInt64(), ".", static_cast<uint64_t>(identifier->data() >> 64), static_cast<uint64_t>(identifier->data())))
@@ -175,14 +174,15 @@ NetworkStorageManager::NetworkStorageManager(NetworkProcess& process, PAL::Sessi
         }
     }
 
-    m_queue->dispatch([this, weakThis = ThreadSafeWeakPtr { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath), customIDBStoragePath = crossThreadCopy(customIDBStoragePath), customCacheStoragePath = crossThreadCopy(customCacheStoragePath), customServiceWorkerStoragePath = crossThreadCopy(customServiceWorkerStoragePath), defaultOriginQuota, originQuotaRatio, totalQuotaRatio, volumeCapacityOverride, level]() mutable {
+    m_queue->dispatch([this, weakThis = ThreadSafeWeakPtr { *this }, path = path.isolatedCopy(), customLocalStoragePath = crossThreadCopy(customLocalStoragePath), customIDBStoragePath = crossThreadCopy(customIDBStoragePath), customCacheStoragePath = crossThreadCopy(customCacheStoragePath), customServiceWorkerStoragePath = crossThreadCopy(customServiceWorkerStoragePath), defaultOriginQuota, originQuotaRatio, totalQuotaRatio, standardVolumeCapacity, volumeCapacityOverride, level]() mutable {
         auto strongThis = weakThis.get();
         if (!strongThis)
             return;
 
         m_defaultOriginQuota = defaultOriginQuota;
         m_originQuotaRatio = originQuotaRatio;
         m_totalQuotaRatio = totalQuotaRatio;
+        m_standardVolumeCapacity = standardVolumeCapacity;
         m_volumeCapacityOverride = volumeCapacityOverride;
 #if PLATFORM(IOS_FAMILY)
         m_backupExclusionPeriod = defaultBackupExclusionPeriod;
@@ -532,7 +532,7 @@ OriginStorageManager& NetworkStorageManager::originStorageManager(const WebCore:
         };
         // Use double for multiplication to preserve precision.
         double quota = m_defaultOriginQuota;
-        double standardReportedQuota = defaultStandardReportedQuota;
+        double standardReportedQuota = m_standardVolumeCapacity ? *m_standardVolumeCapacity : 0.0;
         if (m_originQuotaRatio) {
             std::optional<uint64_t> volumeCapacity;
             if (m_volumeCapacityOverride)
@@ -543,6 +543,7 @@ OriginStorageManager& NetworkStorageManager::originStorageManager(const WebCore:
                 quota = m_originQuotaRatio.value() * volumeCapacity.value();
                 increaseQuotaFunction = { };
             }
+            standardReportedQuota *= m_originQuotaRatio.value();
         }
         if (origin.topOrigin != origin.clientOrigin) {
             quota *= defaultThirdPartyOriginQuotaRatio;

Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h

@@ -84,7 +84,7 @@ class StorageAreaRegistry;
 
 class NetworkStorageManager final : public IPC::WorkQueueMessageReceiver {
 public:
-    static Ref<NetworkStorageManager> create(NetworkProcess&, PAL::SessionID, Markable<UUID>, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel);
+    static Ref<NetworkStorageManager> create(NetworkProcess&, PAL::SessionID, Markable<UUID>, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> standardVolumeCapacity, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel);
     static bool canHandleTypes(OptionSet<WebsiteDataType>);
     static OptionSet<WebsiteDataType> allManagedTypes();
 
@@ -127,7 +127,7 @@ class NetworkStorageManager final : public IPC::WorkQueueMessageReceiver {
 #endif // ENABLE(SERVICE_WORKER)
 
 private:
-    NetworkStorageManager(NetworkProcess&, PAL::SessionID, Markable<UUID>, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel);
+    NetworkStorageManager(NetworkProcess&, PAL::SessionID, Markable<UUID>, IPC::Connection::UniqueID, const String& path, const String& customLocalStoragePath, const String& customIDBStoragePath, const String& customCacheStoragePath, const String& customServiceWorkerStoragePath, uint64_t defaultOriginQuota, std::optional<double> originQuotaRatio, std::optional<double> totalQuotaRatio, std::optional<uint64_t> standardVolumeCapacity, std::optional<uint64_t> volumeCapacityOverride, UnifiedOriginStorageLevel);
     ~NetworkStorageManager();
     void writeOriginToFileIfNecessary(const WebCore::ClientOrigin&, StorageAreaBase* = nullptr);
     enum class ShouldWriteOriginFile : bool { No, Yes };
@@ -262,6 +262,7 @@ class NetworkStorageManager final : public IPC::WorkQueueMessageReceiver {
     uint64_t m_defaultOriginQuota;
     std::optional<double> m_originQuotaRatio;
     std::optional<double> m_totalQuotaRatio;
+    std::optional<uint64_t> m_standardVolumeCapacity;
     std::optional<uint64_t> m_volumeCapacityOverride;
     std::optional<uint64_t> m_totalUsage;
     uint64_t m_totalQuota;

Source/WebKit/NetworkProcess/storage/OriginQuotaManager.cpp

@@ -30,6 +30,8 @@
 
 namespace WebKit {
 
+static constexpr double defaultReportedQuotaIncreaseFactor = 2.0;
+
 Ref<OriginQuotaManager> OriginQuotaManager::create(uint64_t quota, uint64_t standardReportedQuota, GetUsageFunction&& getUsageFunction, IncreaseQuotaFunction&& increaseQuotaFunction, NotifySpaceGrantedFunction&& notifySpaceGrantedFunction)
 {
     return adoptRef(*new OriginQuotaManager(quota, standardReportedQuota, WTFMove(getUsageFunction), WTFMove(increaseQuotaFunction), WTFMove(notifySpaceGrantedFunction)));
@@ -156,11 +158,16 @@ void OriginQuotaManager::resetQuotaForTesting()
     m_quotaCountdown = 0;
 }
 
-uint64_t OriginQuotaManager::reportedQuota() const
+uint64_t OriginQuotaManager::reportedQuota()
 {
-    if (m_usage && *m_usage > m_standardReportedQuota)
+    if (!m_standardReportedQuota)
         return m_quota;
 
+    // Standard reported quota is at least double existing usage.
+    auto expectedUsage = usage() * defaultReportedQuotaIncreaseFactor;
+    while (expectedUsage > m_standardReportedQuota && m_standardReportedQuota < m_quota)
+        m_standardReportedQuota *= defaultReportedQuotaIncreaseFactor;
+
     return std::min(m_quota, m_standardReportedQuota);
 }
 

Source/WebKit/NetworkProcess/storage/OriginQuotaManager.h

@@ -39,7 +39,7 @@ class OriginQuotaManager : public ThreadSafeRefCountedAndCanMakeThreadSafeWeakPt
     using IncreaseQuotaFunction = Function<void(QuotaIncreaseRequestIdentifier, uint64_t currentQuota, uint64_t currentUsage, uint64_t requestedIncrease)>;
     using NotifySpaceGrantedFunction = Function<void(uint64_t)>;
     static Ref<OriginQuotaManager> create(uint64_t quota, uint64_t standardReportedQuota, GetUsageFunction&&, IncreaseQuotaFunction&& = { }, NotifySpaceGrantedFunction&& = { });
-    uint64_t reportedQuota() const;
+    uint64_t reportedQuota();
     uint64_t usage();
     enum class Decision : bool { Deny, Grant };
     using RequestCallback = CompletionHandler<void(Decision)>;

Source/WebKit/UIProcess/API/Cocoa/_WKWebsiteDataStoreConfiguration.h

@@ -54,6 +54,7 @@ WK_CLASS_AVAILABLE(macos(10.13), ios(11.0))
 @property (nonatomic) NSUInteger perOriginStorageQuota WK_API_AVAILABLE(macos(10.15.4), ios(13.4));
 @property (nonatomic, nullable, copy) NSNumber *originQuotaRatio WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
 @property (nonatomic, nullable, copy) NSNumber *totalQuotaRatio WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
+@property (nonatomic, nullable, copy) NSNumber *standardVolumeCapacity WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
 @property (nonatomic, nullable, copy) NSString *boundInterfaceIdentifier WK_API_AVAILABLE(macos(10.15.4), ios(13.4));
 @property (nonatomic) BOOL allowsCellularAccess WK_API_AVAILABLE(macos(10.15.4), ios(14.0));
 @property (nonatomic) BOOL legacyTLSEnabled WK_API_AVAILABLE(macos(10.15.4), ios(13.4));

Source/WebKit/UIProcess/API/Cocoa/_WKWebsiteDataStoreConfiguration.mm

@@ -544,6 +544,24 @@ - (void)setTotalQuotaRatio:(NSNumber *)totalQuotaRatio
     _configuration->setTotalQuotaRatio(ratio);
 }
 
+- (NSNumber *)standardVolumeCapacity
+{
+    auto capacity = _configuration->standardVolumeCapacity();
+    if (!capacity)
+        return nil;
+
+    return [NSNumber numberWithUnsignedLongLong:*capacity];
+}
+
+- (void)setStandardVolumeCapacity:(NSNumber *)standardVolumeCapacity
+{
+    std::optional<uint64_t> capacity;
+    if (standardVolumeCapacity)
+        capacity = [standardVolumeCapacity unsignedLongLongValue];
+
+    _configuration->setStandardVolumeCapacity(capacity);
+}
+
 - (NSNumber *)volumeCapacityOverride
 {
     auto capacity = _configuration->volumeCapacityOverride();

Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp

@@ -1930,6 +1930,7 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
     networkSessionParameters.perOriginStorageQuota = perOriginStorageQuota();
     networkSessionParameters.originQuotaRatio = originQuotaRatio();
     networkSessionParameters.totalQuotaRatio = m_configuration->totalQuotaRatio();
+    networkSessionParameters.standardVolumeCapacity = m_configuration->standardVolumeCapacity();
     networkSessionParameters.volumeCapacityOverride = m_configuration->volumeCapacityOverride();
     networkSessionParameters.localStorageDirectory = resolvedLocalStorageDirectory();
     createHandleFromResolvedPathIfPossible(networkSessionParameters.localStorageDirectory, networkSessionParameters.localStorageDirectoryExtensionHandle);

Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h

@@ -385,6 +385,15 @@ class WebsiteDataStore : public API::ObjectImpl<API::Object::Type::WebsiteDataSt
     static String defaultJavaScriptConfigurationDirectory(const String& baseDataDirectory = nullString());
 
     static constexpr uint64_t defaultPerOriginQuota() { return 1000 * MB; }
+    static constexpr uint64_t defaultStandardVolumeCapacity() {
+#if PLATFORM(MAC)
+        return 128 * GB;
+#elif PLATFORM(IOS)
+        return 64 * GB;
+#else
+        return 16 * GB;
+#endif
+    }
     static std::optional<double> defaultOriginQuotaRatio();
     static std::optional<double> defaultTotalQuotaRatio();
     static UnifiedOriginStorageLevel defaultUnifiedOriginStorageLevel();

Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreConfiguration.cpp

@@ -38,6 +38,7 @@ WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(IsPersistent isPers
     , m_perOriginStorageQuota(WebsiteDataStore::defaultPerOriginQuota())
     , m_originQuotaRatio(WebsiteDataStore::defaultOriginQuotaRatio())
     , m_totalQuotaRatio(WebsiteDataStore::defaultTotalQuotaRatio())
+    , m_standardVolumeCapacity(WebsiteDataStore::defaultStandardVolumeCapacity())
 {
     if (isPersistent == IsPersistent::Yes && shouldInitializePaths == ShouldInitializePaths::Yes) {
 #if PLATFORM(GTK) || PLATFORM(WPE)
@@ -66,6 +67,7 @@ WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(const UUID& identif
     , m_perOriginStorageQuota(WebsiteDataStore::defaultPerOriginQuota())
     , m_originQuotaRatio(WebsiteDataStore::defaultOriginQuotaRatio())
     , m_totalQuotaRatio(WebsiteDataStore::defaultTotalQuotaRatio())
+    , m_standardVolumeCapacity(WebsiteDataStore::defaultStandardVolumeCapacity())
 #if PLATFORM(IOS)
     , m_pcmMachServiceName("com.apple.webkit.adattributiond.service"_s)
 #endif
@@ -86,6 +88,7 @@ WebsiteDataStoreConfiguration::WebsiteDataStoreConfiguration(const String& baseC
     , m_perOriginStorageQuota(WebsiteDataStore::defaultPerOriginQuota())
     , m_originQuotaRatio(WebsiteDataStore::defaultOriginQuotaRatio())
     , m_totalQuotaRatio(WebsiteDataStore::defaultTotalQuotaRatio())
+    , m_standardVolumeCapacity(WebsiteDataStore::defaultStandardVolumeCapacity())
 {
     initializePaths();
 }
@@ -134,6 +137,7 @@ Ref<WebsiteDataStoreConfiguration> WebsiteDataStoreConfiguration::copy() const
     copy->m_perOriginStorageQuota = this->m_perOriginStorageQuota;
     copy->m_originQuotaRatio = this->m_originQuotaRatio;
     copy->m_totalQuotaRatio = this->m_totalQuotaRatio;
+    copy->m_standardVolumeCapacity = this->m_standardVolumeCapacity;
     copy->m_volumeCapacityOverride = this->m_volumeCapacityOverride;
     copy->m_networkCacheDirectory = this->m_networkCacheDirectory;
     copy->m_applicationCacheDirectory = this->m_applicationCacheDirectory;