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