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