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