Drop FrameLoaderClient::sessionID()
[WebKit-https.git] / Source / WebCore / loader / EmptyClients.cpp
1 /*
2  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
3  * Copyright (C) 2008-2019 Apple Inc. All rights reserved.
4  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "EmptyClients.h"
30
31 #include "ApplicationCacheStorage.h"
32 #include "BackForwardClient.h"
33 #include "CacheStorageProvider.h"
34 #include "ColorChooser.h"
35 #include "ContextMenuClient.h"
36 #include "CookieJar.h"
37 #include "DOMPasteAccess.h"
38 #include "DataListSuggestionPicker.h"
39 #include "DatabaseProvider.h"
40 #include "DiagnosticLoggingClient.h"
41 #include "DocumentFragment.h"
42 #include "DocumentLoader.h"
43 #include "DragClient.h"
44 #include "EditorClient.h"
45 #include "EmptyFrameLoaderClient.h"
46 #include "FileChooser.h"
47 #include "FormState.h"
48 #include "Frame.h"
49 #include "FrameLoaderClient.h"
50 #include "FrameNetworkingContext.h"
51 #include "HTMLFormElement.h"
52 #include "HistoryItem.h"
53 #include "InProcessIDBServer.h"
54 #include "InspectorClient.h"
55 #include "LibWebRTCProvider.h"
56 #include "NetworkStorageSession.h"
57 #include "Page.h"
58 #include "PageConfiguration.h"
59 #include "PaymentCoordinatorClient.h"
60 #include "PluginInfoProvider.h"
61 #include "ProgressTrackerClient.h"
62 #include "SecurityOriginData.h"
63 #include "SocketProvider.h"
64 #include "StorageArea.h"
65 #include "StorageNamespace.h"
66 #include "StorageNamespaceProvider.h"
67 #include "StorageType.h"
68 #include "TextCheckerClient.h"
69 #include "ThreadableWebSocketChannel.h"
70 #include "UserContentProvider.h"
71 #include "VisitedLinkStore.h"
72 #include <JavaScriptCore/HeapInlines.h>
73 #include <pal/SessionID.h>
74 #include <wtf/NeverDestroyed.h>
75
76 #if ENABLE(CONTENT_EXTENSIONS)
77 #include "CompiledContentExtension.h"
78 #endif
79
80 #if USE(QUICK_LOOK)
81 #include "PreviewLoaderClient.h"
82 #endif
83
84 namespace WebCore {
85
86 class UserMessageHandlerDescriptor;
87
88 class EmptyBackForwardClient final : public BackForwardClient {
89     void addItem(Ref<HistoryItem>&&) final { }
90     void goToItem(HistoryItem&) final { }
91     RefPtr<HistoryItem> itemAtIndex(int) final { return nullptr; }
92     unsigned backListCount() const final { return 0; }
93     unsigned forwardListCount() const final { return 0; }
94     void close() final { }
95 };
96
97 #if ENABLE(CONTEXT_MENUS)
98
99 class EmptyContextMenuClient final : public ContextMenuClient {
100     void contextMenuDestroyed() final { }
101
102     void downloadURL(const URL&) final { }
103     void searchWithGoogle(const Frame*) final { }
104     void lookUpInDictionary(Frame*) final { }
105     bool isSpeaking() final { return false; }
106     void speak(const String&) final { }
107     void stopSpeaking() final { }
108
109 #if PLATFORM(COCOA)
110     void searchWithSpotlight() final { }
111 #endif
112
113 #if PLATFORM(GTK)
114     void insertEmoji(Frame&) final { }
115 #endif
116
117 #if USE(ACCESSIBILITY_CONTEXT_MENUS)
118     void showContextMenu() final { }
119 #endif
120 };
121
122 #endif // ENABLE(CONTEXT_MENUS)
123
124 class EmptyDatabaseProvider final : public DatabaseProvider {
125 #if ENABLE(INDEXED_DATABASE)
126     IDBClient::IDBConnectionToServer& idbConnectionToServerForSession(const PAL::SessionID& sessionID) final
127     {
128         static auto& sharedConnection = InProcessIDBServer::create(sessionID).leakRef();
129         return sharedConnection.connectionToServer();
130     }
131 #endif
132 };
133
134 class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
135     void logDiagnosticMessage(const String&, const String&, ShouldSample) final { }
136     void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) final { }
137     void logDiagnosticMessageWithValue(const String&, const String&, double, unsigned, ShouldSample) final { }
138     void logDiagnosticMessageWithEnhancedPrivacy(const String&, const String&, ShouldSample) final { }
139     void logDiagnosticMessageWithValueDictionary(const String&, const String&, const ValueDictionary&, ShouldSample) final { }
140 };
141
142 #if ENABLE(DRAG_SUPPORT)
143
144 class EmptyDragClient final : public DragClient {
145     void willPerformDragDestinationAction(DragDestinationAction, const DragData&) final { }
146     void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) final { }
147     DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) final { return DragSourceActionNone; }
148     void startDrag(DragItem, DataTransfer&, Frame&) final { }
149     void dragControllerDestroyed() final { }
150 };
151
152 #endif // ENABLE(DRAG_SUPPORT)
153
154 class EmptyEditorClient final : public EditorClient {
155     WTF_MAKE_FAST_ALLOCATED;
156
157 public:
158     EmptyEditorClient() = default;
159
160 private:
161     bool shouldDeleteRange(Range*) final { return false; }
162     bool smartInsertDeleteEnabled() final { return false; }
163     bool isSelectTrailingWhitespaceEnabled() const final { return false; }
164     bool isContinuousSpellCheckingEnabled() final { return false; }
165     void toggleContinuousSpellChecking() final { }
166     bool isGrammarCheckingEnabled() final { return false; }
167     void toggleGrammarChecking() final { }
168     int spellCheckerDocumentTag() final { return -1; }
169
170     bool shouldBeginEditing(Range*) final { return false; }
171     bool shouldEndEditing(Range*) final { return false; }
172     bool shouldInsertNode(Node*, Range*, EditorInsertAction) final { return false; }
173     bool shouldInsertText(const String&, Range*, EditorInsertAction) final { return false; }
174     bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) final { return false; }
175
176     bool shouldApplyStyle(StyleProperties*, Range*) final { return false; }
177     void didApplyStyle() final { }
178     bool shouldMoveRangeAfterDelete(Range*, Range*) final { return false; }
179
180     void didBeginEditing() final { }
181     void respondToChangedContents() final { }
182     void respondToChangedSelection(Frame*) final { }
183     void updateEditorStateAfterLayoutIfEditabilityChanged() final { }
184     void discardedComposition(Frame*) final { }
185     void canceledComposition() final { }
186     void didUpdateComposition() final { }
187     void didEndEditing() final { }
188     void didEndUserTriggeredSelectionChanges() final { }
189     void willWriteSelectionToPasteboard(Range*) final { }
190     void didWriteSelectionToPasteboard() final { }
191     void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) final { }
192     void requestCandidatesForSelection(const VisibleSelection&) final { }
193     void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) final { }
194
195     void registerUndoStep(UndoStep&) final;
196     void registerRedoStep(UndoStep&) final;
197     void clearUndoRedoOperations() final { }
198
199     DOMPasteAccessResponse requestDOMPasteAccess(const String&) final { return DOMPasteAccessResponse::DeniedForGesture; }
200
201     bool canCopyCut(Frame*, bool defaultValue) const final { return defaultValue; }
202     bool canPaste(Frame*, bool defaultValue) const final { return defaultValue; }
203     bool canUndo() const final { return false; }
204     bool canRedo() const final { return false; }
205
206     void undo() final { }
207     void redo() final { }
208
209     void handleKeyboardEvent(KeyboardEvent&) final { }
210     void handleInputMethodKeydown(KeyboardEvent&) final { }
211
212     void textFieldDidBeginEditing(Element*) final { }
213     void textFieldDidEndEditing(Element*) final { }
214     void textDidChangeInTextField(Element*) final { }
215     bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) final { return false; }
216     void textWillBeDeletedInTextField(Element*) final { }
217     void textDidChangeInTextArea(Element*) final { }
218     void overflowScrollPositionChanged() final { }
219
220 #if PLATFORM(IOS_FAMILY)
221     void startDelayingAndCoalescingContentChangeNotifications() final { }
222     void stopDelayingAndCoalescingContentChangeNotifications() final { }
223     bool hasRichlyEditableSelection() final { return false; }
224     int getPasteboardItemsCount() final { return 0; }
225     RefPtr<DocumentFragment> documentFragmentFromDelegate(int) final { return nullptr; }
226     bool performsTwoStepPaste(DocumentFragment*) final { return false; }
227     void updateStringForFind(const String&) final { }
228 #endif
229
230     bool performTwoStepDrop(DocumentFragment&, Range&, bool) final { return false; }
231
232 #if PLATFORM(COCOA)
233     void setInsertionPasteboard(const String&) final { };
234 #endif
235
236 #if USE(APPKIT)
237     void uppercaseWord() final { }
238     void lowercaseWord() final { }
239     void capitalizeWord() final { }
240 #endif
241
242 #if USE(AUTOMATIC_TEXT_REPLACEMENT)
243     void showSubstitutionsPanel(bool) final { }
244     bool substitutionsPanelIsShowing() final { return false; }
245     void toggleSmartInsertDelete() final { }
246     bool isAutomaticQuoteSubstitutionEnabled() final { return false; }
247     void toggleAutomaticQuoteSubstitution() final { }
248     bool isAutomaticLinkDetectionEnabled() final { return false; }
249     void toggleAutomaticLinkDetection() final { }
250     bool isAutomaticDashSubstitutionEnabled() final { return false; }
251     void toggleAutomaticDashSubstitution() final { }
252     bool isAutomaticTextReplacementEnabled() final { return false; }
253     void toggleAutomaticTextReplacement() final { }
254     bool isAutomaticSpellingCorrectionEnabled() final { return false; }
255     void toggleAutomaticSpellingCorrection() final { }
256 #endif
257
258 #if PLATFORM(GTK)
259     bool shouldShowUnicodeMenu() final { return false; }
260 #endif
261
262     TextCheckerClient* textChecker() final { return &m_textCheckerClient; }
263
264     void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) final { }
265     void updateSpellingUIWithMisspelledWord(const String&) final { }
266     void showSpellingUI(bool) final { }
267     bool spellingUIIsShowing() final { return false; }
268
269     void willSetInputMethodState() final { }
270     void setInputMethodState(bool) final { }
271
272     bool canShowFontPanel() const final { return false; }
273
274     class EmptyTextCheckerClient final : public TextCheckerClient {
275         bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const final { return true; }
276         void ignoreWordInSpellDocument(const String&) final { }
277         void learnWord(const String&) final { }
278         void checkSpellingOfString(StringView, int*, int*) final { }
279         String getAutoCorrectSuggestionForMisspelledWord(const String&) final { return { }; }
280         void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) final { }
281
282 #if USE(UNIFIED_TEXT_CHECKING)
283         Vector<TextCheckingResult> checkTextOfParagraph(StringView, OptionSet<TextCheckingType>, const VisibleSelection&) final { return Vector<TextCheckingResult>(); }
284 #endif
285
286         void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) final { }
287         void requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&) final;
288     };
289
290     EmptyTextCheckerClient m_textCheckerClient;
291 };
292
293 class EmptyFrameNetworkingContext final : public FrameNetworkingContext {
294 public:
295     static Ref<EmptyFrameNetworkingContext> create() { return adoptRef(*new EmptyFrameNetworkingContext); }
296
297 private:
298     EmptyFrameNetworkingContext();
299
300     bool shouldClearReferrerOnHTTPSToHTTPRedirect() const { return true; }
301     NetworkStorageSession* storageSession() const final { return nullptr; }
302
303 #if PLATFORM(COCOA)
304     bool localFileContentSniffingEnabled() const { return false; }
305     SchedulePairHashSet* scheduledRunLoopPairs() const { return nullptr; }
306     RetainPtr<CFDataRef> sourceApplicationAuditData() const { return nullptr; };
307 #endif
308
309 #if PLATFORM(COCOA) || PLATFORM(WIN)
310     ResourceError blockedError(const ResourceRequest&) const final { return { }; }
311 #endif
312 };
313
314 class EmptyInspectorClient final : public InspectorClient {
315     void inspectedPageDestroyed() final { }
316     Inspector::FrontendChannel* openLocalFrontend(InspectorController*) final { return nullptr; }
317     void bringFrontendToFront() final { }
318     void highlight() final { }
319     void hideHighlight() final { }
320 };
321
322 #if ENABLE(APPLE_PAY)
323
324 class EmptyPaymentCoordinatorClient final : public PaymentCoordinatorClient {
325     Optional<String> validatedPaymentNetwork(const String&) final { return WTF::nullopt; }
326     bool canMakePayments() final { return false; }
327     void canMakePaymentsWithActiveCard(const String&, const String&, CompletionHandler<void(bool)>&& completionHandler) final { callOnMainThread([completionHandler = WTFMove(completionHandler)]() mutable { completionHandler(false); }); }
328     void openPaymentSetup(const String&, const String&, CompletionHandler<void(bool)>&& completionHandler) final { callOnMainThread([completionHandler = WTFMove(completionHandler)]() mutable { completionHandler(false); }); }
329     bool showPaymentUI(const URL&, const Vector<URL>&, const ApplePaySessionPaymentRequest&) final { return false; }
330     void completeMerchantValidation(const PaymentMerchantSession&) final { }
331     void completeShippingMethodSelection(Optional<ShippingMethodUpdate>&&) final { }
332     void completeShippingContactSelection(Optional<ShippingContactUpdate>&&) final { }
333     void completePaymentMethodSelection(Optional<PaymentMethodUpdate>&&) final { }
334     void completePaymentSession(Optional<PaymentAuthorizationResult>&&) final { }
335     void cancelPaymentSession() final { }
336     void abortPaymentSession() final { }
337     void paymentCoordinatorDestroyed() final { }
338     bool supportsUnrestrictedApplePay() const final { return false; }
339 };
340
341 #endif
342
343 class EmptyPluginInfoProvider final : public PluginInfoProvider {
344     void refreshPlugins() final { };
345     Vector<PluginInfo> pluginInfo(Page&, Optional<Vector<SupportedPluginIdentifier>>&) final { return { }; }
346     Vector<PluginInfo> webVisiblePluginInfo(Page&, const URL&) final { return { }; }
347 };
348
349 class EmptyPopupMenu : public PopupMenu {
350 public:
351     EmptyPopupMenu() = default;
352 private:
353     void show(const IntRect&, FrameView*, int) final { }
354     void hide() final { }
355     void updateFromElement() final { }
356     void disconnectClient() final { }
357 };
358
359 class EmptyProgressTrackerClient final : public ProgressTrackerClient {
360     void willChangeEstimatedProgress() final { }
361     void didChangeEstimatedProgress() final { }
362     void progressStarted(Frame&) final { }
363     void progressEstimateChanged(Frame&) final { }
364     void progressFinished(Frame&) final { }
365 };
366
367 class EmptySearchPopupMenu : public SearchPopupMenu {
368 public:
369     EmptySearchPopupMenu()
370         : m_popup(adoptRef(*new EmptyPopupMenu))
371     {
372     }
373
374 private:
375     PopupMenu* popupMenu() final { return m_popup.ptr(); }
376     void saveRecentSearches(const AtomString&, const Vector<RecentSearch>&) final { }
377     void loadRecentSearches(const AtomString&, Vector<RecentSearch>&) final { }
378     bool enabled() final { return false; }
379
380     Ref<EmptyPopupMenu> m_popup;
381 };
382
383 class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {
384     struct EmptyStorageArea : public StorageArea {
385         unsigned length() final { return 0; }
386         String key(unsigned) final { return { }; }
387         String item(const String&) final { return { }; }
388         void setItem(Frame*, const String&, const String&, bool&) final { }
389         void removeItem(Frame*, const String&) final { }
390         void clear(Frame*) final { }
391         bool contains(const String&) final { return false; }
392         StorageType storageType() const final { return StorageType::Local; }
393         size_t memoryBytesUsedByCache() final { return 0; }
394     };
395
396     struct EmptyStorageNamespace final : public StorageNamespace {
397         explicit EmptyStorageNamespace(PAL::SessionID sessionID)
398             : m_sessionID(sessionID)
399         {
400         }
401     private:
402         Ref<StorageArea> storageArea(const SecurityOriginData&) final { return adoptRef(*new EmptyStorageArea); }
403         Ref<StorageNamespace> copy(Page&) final { return adoptRef(*new EmptyStorageNamespace { m_sessionID }); }
404         PAL::SessionID sessionID() const final { return m_sessionID; }
405         void setSessionIDForTesting(PAL::SessionID sessionID) final { m_sessionID = sessionID; };
406
407         PAL::SessionID m_sessionID;
408     };
409
410     Ref<StorageNamespace> createSessionStorageNamespace(Page&, unsigned) final;
411     Ref<StorageNamespace> createLocalStorageNamespace(unsigned, PAL::SessionID) final;
412     Ref<StorageNamespace> createTransientLocalStorageNamespace(SecurityOrigin&, unsigned, PAL::SessionID) final;
413
414 };
415
416 class EmptyUserContentProvider final : public UserContentProvider {
417     void forEachUserScript(Function<void(DOMWrapperWorld&, const UserScript&)>&&) const final { }
418     void forEachUserStyleSheet(Function<void(const UserStyleSheet&)>&&) const final { }
419 #if ENABLE(USER_MESSAGE_HANDLERS)
420     void forEachUserMessageHandler(Function<void(const UserMessageHandlerDescriptor&)>&&) const final { }
421 #endif
422 #if ENABLE(CONTENT_EXTENSIONS)
423     ContentExtensions::ContentExtensionsBackend& userContentExtensionBackend() final { static NeverDestroyed<ContentExtensions::ContentExtensionsBackend> backend; return backend.get(); };
424 #endif
425 };
426
427 class EmptyVisitedLinkStore final : public VisitedLinkStore {
428     bool isLinkVisited(Page&, SharedStringHash, const URL&, const AtomString&) final { return false; }
429     void addVisitedLink(Page&, SharedStringHash) final { }
430 };
431
432 RefPtr<PopupMenu> EmptyChromeClient::createPopupMenu(PopupMenuClient&) const
433 {
434     return adoptRef(*new EmptyPopupMenu);
435 }
436
437 RefPtr<SearchPopupMenu> EmptyChromeClient::createSearchPopupMenu(PopupMenuClient&) const
438 {
439     return adoptRef(*new EmptySearchPopupMenu);
440 }
441
442 #if ENABLE(INPUT_TYPE_COLOR)
443
444 std::unique_ptr<ColorChooser> EmptyChromeClient::createColorChooser(ColorChooserClient&, const Color&)
445 {
446     return nullptr;
447 }
448
449 #endif
450
451 #if ENABLE(DATALIST_ELEMENT)
452
453 std::unique_ptr<DataListSuggestionPicker> EmptyChromeClient::createDataListSuggestionPicker(DataListSuggestionsClient&)
454 {
455     return nullptr;
456 }
457
458 #endif
459
460 void EmptyChromeClient::runOpenPanel(Frame&, FileChooser&)
461 {
462 }
463     
464 void EmptyChromeClient::showShareSheet(ShareDataWithParsedURL&, CompletionHandler<void(bool)>&&)
465 {
466 }
467
468 void EmptyFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, FormState*, const String&, PolicyCheckIdentifier, FramePolicyFunction&&)
469 {
470 }
471
472 void EmptyFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, const ResourceResponse&, FormState*, PolicyDecisionMode, PolicyCheckIdentifier, FramePolicyFunction&&)
473 {
474 }
475
476 void EmptyFrameLoaderClient::dispatchWillSendSubmitEvent(Ref<FormState>&&)
477 {
478 }
479
480 void EmptyFrameLoaderClient::dispatchWillSubmitForm(FormState&, CompletionHandler<void()>&& completionHandler)
481 {
482     completionHandler();
483 }
484
485 Ref<DocumentLoader> EmptyFrameLoaderClient::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
486 {
487     return DocumentLoader::create(request, substituteData);
488 }
489
490 RefPtr<Frame> EmptyFrameLoaderClient::createFrame(const URL&, const String&, HTMLFrameOwnerElement&, const String&)
491 {
492     return nullptr;
493 }
494
495 RefPtr<Widget> EmptyFrameLoaderClient::createPlugin(const IntSize&, HTMLPlugInElement&, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool)
496 {
497     return nullptr;
498 }
499
500 RefPtr<Widget> EmptyFrameLoaderClient::createJavaAppletWidget(const IntSize&, HTMLAppletElement&, const URL&, const Vector<String>&, const Vector<String>&)
501 {
502     return nullptr;
503 }
504
505 inline EmptyFrameNetworkingContext::EmptyFrameNetworkingContext()
506     : FrameNetworkingContext { nullptr }
507 {
508 }
509
510 Ref<FrameNetworkingContext> EmptyFrameLoaderClient::createNetworkingContext()
511 {
512     return EmptyFrameNetworkingContext::create();
513 }
514
515 void EmptyEditorClient::EmptyTextCheckerClient::requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&)
516 {
517 }
518
519 void EmptyEditorClient::registerUndoStep(UndoStep&)
520 {
521 }
522
523 void EmptyEditorClient::registerRedoStep(UndoStep&)
524 {
525 }
526
527 Ref<StorageNamespace> EmptyStorageNamespaceProvider::createSessionStorageNamespace(Page& page, unsigned)
528 {
529     return adoptRef(*new EmptyStorageNamespace { page.sessionID() });
530 }
531
532 Ref<StorageNamespace> EmptyStorageNamespaceProvider::createLocalStorageNamespace(unsigned, PAL::SessionID sessionID)
533 {
534     return adoptRef(*new EmptyStorageNamespace { sessionID });
535 }
536
537 Ref<StorageNamespace> EmptyStorageNamespaceProvider::createTransientLocalStorageNamespace(SecurityOrigin&, unsigned, PAL::SessionID sessionID)
538 {
539     return adoptRef(*new EmptyStorageNamespace { sessionID });
540 }
541
542 class EmptyStorageSessionProvider : public StorageSessionProvider {
543     NetworkStorageSession* storageSession() const final { return nullptr; }
544 };
545
546 PageConfiguration pageConfigurationWithEmptyClients(PAL::SessionID sessionID)
547 {
548     PageConfiguration pageConfiguration {
549         sessionID,
550         makeUniqueRef<EmptyEditorClient>(),
551         SocketProvider::create(),
552         LibWebRTCProvider::create(),
553         CacheStorageProvider::create(),
554         adoptRef(*new EmptyBackForwardClient),
555         CookieJar::create(adoptRef(*new EmptyStorageSessionProvider))
556     };
557
558     static NeverDestroyed<EmptyChromeClient> dummyChromeClient;
559     pageConfiguration.chromeClient = &dummyChromeClient.get();
560
561 #if ENABLE(APPLE_PAY)
562     static NeverDestroyed<EmptyPaymentCoordinatorClient> dummyPaymentCoordinatorClient;
563     pageConfiguration.paymentCoordinatorClient = &dummyPaymentCoordinatorClient.get();
564 #endif
565
566 #if ENABLE(CONTEXT_MENUS)
567     static NeverDestroyed<EmptyContextMenuClient> dummyContextMenuClient;
568     pageConfiguration.contextMenuClient = &dummyContextMenuClient.get();
569 #endif
570
571 #if ENABLE(DRAG_SUPPORT)
572     static NeverDestroyed<EmptyDragClient> dummyDragClient;
573     pageConfiguration.dragClient = &dummyDragClient.get();
574 #endif
575
576     static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
577     pageConfiguration.inspectorClient = &dummyInspectorClient.get();
578
579     static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
580     pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
581
582     static NeverDestroyed<EmptyProgressTrackerClient> dummyProgressTrackerClient;
583     pageConfiguration.progressTrackerClient = &dummyProgressTrackerClient.get();
584
585     pageConfiguration.diagnosticLoggingClient = makeUnique<EmptyDiagnosticLoggingClient>();
586
587     pageConfiguration.applicationCacheStorage = ApplicationCacheStorage::create({ }, { });
588     pageConfiguration.databaseProvider = adoptRef(*new EmptyDatabaseProvider);
589     pageConfiguration.pluginInfoProvider = adoptRef(*new EmptyPluginInfoProvider);
590     pageConfiguration.storageNamespaceProvider = adoptRef(*new EmptyStorageNamespaceProvider);
591     pageConfiguration.userContentProvider = adoptRef(*new EmptyUserContentProvider);
592     pageConfiguration.visitedLinkStore = adoptRef(*new EmptyVisitedLinkStore);
593     
594     return pageConfiguration;
595 }
596
597 DiagnosticLoggingClient& emptyDiagnosticLoggingClient()
598 {
599     static NeverDestroyed<EmptyDiagnosticLoggingClient> client;
600     return client;
601 }
602
603 }