Clearing Website data for a given session should not shut down cached processes for...
[WebKit.git] / Source / WebKit / UIProcess / WebProcessProxy.h
1 /*
2  * Copyright (C) 2010-2019 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "APIUserInitiatedAction.h"
29 #include "AuxiliaryProcessProxy.h"
30 #include "BackgroundProcessResponsivenessTimer.h"
31 #include "MessageReceiverMap.h"
32 #include "PluginInfoStore.h"
33 #include "ProcessLauncher.h"
34 #include "ProcessTerminationReason.h"
35 #include "ProcessThrottler.h"
36 #include "ProcessThrottlerClient.h"
37 #include "ResponsivenessTimer.h"
38 #include "VisibleWebPageCounter.h"
39 #include "WebConnectionToWebProcess.h"
40 #include "WebPageProxyIdentifier.h"
41 #include "WebProcessProxyMessages.h"
42 #include <WebCore/FrameIdentifier.h>
43 #include <WebCore/PageIdentifier.h>
44 #include <WebCore/ProcessIdentifier.h>
45 #include <WebCore/RegistrableDomain.h>
46 #include <WebCore/SharedStringHash.h>
47 #include <memory>
48 #include <pal/SessionID.h>
49 #include <wtf/Forward.h>
50 #include <wtf/HashMap.h>
51 #include <wtf/HashSet.h>
52 #include <wtf/RefCounted.h>
53 #include <wtf/RefPtr.h>
54
55 namespace API {
56 class Navigation;
57 class PageConfiguration;
58 }
59
60 namespace WebCore {
61 class DeferrableOneShotTimer;
62 class ResourceRequest;
63 struct PluginInfo;
64 struct SecurityOriginData;
65 }
66
67 namespace WebKit {
68
69 class NetworkProcessProxy;
70 class ObjCObjectGraph;
71 class PageClient;
72 class ProvisionalPageProxy;
73 class UserMediaCaptureManagerProxy;
74 class VisitedLinkStore;
75 class WebBackForwardListItem;
76 class WebFrameProxy;
77 class WebPageGroup;
78 class WebPageProxy;
79 class WebProcessPool;
80 class WebUserContentControllerProxy;
81 class WebsiteDataStore;
82 enum class WebsiteDataType;
83 struct WebNavigationDataStore;
84 struct WebPageCreationParameters;
85 struct WebPreferencesStore;
86 struct WebsiteData;
87
88 #if PLATFORM(IOS_FAMILY)
89 enum ForegroundWebProcessCounterType { };
90 typedef RefCounter<ForegroundWebProcessCounterType> ForegroundWebProcessCounter;
91 typedef ForegroundWebProcessCounter::Token ForegroundWebProcessToken;
92 enum BackgroundWebProcessCounterType { };
93 typedef RefCounter<BackgroundWebProcessCounterType> BackgroundWebProcessCounter;
94 typedef BackgroundWebProcessCounter::Token BackgroundWebProcessToken;
95 #endif
96
97 class WebProcessProxy : public AuxiliaryProcessProxy, public ResponsivenessTimer::Client, public ThreadSafeRefCounted<WebProcessProxy>, public CanMakeWeakPtr<WebProcessProxy>, private ProcessThrottlerClient {
98 public:
99     typedef HashMap<WebCore::FrameIdentifier, RefPtr<WebFrameProxy>> WebFrameProxyMap;
100     typedef HashMap<WebPageProxyIdentifier, WebPageProxy*> WebPageProxyMap;
101     typedef HashMap<uint64_t, RefPtr<API::UserInitiatedAction>> UserInitiatedActionMap;
102
103     enum class IsPrewarmed {
104         No,
105         Yes
106     };
107
108     enum class ShouldLaunchProcess : bool { No, Yes };
109
110     static Ref<WebProcessProxy> create(WebProcessPool&, WebsiteDataStore*, IsPrewarmed, ShouldLaunchProcess = ShouldLaunchProcess::Yes);
111     static Ref<WebProcessProxy> createForServiceWorkers(WebProcessPool&, WebCore::RegistrableDomain&&, WebsiteDataStore&);
112
113     ~WebProcessProxy();
114
115     static void forWebPagesWithOrigin(PAL::SessionID, const WebCore::SecurityOriginData&, const Function<void(WebPageProxy&)>&);
116
117     WebConnection* webConnection() const { return m_webConnection.get(); }
118
119     unsigned suspendedPageCount() const { return m_suspendedPageCount; }
120     void incrementSuspendedPageCount();
121     void decrementSuspendedPageCount();
122
123     WebProcessPool* processPoolIfExists() const;
124     WebProcessPool& processPool() const;
125
126     WebCore::RegistrableDomain registrableDomain() const { return m_registrableDomain.valueOr(WebCore::RegistrableDomain { }); }
127     void setIsInProcessCache(bool);
128     bool isInProcessCache() const { return m_isInProcessCache; }
129
130     WebsiteDataStore& websiteDataStore() const { ASSERT(m_websiteDataStore); return *m_websiteDataStore; }
131     void setWebsiteDataStore(WebsiteDataStore&);
132     
133     PAL::SessionID sessionID() const;
134
135     static WebProcessProxy* processForIdentifier(WebCore::ProcessIdentifier);
136     static WebPageProxy* webPage(WebPageProxyIdentifier);
137     Ref<WebPageProxy> createWebPage(PageClient&, Ref<API::PageConfiguration>&&);
138
139     enum class BeginsUsingDataStore : bool { No, Yes };
140     void addExistingWebPage(WebPageProxy&, BeginsUsingDataStore);
141
142     enum class EndsUsingDataStore : bool { No, Yes };
143     void removeWebPage(WebPageProxy&, EndsUsingDataStore);
144
145     void addProvisionalPageProxy(ProvisionalPageProxy&);
146     void removeProvisionalPageProxy(ProvisionalPageProxy&);
147     
148     typename WebPageProxyMap::ValuesConstIteratorRange pages() const { return m_pageMap.values(); }
149     unsigned pageCount() const { return m_pageMap.size(); }
150     unsigned provisionalPageCount() const { return m_provisionalPages.size(); }
151     unsigned visiblePageCount() const { return m_visiblePageCounter.value(); }
152
153     void activePagesDomainsForTesting(CompletionHandler<void(Vector<String>&&)>&&); // This is what is reported to ActivityMonitor.
154
155     bool isRunningServiceWorkers() const { return !!m_serviceWorkerInformation; }
156
157     void didCreateWebPageInProcess(WebCore::PageIdentifier);
158
159     void addVisitedLinkStoreUser(VisitedLinkStore&, WebPageProxyIdentifier);
160     void removeVisitedLinkStoreUser(VisitedLinkStore&, WebPageProxyIdentifier);
161
162     void addWebUserContentControllerProxy(WebUserContentControllerProxy&, WebPageCreationParameters&);
163     void didDestroyWebUserContentControllerProxy(WebUserContentControllerProxy&);
164
165     RefPtr<API::UserInitiatedAction> userInitiatedActivity(uint64_t);
166
167     ResponsivenessTimer& responsivenessTimer() { return m_responsivenessTimer; }
168     bool isResponsive() const;
169
170     WebFrameProxy* webFrame(WebCore::FrameIdentifier) const;
171     bool canCreateFrame(WebCore::FrameIdentifier) const;
172     void frameCreated(WebCore::FrameIdentifier, WebFrameProxy&);
173     void disconnectFramesFromPage(WebPageProxy*); // Including main frame.
174     size_t frameCountInPage(WebPageProxy*) const; // Including main frame.
175
176     VisibleWebPageToken visiblePageToken() const;
177
178     void updateTextCheckerState();
179
180     void willAcquireUniversalFileReadSandboxExtension() { m_mayHaveUniversalFileReadSandboxExtension = true; }
181     void assumeReadAccessToBaseURL(WebPageProxy&, const String&);
182     bool hasAssumedReadAccessToURL(const URL&) const;
183
184     bool checkURLReceivedFromWebProcess(const String&);
185     bool checkURLReceivedFromWebProcess(const URL&);
186
187     static bool fullKeyboardAccessEnabled();
188
189     void didSaveToPageCache();
190     void releasePageCache();
191
192     void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, CompletionHandler<void(WebsiteData)>&&);
193     void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&&);
194     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
195
196 #if ENABLE(RESOURCE_LOAD_STATISTICS)
197     static void notifyPageStatisticsAndDataRecordsProcessed();
198     static void notifyPageStatisticsTelemetryFinished(API::Object* messageBody);
199
200     static void notifyWebsiteDataDeletionForRegistrableDomainsFinished();
201     static void notifyWebsiteDataScanForRegistrableDomainsFinished();
202 #endif
203
204     void enableSuddenTermination();
205     void disableSuddenTermination();
206     bool isSuddenTerminationEnabled() { return !m_numberOfTimesSuddenTerminationWasDisabled; }
207
208     void requestTermination(ProcessTerminationReason);
209
210     void stopResponsivenessTimer();
211
212     RefPtr<API::Object> transformHandlesToObjects(API::Object*);
213     static RefPtr<API::Object> transformObjectsToHandles(API::Object*);
214
215 #if PLATFORM(COCOA)
216     RefPtr<ObjCObjectGraph> transformHandlesToObjects(ObjCObjectGraph&);
217     static RefPtr<ObjCObjectGraph> transformObjectsToHandles(ObjCObjectGraph&);
218 #endif
219
220     void windowServerConnectionStateChanged();
221
222     void processReadyToSuspend();
223     void didCancelProcessSuspension();
224
225     void setIsHoldingLockedFiles(bool);
226
227     ProcessThrottler& throttler() { return m_throttler; }
228
229     void isResponsive(CompletionHandler<void(bool isWebProcessResponsive)>&&);
230     void isResponsiveWithLazyStop();
231     void didReceiveMainThreadPing();
232     void didReceiveBackgroundResponsivenessPing();
233
234     void memoryPressureStatusChanged(bool isUnderMemoryPressure) { m_isUnderMemoryPressure = isUnderMemoryPressure; }
235     bool isUnderMemoryPressure() const { return m_isUnderMemoryPressure; }
236     void didExceedInactiveMemoryLimitWhileActive();
237
238     void processTerminated();
239
240     void didExceedCPULimit();
241     void didExceedActiveMemoryLimit();
242     void didExceedInactiveMemoryLimit();
243
244     void didCommitProvisionalLoad() { m_hasCommittedAnyProvisionalLoads = true; }
245     bool hasCommittedAnyProvisionalLoads() const { return m_hasCommittedAnyProvisionalLoads; }
246
247 #if PLATFORM(WATCHOS)
248     void takeBackgroundActivityTokenForFullscreenInput();
249     void releaseBackgroundActivityTokenForFullscreenInput();
250 #endif
251
252     bool isPrewarmed() const { return m_isPrewarmed; }
253     void markIsNoLongerInPrewarmedPool();
254
255 #if PLATFORM(COCOA)
256     Vector<String> mediaMIMETypes() const;
257     void cacheMediaMIMETypes(const Vector<String>&);
258 #endif
259
260 #if PLATFORM(MAC)
261     void requestHighPerformanceGPU();
262     void releaseHighPerformanceGPU();
263 #endif
264
265 #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
266     void startDisplayLink(unsigned observerID, uint32_t displayID);
267     void stopDisplayLink(unsigned observerID, uint32_t displayID);
268 #endif
269
270     // Called when the web process has crashed or we know that it will terminate soon.
271     // Will potentially cause the WebProcessProxy object to be freed.
272     void shutDown();
273
274     class ScopePreventingShutdown {
275     public:
276         explicit ScopePreventingShutdown(WebProcessProxy& process)
277             : m_process(process)
278         {
279             ++(m_process->m_shutdownPreventingScopeCount);
280         }
281
282         ~ScopePreventingShutdown()
283         {
284             ASSERT(m_process->m_shutdownPreventingScopeCount);
285             if (!--(m_process->m_shutdownPreventingScopeCount))
286                 m_process->maybeShutDown();
287         }
288
289     private:
290         Ref<WebProcessProxy> m_process;
291     };
292
293     ScopePreventingShutdown makeScopePreventingShutdown() { return ScopePreventingShutdown { *this }; }
294
295     void didStartProvisionalLoadForMainFrame(const URL&);
296
297     // ProcessThrottlerClient
298     void sendProcessWillSuspendImminently() override;
299     void sendPrepareToSuspend() override;
300     void sendCancelPrepareToSuspend() override;
301     void sendProcessDidResume() override;
302     void didSetAssertionState(AssertionState) override;
303
304 #if PLATFORM(COCOA)
305     enum SandboxExtensionType : uint32_t {
306         None = 0,
307         Video = 1 << 0,
308         Audio = 1 << 1
309     };
310
311     typedef uint32_t MediaCaptureSandboxExtensions;
312
313     bool hasVideoCaptureExtension() const { return m_mediaCaptureSandboxExtensions & Video; }
314     void grantVideoCaptureExtension() { m_mediaCaptureSandboxExtensions |= Video; }
315     void revokeVideoCaptureExtension() { m_mediaCaptureSandboxExtensions &= ~Video; }
316
317     bool hasAudioCaptureExtension() const { return m_mediaCaptureSandboxExtensions & Audio; }
318     void grantAudioCaptureExtension() { m_mediaCaptureSandboxExtensions |= Audio; }
319     void revokeAudioCaptureExtension() { m_mediaCaptureSandboxExtensions &= ~Audio; }
320 #endif
321
322 #if PLATFORM(IOS_FAMILY)
323     void unblockAccessibilityServerIfNeeded();
324 #endif
325
326 #if PLATFORM(IOS_FAMILY)
327     void processWasUnexpectedlyUnsuspended();
328 #endif
329
330     void webPageMediaStateDidChange(WebPageProxy&);
331
332     void ref() final { ThreadSafeRefCounted::ref(); }
333     void deref() final { ThreadSafeRefCounted::deref(); }
334
335 #if ENABLE(SERVICE_WORKER)
336     void establishServiceWorkerContext(const WebPreferencesStore&);
337     void setServiceWorkerUserAgent(const String&);
338     void updateServiceWorkerPreferencesStore(const WebPreferencesStore&);
339     bool hasServiceWorkerPageProxy(WebPageProxyIdentifier pageProxyID) { return m_serviceWorkerInformation && m_serviceWorkerInformation->serviceWorkerPageProxyID == pageProxyID; }
340 #endif
341
342 protected:
343     WebProcessProxy(WebProcessPool&, WebsiteDataStore*, IsPrewarmed);
344
345     // AuxiliaryProcessProxy
346     void getLaunchOptions(ProcessLauncher::LaunchOptions&) override;
347     void platformGetLaunchOptions(ProcessLauncher::LaunchOptions&) override;
348     void connectionWillOpen(IPC::Connection&) override;
349     void processWillShutDown(IPC::Connection&) override;
350     bool shouldSendPendingMessage(const PendingMessage&) final;
351     
352     // ProcessLauncher::Client
353     void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) override;
354
355 #if PLATFORM(COCOA)
356     void cacheMediaMIMETypesInternal(const Vector<String>&);
357 #endif
358
359     bool shouldConfigureJSCForTesting() const final;
360     bool isJITEnabled() const final;
361
362     void validateFreezerStatus();
363
364 private:
365     // IPC message handlers.
366     void updateBackForwardItem(const BackForwardListItemState&);
367     void didDestroyFrame(WebCore::FrameIdentifier);
368     void didDestroyUserGestureToken(uint64_t);
369
370     bool canBeAddedToWebProcessCache() const;
371     void shouldTerminate(CompletionHandler<void(bool)>&&);
372
373     bool hasProvisionalPageWithID(WebPageProxyIdentifier) const;
374     bool isAllowedToUpdateBackForwardItem(WebBackForwardListItem&) const;
375
376     // Plugins
377 #if ENABLE(NETSCAPE_PLUGIN_API)
378     void getPlugins(bool refresh, CompletionHandler<void(Vector<WebCore::PluginInfo>&& plugins, Vector<WebCore::PluginInfo>&& applicationPlugins, Optional<Vector<WebCore::SupportedPluginIdentifier>>&&)>&&);
379 #endif // ENABLE(NETSCAPE_PLUGIN_API)
380 #if ENABLE(NETSCAPE_PLUGIN_API)
381     void getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&&);
382 #endif
383     void addPlugInAutoStartOriginHash(String&& pageOrigin, uint32_t hash);
384     void plugInDidReceiveUserInteraction(uint32_t hash);
385     
386     void getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&&);
387
388     bool platformIsBeingDebugged() const;
389     bool shouldAllowNonValidInjectedCode() const;
390
391     static const HashSet<String>& platformPathsWithAssumedReadAccess();
392
393     void updateBackgroundResponsivenessTimer();
394
395     void processDidTerminateOrFailedToLaunch();
396
397     bool isReleaseLoggingAllowed() const;
398
399     // IPC::Connection::Client
400     friend class WebConnectionToWebProcess;
401     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
402     void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&) override;
403     void didClose(IPC::Connection&) override;
404     void didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference messageReceiverName, IPC::StringReference messageName) override;
405
406     // ResponsivenessTimer::Client
407     void didBecomeUnresponsive() override;
408     void didBecomeResponsive() override;
409     void willChangeIsResponsive() override;
410     void didChangeIsResponsive() override;
411     bool mayBecomeUnresponsive() override;
412
413     // Implemented in generated WebProcessProxyMessageReceiver.cpp
414     void didReceiveWebProcessProxyMessage(IPC::Connection&, IPC::Decoder&);
415     void didReceiveSyncWebProcessProxyMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&);
416
417     bool canTerminateAuxiliaryProcess();
418
419     void didCollectPrewarmInformation(const WebCore::RegistrableDomain&, const WebCore::PrewarmInformation&);
420
421     void logDiagnosticMessageForResourceLimitTermination(const String& limitKey);
422     
423     void updateRegistrationWithDataStore();
424
425     void maybeShutDown();
426
427     enum class IsWeak { No, Yes };
428     template<typename T> class WeakOrStrongPtr {
429     public:
430         WeakOrStrongPtr(T& object, IsWeak isWeak)
431             : m_isWeak(isWeak)
432             , m_weakObject(makeWeakPtr(object))
433         {
434             updateStrongReference();
435         }
436
437         void setIsWeak(IsWeak isWeak)
438         {
439             m_isWeak = isWeak;
440             updateStrongReference();
441         }
442
443         T* get() const { return m_weakObject.get(); }
444         T* operator->() const { return m_weakObject.get(); }
445         T& operator*() const { return *m_weakObject; }
446         explicit operator bool() const { return !!m_weakObject; }
447
448     private:
449         void updateStrongReference()
450         {
451             m_strongObject = m_isWeak == IsWeak::Yes ? nullptr : m_weakObject.get();
452         }
453
454         IsWeak m_isWeak;
455         WeakPtr<T> m_weakObject;
456         RefPtr<T> m_strongObject;
457     };
458
459     ResponsivenessTimer m_responsivenessTimer;
460     BackgroundProcessResponsivenessTimer m_backgroundResponsivenessTimer;
461     
462     RefPtr<WebConnectionToWebProcess> m_webConnection;
463     WeakOrStrongPtr<WebProcessPool> m_processPool; // Pre-warmed and cached processes do not hold a strong reference to their pool.
464
465     bool m_mayHaveUniversalFileReadSandboxExtension; // True if a read extension for "/" was ever granted - we don't track whether WebProcess still has it.
466     HashSet<String> m_localPathsWithAssumedReadAccess;
467
468     WebPageProxyMap m_pageMap;
469     WebFrameProxyMap m_frameMap;
470     HashSet<ProvisionalPageProxy*> m_provisionalPages;
471     UserInitiatedActionMap m_userInitiatedActionMap;
472
473     HashMap<VisitedLinkStore*, HashSet<WebPageProxyIdentifier>> m_visitedLinkStoresWithUsers;
474     HashSet<WebUserContentControllerProxy*> m_webUserContentControllerProxies;
475
476     int m_numberOfTimesSuddenTerminationWasDisabled;
477     ProcessThrottler m_throttler;
478     ProcessThrottler::BackgroundActivityToken m_tokenForHoldingLockedFiles;
479 #if PLATFORM(IOS_FAMILY)
480     ForegroundWebProcessToken m_foregroundToken;
481     BackgroundWebProcessToken m_backgroundToken;
482     bool m_hasSentMessageToUnblockAccessibilityServer { false };
483     std::unique_ptr<WebCore::DeferrableOneShotTimer> m_unexpectedActivityTimer;
484 #endif
485
486     HashMap<String, uint64_t> m_pageURLRetainCountMap;
487
488     Optional<WebCore::RegistrableDomain> m_registrableDomain;
489     bool m_isInProcessCache { false };
490
491     enum class NoOrMaybe { No, Maybe } m_isResponsive;
492     Vector<CompletionHandler<void(bool webProcessIsResponsive)>> m_isResponsiveCallbacks;
493
494     VisibleWebPageCounter m_visiblePageCounter;
495
496     RefPtr<WebsiteDataStore> m_websiteDataStore;
497
498     bool m_isUnderMemoryPressure { false };
499
500 #if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)
501     std::unique_ptr<UserMediaCaptureManagerProxy> m_userMediaCaptureManagerProxy;
502 #endif
503
504     unsigned m_suspendedPageCount { 0 };
505     unsigned m_shutdownPreventingScopeCount { 0 };
506     bool m_hasCommittedAnyProvisionalLoads { false };
507     bool m_isPrewarmed;
508     bool m_hasAudibleWebPage { false };
509
510 #if PLATFORM(WATCHOS)
511     ProcessThrottler::BackgroundActivityToken m_backgroundActivityTokenForFullscreenFormControls;
512 #endif
513
514 #if PLATFORM(COCOA)
515     MediaCaptureSandboxExtensions m_mediaCaptureSandboxExtensions { SandboxExtensionType::None };
516 #endif
517
518     struct ServiceWorkerInformation {
519         WebPageProxyIdentifier serviceWorkerPageProxyID;
520         WebCore::PageIdentifier serviceWorkerPageID;
521     };
522     Optional<ServiceWorkerInformation> m_serviceWorkerInformation;
523 };
524
525 } // namespace WebKit