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