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