Separate form submission from PolicyChecker infrastructure
[WebKit-https.git] / Source / WebCore / loader / EmptyClients.cpp
1 /*
2  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
3  * Copyright (C) 2008-2017 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 "FileChooser.h"
42 #include "FormState.h"
43 #include "Frame.h"
44 #include "FrameLoaderClient.h"
45 #include "FrameNetworkingContext.h"
46 #include "HTMLFormElement.h"
47 #include "InProcessIDBServer.h"
48 #include "InspectorClient.h"
49 #include "NetworkStorageSession.h"
50 #include "Page.h"
51 #include "PageConfiguration.h"
52 #include "PaymentCoordinatorClient.h"
53 #include "PluginInfoProvider.h"
54 #include "ProgressTrackerClient.h"
55 #include "SecurityOriginData.h"
56 #include "StorageArea.h"
57 #include "StorageNamespace.h"
58 #include "StorageNamespaceProvider.h"
59 #include "StorageType.h"
60 #include "TextCheckerClient.h"
61 #include "ThreadableWebSocketChannel.h"
62 #include "UserContentProvider.h"
63 #include "VisitedLinkStore.h"
64 #include <heap/HeapInlines.h>
65 #include <wtf/NeverDestroyed.h>
66
67 #if ENABLE(CONTENT_EXTENSIONS)
68 #include "CompiledContentExtension.h"
69 #endif
70
71 #if USE(QUICK_LOOK)
72 #include "PreviewLoaderClient.h"
73 #endif
74
75 namespace WebCore {
76
77 class UserMessageHandlerDescriptor;
78
79 class EmptyBackForwardClient final : public BackForwardClient {
80     void addItem(Ref<HistoryItem>&&) final { }
81     void goToItem(HistoryItem*) final { }
82     HistoryItem* itemAtIndex(int) final { return nullptr; }
83     int backListCount() final { return 0; }
84     int forwardListCount() final { return 0; }
85     void close() final { }
86 };
87
88 #if ENABLE(CONTEXT_MENUS)
89
90 class EmptyContextMenuClient final : public ContextMenuClient {
91     void contextMenuDestroyed() final { }
92
93     void downloadURL(const URL&) final { }
94     void searchWithGoogle(const Frame*) final { }
95     void lookUpInDictionary(Frame*) final { }
96     bool isSpeaking() final { return false; }
97     void speak(const String&) final { }
98     void stopSpeaking() final { }
99
100 #if PLATFORM(COCOA)
101     void searchWithSpotlight() final { }
102 #endif
103
104 #if USE(ACCESSIBILITY_CONTEXT_MENUS)
105     void showContextMenu() final { }
106 #endif
107 };
108
109 #endif // ENABLE(CONTEXT_MENUS)
110
111 class EmptyDatabaseProvider final : public DatabaseProvider {
112 #if ENABLE(INDEXED_DATABASE)
113     IDBClient::IDBConnectionToServer& idbConnectionToServerForSession(const PAL::SessionID&) final
114     {
115         static auto& sharedConnection = InProcessIDBServer::create().leakRef();
116         return sharedConnection.connectionToServer();
117     }
118 #endif
119 };
120
121 class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
122     void logDiagnosticMessage(const String&, const String&, ShouldSample) final { }
123     void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) final { }
124     void logDiagnosticMessageWithValue(const String&, const String&, double, unsigned, ShouldSample) final { }
125     void logDiagnosticMessageWithEnhancedPrivacy(const String&, const String&, ShouldSample) final { }
126 };
127
128 #if ENABLE(DRAG_SUPPORT)
129
130 class EmptyDragClient final : public DragClient {
131     void willPerformDragDestinationAction(DragDestinationAction, const DragData&) final { }
132     void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) final { }
133     DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) final { return DragSourceActionNone; }
134     void startDrag(DragItem, DataTransfer&, Frame&) final { }
135     void dragControllerDestroyed() final { }
136 };
137
138 #endif // ENABLE(DRAG_SUPPORT)
139
140 class EmptyEditorClient final : public EditorClient {
141     WTF_MAKE_FAST_ALLOCATED;
142
143 public:
144     EmptyEditorClient() = default;
145
146 private:
147     bool shouldDeleteRange(Range*) final { return false; }
148     bool smartInsertDeleteEnabled() final { return false; }
149     bool isSelectTrailingWhitespaceEnabled() const final { return false; }
150     bool isContinuousSpellCheckingEnabled() final { return false; }
151     void toggleContinuousSpellChecking() final { }
152     bool isGrammarCheckingEnabled() final { return false; }
153     void toggleGrammarChecking() final { }
154     int spellCheckerDocumentTag() final { return -1; }
155
156     bool shouldBeginEditing(Range*) final { return false; }
157     bool shouldEndEditing(Range*) final { return false; }
158     bool shouldInsertNode(Node*, Range*, EditorInsertAction) final { return false; }
159     bool shouldInsertText(const String&, Range*, EditorInsertAction) final { return false; }
160     bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) final { return false; }
161
162     bool shouldApplyStyle(StyleProperties*, Range*) final { return false; }
163     void didApplyStyle() final { }
164     bool shouldMoveRangeAfterDelete(Range*, Range*) final { return false; }
165
166     void didBeginEditing() final { }
167     void respondToChangedContents() final { }
168     void respondToChangedSelection(Frame*) final { }
169     void updateEditorStateAfterLayoutIfEditabilityChanged() final { }
170     void discardedComposition(Frame*) final { }
171     void canceledComposition() final { }
172     void didUpdateComposition() final { }
173     void didEndEditing() final { }
174     void didEndUserTriggeredSelectionChanges() final { }
175     void willWriteSelectionToPasteboard(Range*) final { }
176     void didWriteSelectionToPasteboard() final { }
177     void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) final { }
178     void requestCandidatesForSelection(const VisibleSelection&) final { }
179     void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) final { }
180
181     void registerUndoStep(UndoStep&) final;
182     void registerRedoStep(UndoStep&) final;
183     void clearUndoRedoOperations() final { }
184
185     bool canCopyCut(Frame*, bool defaultValue) const final { return defaultValue; }
186     bool canPaste(Frame*, bool defaultValue) const final { return defaultValue; }
187     bool canUndo() const final { return false; }
188     bool canRedo() const final { return false; }
189
190     void undo() final { }
191     void redo() final { }
192
193     void handleKeyboardEvent(KeyboardEvent*) final { }
194     void handleInputMethodKeydown(KeyboardEvent*) final { }
195
196     void textFieldDidBeginEditing(Element*) final { }
197     void textFieldDidEndEditing(Element*) final { }
198     void textDidChangeInTextField(Element*) final { }
199     bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) final { return false; }
200     void textWillBeDeletedInTextField(Element*) final { }
201     void textDidChangeInTextArea(Element*) final { }
202     void overflowScrollPositionChanged() final { }
203
204 #if PLATFORM(IOS)
205     void startDelayingAndCoalescingContentChangeNotifications() final { }
206     void stopDelayingAndCoalescingContentChangeNotifications() final { }
207     void writeDataToPasteboard(NSDictionary*) final { }
208     NSArray* supportedPasteboardTypesForCurrentSelection() final { return nullptr; }
209     NSArray* readDataFromPasteboard(NSString*, int) final { return nullptr; }
210     bool hasRichlyEditableSelection() final { return false; }
211     int getPasteboardItemsCount() final { return 0; }
212     RefPtr<DocumentFragment> documentFragmentFromDelegate(int) final { return nullptr; }
213     bool performsTwoStepPaste(DocumentFragment*) final { return false; }
214     int pasteboardChangeCount() final { return 0; }
215 #endif
216
217     bool performTwoStepDrop(DocumentFragment&, Range&, bool) final { return false; }
218
219 #if PLATFORM(COCOA)
220     NSString *userVisibleString(NSURL *) final { return nullptr; }
221     void setInsertionPasteboard(const String&) final { };
222     NSURL *canonicalizeURL(NSURL *) final { return nullptr; }
223     NSURL *canonicalizeURLString(NSString *) final { return nullptr; }
224 #endif
225
226 #if USE(APPKIT)
227     void uppercaseWord() final { }
228     void lowercaseWord() final { }
229     void capitalizeWord() final { }
230 #endif
231
232 #if USE(AUTOMATIC_TEXT_REPLACEMENT)
233     void showSubstitutionsPanel(bool) final { }
234     bool substitutionsPanelIsShowing() final { return false; }
235     void toggleSmartInsertDelete() final { }
236     bool isAutomaticQuoteSubstitutionEnabled() final { return false; }
237     void toggleAutomaticQuoteSubstitution() final { }
238     bool isAutomaticLinkDetectionEnabled() final { return false; }
239     void toggleAutomaticLinkDetection() final { }
240     bool isAutomaticDashSubstitutionEnabled() final { return false; }
241     void toggleAutomaticDashSubstitution() final { }
242     bool isAutomaticTextReplacementEnabled() final { return false; }
243     void toggleAutomaticTextReplacement() final { }
244     bool isAutomaticSpellingCorrectionEnabled() final { return false; }
245     void toggleAutomaticSpellingCorrection() final { }
246 #endif
247
248 #if PLATFORM(GTK)
249     bool shouldShowUnicodeMenu() final { return false; }
250 #endif
251
252     TextCheckerClient* textChecker() final { return &m_textCheckerClient; }
253
254     void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) final { }
255     void updateSpellingUIWithMisspelledWord(const String&) final { }
256     void showSpellingUI(bool) final { }
257     bool spellingUIIsShowing() final { return false; }
258
259     void willSetInputMethodState() final { }
260     void setInputMethodState(bool) final { }
261
262     class EmptyTextCheckerClient final : public TextCheckerClient {
263         bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const final { return true; }
264         void ignoreWordInSpellDocument(const String&) final { }
265         void learnWord(const String&) final { }
266         void checkSpellingOfString(StringView, int*, int*) final { }
267         String getAutoCorrectSuggestionForMisspelledWord(const String&) final { return { }; }
268         void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) final { }
269
270 #if USE(UNIFIED_TEXT_CHECKING)
271         Vector<TextCheckingResult> checkTextOfParagraph(StringView, TextCheckingTypeMask, const VisibleSelection&) final { return Vector<TextCheckingResult>(); }
272 #endif
273
274         void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) final { }
275         void requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&) final;
276     };
277
278     EmptyTextCheckerClient m_textCheckerClient;
279 };
280
281 class EmptyFrameLoaderClient final : public FrameLoaderClient {
282     void frameLoaderDestroyed() final { }
283
284     bool hasWebView() const final { return true; } // mainly for assertions
285
286     void makeRepresentation(DocumentLoader*) final { }
287 #if PLATFORM(IOS)
288     bool forceLayoutOnRestoreFromPageCache() final { return false; }
289 #endif
290     void forceLayoutForNonHTML() final { }
291
292     void setCopiesOnScroll() final { }
293
294     void detachedFromParent2() final { }
295     void detachedFromParent3() final { }
296
297     void convertMainResourceLoadToDownload(DocumentLoader*, PAL::SessionID, const ResourceRequest&, const ResourceResponse&) final { }
298
299     void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) final { }
300     bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) final { return false; }
301     void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) final { }
302     void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) final { }
303 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
304     bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) final { return false; }
305 #endif
306
307 #if PLATFORM(IOS)
308     RetainPtr<CFDictionaryRef> connectionProperties(DocumentLoader*, unsigned long) final { return nullptr; }
309 #endif
310
311     void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) final { }
312     void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) final { }
313     void dispatchDidFinishLoading(DocumentLoader*, unsigned long) final { }
314 #if ENABLE(DATA_DETECTION)
315     void dispatchDidFinishDataDetection(NSArray *) final { }
316 #endif
317     void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) final { }
318     bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) final { return false; }
319
320     void dispatchDidDispatchOnloadEvents() final { }
321     void dispatchDidReceiveServerRedirectForProvisionalLoad() final { }
322     void dispatchDidCancelClientRedirect() final { }
323     void dispatchWillPerformClientRedirect(const URL&, double, double) final { }
324     void dispatchDidChangeLocationWithinPage() final { }
325     void dispatchDidPushStateWithinPage() final { }
326     void dispatchDidReplaceStateWithinPage() final { }
327     void dispatchDidPopStateWithinPage() final { }
328     void dispatchWillClose() final { }
329     void dispatchDidStartProvisionalLoad() final { }
330     void dispatchDidReceiveTitle(const StringWithDirection&) final { }
331     void dispatchDidCommitLoad(std::optional<HasInsecureContent>) final { }
332     void dispatchDidFailProvisionalLoad(const ResourceError&) final { }
333     void dispatchDidFailLoad(const ResourceError&) final { }
334     void dispatchDidFinishDocumentLoad() final { }
335     void dispatchDidFinishLoad() final { }
336     void dispatchDidReachLayoutMilestone(LayoutMilestones) final { }
337
338     Frame* dispatchCreatePage(const NavigationAction&) final { return nullptr; }
339     void dispatchShow() final { }
340
341     void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, FramePolicyFunction&&) final { }
342     void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, FormState*, const String&, FramePolicyFunction&&) final;
343     void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, bool didReceiveRedirectResponse, FormState*, FramePolicyFunction&&) final;
344     void cancelPolicyCheck() final { }
345
346     void dispatchUnableToImplementPolicy(const ResourceError&) final { }
347
348     void dispatchWillSendSubmitEvent(Ref<FormState>&&) final;
349     void dispatchWillSubmitForm(FormState&, WTF::Function<void(void)>&&) final;
350
351     void revertToProvisionalState(DocumentLoader*) final { }
352     void setMainDocumentError(DocumentLoader*, const ResourceError&) final { }
353
354     void setMainFrameDocumentReady(bool) final { }
355
356     void startDownload(const ResourceRequest&, const String&) final { }
357
358     void willChangeTitle(DocumentLoader*) final { }
359     void didChangeTitle(DocumentLoader*) final { }
360
361     void willReplaceMultipartContent() final { }
362     void didReplaceMultipartContent() final { }
363
364     void committedLoad(DocumentLoader*, const char*, int) final { }
365     void finishedLoading(DocumentLoader*) final { }
366
367     ResourceError cancelledError(const ResourceRequest&) final { return { ResourceError::Type::Cancellation }; }
368     ResourceError blockedError(const ResourceRequest&) final { return { }; }
369     ResourceError blockedByContentBlockerError(const ResourceRequest&) final { return { }; }
370     ResourceError cannotShowURLError(const ResourceRequest&) final { return { }; }
371     ResourceError interruptedForPolicyChangeError(const ResourceRequest&) final { return { }; }
372 #if ENABLE(CONTENT_FILTERING)
373     ResourceError blockedByContentFilterError(const ResourceRequest&) final { return { }; }
374 #endif
375
376     ResourceError cannotShowMIMETypeError(const ResourceResponse&) final { return { }; }
377     ResourceError fileDoesNotExistError(const ResourceResponse&) final { return { }; }
378     ResourceError pluginWillHandleLoadError(const ResourceResponse&) final { return { }; }
379
380     bool shouldFallBack(const ResourceError&) final { return false; }
381
382     bool canHandleRequest(const ResourceRequest&) const final { return false; }
383     bool canShowMIMEType(const String&) const final { return false; }
384     bool canShowMIMETypeAsHTML(const String&) const final { return false; }
385     bool representationExistsForURLScheme(const String&) const final { return false; }
386     String generatedMIMETypeForURLScheme(const String&) const final { return emptyString(); }
387
388     void frameLoadCompleted() final { }
389     void restoreViewState() final { }
390     void provisionalLoadStarted() final { }
391     void didFinishLoad() final { }
392     void prepareForDataSourceReplacement() final { }
393
394     Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) final;
395     void updateCachedDocumentLoader(DocumentLoader&) final { }
396     void setTitle(const StringWithDirection&, const URL&) final { }
397
398     String userAgent(const URL&) final { return emptyString(); }
399
400     void savePlatformDataToCachedFrame(CachedFrame*) final { }
401     void transitionToCommittedFromCachedFrame(CachedFrame*) final { }
402 #if PLATFORM(IOS)
403     void didRestoreFrameHierarchyForCachedFrame() final { }
404 #endif
405     void transitionToCommittedForNewPage() final { }
406
407     void didSaveToPageCache() final { }
408     void didRestoreFromPageCache() final { }
409
410     void dispatchDidBecomeFrameset(bool) final { }
411
412     void updateGlobalHistory() final { }
413     void updateGlobalHistoryRedirectLinks() final { }
414     bool shouldGoToHistoryItem(HistoryItem*) const final { return false; }
415     void updateGlobalHistoryItemForPage() final { }
416     void saveViewStateToItem(HistoryItem&) final { }
417     bool canCachePage() const final { return false; }
418     void didDisplayInsecureContent() final { }
419     void didRunInsecureContent(SecurityOrigin&, const URL&) final { }
420     void didDetectXSS(const URL&, bool) final { }
421     RefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement&, const String&, bool, int, int) final;
422     RefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement&, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) final;
423     void recreatePlugin(Widget*) final;
424     RefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement&, const URL&, const Vector<String>&, const Vector<String>&) final;
425
426     ObjectContentType objectContentType(const URL&, const String&) final { return ObjectContentType::None; }
427     String overrideMediaType() const final { return { }; }
428
429     void redirectDataToPlugin(Widget&) final { }
430     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&) final { }
431
432 #if PLATFORM(COCOA)
433     RemoteAXObjectRef accessibilityRemoteObject() final { return nullptr; }
434     NSCachedURLResponse *willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse *response) const final { return response; }
435 #endif
436
437 #if PLATFORM(WIN) && USE(CFURLCONNECTION)
438     bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) final { return true; }
439 #endif
440
441     Ref<FrameNetworkingContext> createNetworkingContext() final;
442
443     bool isEmptyFrameLoaderClient() final { return true; }
444     void prefetchDNS(const String&) final { }
445
446 #if USE(QUICK_LOOK)
447     RefPtr<PreviewLoaderClient> createPreviewLoaderClient(const String&, const String&) final { return nullptr; }
448 #endif
449 };
450
451 class EmptyFrameNetworkingContext final : public FrameNetworkingContext {
452 public:
453     static Ref<EmptyFrameNetworkingContext> create() { return adoptRef(*new EmptyFrameNetworkingContext); }
454
455 private:
456     EmptyFrameNetworkingContext();
457
458     bool shouldClearReferrerOnHTTPSToHTTPRedirect() const { return true; }
459     NetworkStorageSession& storageSession() const final { return NetworkStorageSession::defaultStorageSession(); }
460
461 #if PLATFORM(COCOA)
462     bool localFileContentSniffingEnabled() const { return false; }
463     SchedulePairHashSet* scheduledRunLoopPairs() const { return nullptr; }
464     RetainPtr<CFDataRef> sourceApplicationAuditData() const { return nullptr; };
465 #endif
466
467 #if PLATFORM(COCOA) || PLATFORM(WIN)
468     ResourceError blockedError(const ResourceRequest&) const final { return { }; }
469 #endif
470 };
471
472 class EmptyInspectorClient final : public InspectorClient {
473     void inspectedPageDestroyed() final { }
474     Inspector::FrontendChannel* openLocalFrontend(InspectorController*) final { return nullptr; }
475     void bringFrontendToFront() final { }
476     void highlight() final { }
477     void hideHighlight() final { }
478 };
479
480 #if ENABLE(APPLE_PAY)
481
482 class EmptyPaymentCoordinatorClient final : public PaymentCoordinatorClient {
483     bool supportsVersion(unsigned) final { return false; }
484     bool canMakePayments() final { return false; }
485     void canMakePaymentsWithActiveCard(const String&, const String&, WTF::Function<void(bool)>&& completionHandler) final { callOnMainThread([completionHandler = WTFMove(completionHandler)] { completionHandler(false); }); }
486     void openPaymentSetup(const String&, const String&, WTF::Function<void(bool)>&& completionHandler) final { callOnMainThread([completionHandler = WTFMove(completionHandler)] { completionHandler(false); }); }
487     bool showPaymentUI(const URL&, const Vector<URL>&, const ApplePaySessionPaymentRequest&) final { return false; }
488     void completeMerchantValidation(const PaymentMerchantSession&) final { }
489     void completeShippingMethodSelection(std::optional<ShippingMethodUpdate>&&) final { }
490     void completeShippingContactSelection(std::optional<ShippingContactUpdate>&&) final { }
491     void completePaymentMethodSelection(std::optional<PaymentMethodUpdate>&&) final { }
492     void completePaymentSession(std::optional<PaymentAuthorizationResult>&&) final { }
493     void cancelPaymentSession() final { }
494     void abortPaymentSession() final { }
495     void paymentCoordinatorDestroyed() final { }
496 };
497
498 #endif
499
500 class EmptyPluginInfoProvider final : public PluginInfoProvider {
501     void refreshPlugins() final { };
502     void getPluginInfo(Page&, Vector<PluginInfo>&) final { }
503     void getWebVisiblePluginInfo(Page&, Vector<PluginInfo>&) final { }
504 };
505
506 class EmptyPopupMenu : public PopupMenu {
507 public:
508     EmptyPopupMenu() = default;
509 private:
510     void show(const IntRect&, FrameView*, int) final { }
511     void hide() final { }
512     void updateFromElement() final { }
513     void disconnectClient() final { }
514 };
515
516 class EmptyProgressTrackerClient final : public ProgressTrackerClient {
517     void willChangeEstimatedProgress() final { }
518     void didChangeEstimatedProgress() final { }
519     void progressStarted(Frame&) final { }
520     void progressEstimateChanged(Frame&) final { }
521     void progressFinished(Frame&) final { }
522 };
523
524 class EmptySearchPopupMenu : public SearchPopupMenu {
525 public:
526     EmptySearchPopupMenu()
527         : m_popup(adoptRef(*new EmptyPopupMenu))
528     {
529     }
530
531 private:
532     PopupMenu* popupMenu() final { return m_popup.ptr(); }
533     void saveRecentSearches(const AtomicString&, const Vector<RecentSearch>&) final { }
534     void loadRecentSearches(const AtomicString&, Vector<RecentSearch>&) final { }
535     bool enabled() final { return false; }
536
537     Ref<EmptyPopupMenu> m_popup;
538 };
539
540 class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {
541     struct EmptyStorageArea : public StorageArea {
542         unsigned length() final { return 0; }
543         String key(unsigned) final { return { }; }
544         String item(const String&) final { return { }; }
545         void setItem(Frame*, const String&, const String&, bool&) final { }
546         void removeItem(Frame*, const String&) final { }
547         void clear(Frame*) final { }
548         bool contains(const String&) final { return false; }
549         StorageType storageType() const final { return StorageType::Local; }
550         size_t memoryBytesUsedByCache() final { return 0; }
551         SecurityOriginData securityOrigin() const final { return { }; }
552     };
553
554     struct EmptyStorageNamespace final : public StorageNamespace {
555         RefPtr<StorageArea> storageArea(const SecurityOriginData&) final { return adoptRef(*new EmptyStorageArea); }
556         RefPtr<StorageNamespace> copy(Page*) final { return adoptRef(*new EmptyStorageNamespace); }
557     };
558
559     RefPtr<StorageNamespace> createSessionStorageNamespace(Page&, unsigned) final;
560     RefPtr<StorageNamespace> createLocalStorageNamespace(unsigned) final;
561     RefPtr<StorageNamespace> createEphemeralLocalStorageNamespace(Page&, unsigned) final;
562     RefPtr<StorageNamespace> createTransientLocalStorageNamespace(SecurityOrigin&, unsigned) final;
563 };
564
565 class EmptyUserContentProvider final : public UserContentProvider {
566     void forEachUserScript(Function<void(DOMWrapperWorld&, const UserScript&)>&&) const final { }
567     void forEachUserStyleSheet(Function<void(const UserStyleSheet&)>&&) const final { }
568 #if ENABLE(USER_MESSAGE_HANDLERS)
569     void forEachUserMessageHandler(Function<void(const UserMessageHandlerDescriptor&)>&&) const final { }
570 #endif
571 #if ENABLE(CONTENT_EXTENSIONS)
572     ContentExtensions::ContentExtensionsBackend& userContentExtensionBackend() final { static NeverDestroyed<ContentExtensions::ContentExtensionsBackend> backend; return backend.get(); };
573 #endif
574 };
575
576 class EmptyVisitedLinkStore final : public VisitedLinkStore {
577     bool isLinkVisited(Page&, LinkHash, const URL&, const AtomicString&) final { return false; }
578     void addVisitedLink(Page&, LinkHash) final { }
579 };
580
581 RefPtr<PopupMenu> EmptyChromeClient::createPopupMenu(PopupMenuClient&) const
582 {
583     return adoptRef(*new EmptyPopupMenu);
584 }
585
586 RefPtr<SearchPopupMenu> EmptyChromeClient::createSearchPopupMenu(PopupMenuClient&) const
587 {
588     return adoptRef(*new EmptySearchPopupMenu);
589 }
590
591 #if ENABLE(INPUT_TYPE_COLOR)
592
593 std::unique_ptr<ColorChooser> EmptyChromeClient::createColorChooser(ColorChooserClient&, const Color&)
594 {
595     return nullptr;
596 }
597
598 #endif
599
600 void EmptyChromeClient::runOpenPanel(Frame&, FileChooser&)
601 {
602 }
603
604 void EmptyFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, FormState*, const String&, FramePolicyFunction&&)
605 {
606 }
607
608 void EmptyFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, bool, FormState*, FramePolicyFunction&&)
609 {
610 }
611
612 void EmptyFrameLoaderClient::dispatchWillSendSubmitEvent(Ref<FormState>&&)
613 {
614 }
615
616 void EmptyFrameLoaderClient::dispatchWillSubmitForm(FormState&, WTF::Function<void(void)>&&)
617 {
618 }
619
620 Ref<DocumentLoader> EmptyFrameLoaderClient::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
621 {
622     return DocumentLoader::create(request, substituteData);
623 }
624
625 RefPtr<Frame> EmptyFrameLoaderClient::createFrame(const URL&, const String&, HTMLFrameOwnerElement&, const String&, bool, int, int)
626 {
627     return nullptr;
628 }
629
630 RefPtr<Widget> EmptyFrameLoaderClient::createPlugin(const IntSize&, HTMLPlugInElement&, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool)
631 {
632     return nullptr;
633 }
634
635 void EmptyFrameLoaderClient::recreatePlugin(Widget*)
636 {
637 }
638
639 RefPtr<Widget> EmptyFrameLoaderClient::createJavaAppletWidget(const IntSize&, HTMLAppletElement&, const URL&, const Vector<String>&, const Vector<String>&)
640 {
641     return nullptr;
642 }
643
644 inline EmptyFrameNetworkingContext::EmptyFrameNetworkingContext()
645     : FrameNetworkingContext { nullptr }
646 {
647 }
648
649 Ref<FrameNetworkingContext> EmptyFrameLoaderClient::createNetworkingContext()
650 {
651     return EmptyFrameNetworkingContext::create();
652 }
653
654 void EmptyEditorClient::EmptyTextCheckerClient::requestCheckingOfString(TextCheckingRequest&, const VisibleSelection&)
655 {
656 }
657
658 void EmptyEditorClient::registerUndoStep(UndoStep&)
659 {
660 }
661
662 void EmptyEditorClient::registerRedoStep(UndoStep&)
663 {
664 }
665
666 RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createSessionStorageNamespace(Page&, unsigned)
667 {
668     return adoptRef(*new EmptyStorageNamespace);
669 }
670
671 RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createLocalStorageNamespace(unsigned)
672 {
673     return adoptRef(*new EmptyStorageNamespace);
674 }
675
676 RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createEphemeralLocalStorageNamespace(Page&, unsigned)
677 {
678     return adoptRef(*new EmptyStorageNamespace);
679 }
680
681 RefPtr<StorageNamespace> EmptyStorageNamespaceProvider::createTransientLocalStorageNamespace(SecurityOrigin&, unsigned)
682 {
683     return adoptRef(*new EmptyStorageNamespace);
684 }
685
686 void fillWithEmptyClients(PageConfiguration& pageConfiguration)
687 {
688     static NeverDestroyed<EmptyChromeClient> dummyChromeClient;
689     pageConfiguration.chromeClient = &dummyChromeClient.get();
690
691 #if ENABLE(APPLE_PAY)
692     static NeverDestroyed<EmptyPaymentCoordinatorClient> dummyPaymentCoordinatorClient;
693     pageConfiguration.paymentCoordinatorClient = &dummyPaymentCoordinatorClient.get();
694 #endif
695
696 #if ENABLE(CONTEXT_MENUS)
697     static NeverDestroyed<EmptyContextMenuClient> dummyContextMenuClient;
698     pageConfiguration.contextMenuClient = &dummyContextMenuClient.get();
699 #endif
700
701 #if ENABLE(DRAG_SUPPORT)
702     static NeverDestroyed<EmptyDragClient> dummyDragClient;
703     pageConfiguration.dragClient = &dummyDragClient.get();
704 #endif
705
706     static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
707     pageConfiguration.inspectorClient = &dummyInspectorClient.get();
708
709     static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
710     pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
711
712     static NeverDestroyed<EmptyProgressTrackerClient> dummyProgressTrackerClient;
713     pageConfiguration.progressTrackerClient = &dummyProgressTrackerClient.get();
714
715     pageConfiguration.backForwardClient = adoptRef(*new EmptyBackForwardClient);
716     pageConfiguration.diagnosticLoggingClient = std::make_unique<EmptyDiagnosticLoggingClient>();
717
718     pageConfiguration.applicationCacheStorage = ApplicationCacheStorage::create({ }, { });
719     pageConfiguration.databaseProvider = adoptRef(*new EmptyDatabaseProvider);
720     pageConfiguration.pluginInfoProvider = adoptRef(*new EmptyPluginInfoProvider);
721     pageConfiguration.storageNamespaceProvider = adoptRef(*new EmptyStorageNamespaceProvider);
722     pageConfiguration.userContentProvider = adoptRef(*new EmptyUserContentProvider);
723     pageConfiguration.visitedLinkStore = adoptRef(*new EmptyVisitedLinkStore);
724 }
725
726 UniqueRef<EditorClient> createEmptyEditorClient()
727 {
728     return makeUniqueRef<EmptyEditorClient>();
729 }
730
731 DiagnosticLoggingClient& emptyDiagnosticLoggingClient()
732 {
733     static NeverDestroyed<EmptyDiagnosticLoggingClient> client;
734     return client;
735 }
736
737 }