10e7ee8a6c19bf57204eb7a73a19599dd7759cc8
[WebKit-https.git] / Source / WebCore / loader / EmptyClients.h
1 /*
2  * Copyright (C) 2006 Eric Seidel (eric@webkit.org)
3  * Copyright (C) 2008-2012, 2015 Apple Inc. All rights reserved.
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef EmptyClients_h
30 #define EmptyClients_h
31
32 #include "ChromeClient.h"
33 #include "ContextMenuClient.h"
34 #include "DeviceMotionClient.h"
35 #include "DeviceOrientationClient.h"
36 #include "DiagnosticLoggingClient.h"
37 #include "DragClient.h"
38 #include "EditorClient.h"
39 #include "FloatRect.h"
40 #include "FocusDirection.h"
41 #include "FrameLoaderClient.h"
42 #include "InspectorClient.h"
43 #include "ProgressTrackerClient.h"
44 #include "ResourceError.h"
45 #include "TextCheckerClient.h"
46 #include "VisitedLinkStore.h"
47 #include <wtf/text/StringView.h>
48
49 #if ENABLE(USER_MESSAGE_HANDLERS)
50 #include "UserMessageHandlerDescriptor.h"
51 #endif
52
53 #if ENABLE(CONTENT_EXTENSIONS)
54 #include "CompiledContentExtension.h"
55 #endif
56
57 /*
58  This file holds empty Client stubs for use by WebCore.
59  Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.
60  This tree depends heavily on Clients (usually provided by WebKit classes).
61
62  This file was first created for SVGImage as it had no way to access the current Page (nor should it,
63  since Images are not tied to a page).
64  See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
65
66  Ideally, whenever you change a Client class, you should add a stub here.
67  Brittle, yes.  Unfortunate, yes.  Hopefully temporary.
68 */
69
70 namespace WebCore {
71
72 class GraphicsContext3D;
73 class Page;
74
75 class EmptyChromeClient : public ChromeClient {
76     WTF_MAKE_FAST_ALLOCATED;
77 public:
78     virtual ~EmptyChromeClient() { }
79     void chromeDestroyed() override { }
80
81     void setWindowRect(const FloatRect&) override { }
82     FloatRect windowRect() override { return FloatRect(); }
83
84     FloatRect pageRect() override { return FloatRect(); }
85
86     void focus() override { }
87     void unfocus() override { }
88
89     bool canTakeFocus(FocusDirection) override { return false; }
90     void takeFocus(FocusDirection) override { }
91
92     void focusedElementChanged(Element*) override { }
93     void focusedFrameChanged(Frame*) override { }
94
95     Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) override { return nullptr; }
96     void show() override { }
97
98     bool canRunModal() override { return false; }
99     void runModal() override { }
100
101     void setToolbarsVisible(bool) override { }
102     bool toolbarsVisible() override { return false; }
103
104     void setStatusbarVisible(bool) override { }
105     bool statusbarVisible() override { return false; }
106
107     void setScrollbarsVisible(bool) override { }
108     bool scrollbarsVisible() override { return false; }
109
110     void setMenubarVisible(bool) override { }
111     bool menubarVisible() override { return false; }
112
113     void setResizable(bool) override { }
114
115     void addMessageToConsole(MessageSource, MessageLevel, const String&, unsigned, unsigned, const String&) override { }
116
117     bool canRunBeforeUnloadConfirmPanel() override { return false; }
118     bool runBeforeUnloadConfirmPanel(const String&, Frame*) override { return true; }
119
120     void closeWindowSoon() override { }
121
122     void runJavaScriptAlert(Frame*, const String&) override { }
123     bool runJavaScriptConfirm(Frame*, const String&) override { return false; }
124     bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) override { return false; }
125
126     bool selectItemWritingDirectionIsNatural() override { return false; }
127     bool selectItemAlignmentFollowsMenuWritingDirection() override { return false; }
128     bool hasOpenedPopup() const override { return false; }
129     RefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const override;
130     RefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const override;
131
132     void setStatusbarText(const String&) override { }
133
134     KeyboardUIMode keyboardUIMode() override { return KeyboardAccessDefault; }
135
136     void invalidateRootView(const IntRect&) override { }
137     void invalidateContentsAndRootView(const IntRect&) override { }
138     void invalidateContentsForSlowScroll(const IntRect&) override { }
139     void scroll(const IntSize&, const IntRect&, const IntRect&) override { }
140 #if USE(COORDINATED_GRAPHICS)
141     void delegatedScrollRequested(const IntPoint&) override { }
142 #endif
143 #if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
144     void scheduleAnimation() override { }
145 #endif
146
147     IntPoint screenToRootView(const IntPoint& p) const override { return p; }
148     IntRect rootViewToScreen(const IntRect& r) const override { return r; }
149 #if PLATFORM(IOS)
150     IntPoint accessibilityScreenToRootView(const IntPoint& p) const override { return p; };
151     IntRect rootViewToAccessibilityScreen(const IntRect& r) const override { return r; };
152 #endif
153     PlatformPageClient platformPageClient() const override { return 0; }
154     void contentsSizeChanged(Frame*, const IntSize&) const override { }
155
156     void scrollbarsModeDidChange() const override { }
157     void mouseDidMoveOverElement(const HitTestResult&, unsigned) override { }
158
159     void setToolTip(const String&, TextDirection) override { }
160
161     void print(Frame*) override { }
162
163     void exceededDatabaseQuota(Frame*, const String&, DatabaseDetails) override { }
164
165     void reachedMaxAppCacheSize(int64_t) override { }
166     void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t) override { }
167
168 #if ENABLE(INPUT_TYPE_COLOR)
169     std::unique_ptr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) override;
170 #endif
171
172     void runOpenPanel(Frame*, PassRefPtr<FileChooser>) override;
173     void loadIconForFiles(const Vector<String>&, FileIconLoader*) override { }
174
175     void elementDidFocus(const Node*) override { }
176     void elementDidBlur(const Node*) override { }
177
178 #if !PLATFORM(IOS)
179     void setCursor(const Cursor&) override { }
180     void setCursorHiddenUntilMouseMoves(bool) override { }
181 #endif
182
183     void scrollRectIntoView(const IntRect&) const override { }
184
185     void attachRootGraphicsLayer(Frame*, GraphicsLayer*) override { }
186     void attachViewOverlayGraphicsLayer(Frame*, GraphicsLayer*) override { }
187     void setNeedsOneShotDrawingSynchronization() override { }
188     void scheduleCompositingLayerFlush() override { }
189
190 #if PLATFORM(WIN)
191     void setLastSetCursorToCurrentCursor() override { }
192     void AXStartFrameLoad() override { }
193     void AXFinishFrameLoad() override { }
194 #endif
195
196 #if PLATFORM(IOS)
197 #if ENABLE(IOS_TOUCH_EVENTS)
198     void didPreventDefaultForEvent() override { }
199 #endif
200     void didReceiveMobileDocType(bool) override { }
201     void setNeedsScrollNotifications(Frame*, bool) override { }
202     void observedContentChange(Frame*) override { }
203     void clearContentChangeObservers(Frame*) override { }
204     void notifyRevealedSelectionByScrollingFrame(Frame*) override { }
205     void didLayout(LayoutType) override { }
206     void didStartOverflowScroll() override { }
207     void didEndOverflowScroll() override { }
208
209     void suppressFormNotifications() override { }
210     void restoreFormNotifications() override { }
211
212     void addOrUpdateScrollingLayer(Node*, PlatformLayer*, PlatformLayer*, const IntSize&, bool, bool) override { }
213     void removeScrollingLayer(Node*, PlatformLayer*, PlatformLayer*) override { }
214
215     void webAppOrientationsUpdated() override { };
216     void showPlaybackTargetPicker(bool) override { };
217 #endif // PLATFORM(IOS)
218
219 #if ENABLE(ORIENTATION_EVENTS)
220     int deviceOrientation() const override { return 0; }
221 #endif
222
223 #if PLATFORM(IOS)
224     bool isStopping() override { return false; }
225 #endif
226
227 #if ENABLE(TOUCH_EVENTS)
228     void needTouchEvents(bool) override { }
229 #endif
230     
231     void wheelEventHandlersChanged(bool) override { }
232     
233     bool isEmptyChromeClient() const override { return true; }
234
235     void didAssociateFormControls(const Vector<RefPtr<Element>>&) override { }
236     bool shouldNotifyOnFormChanges() override { return false; }
237 };
238
239 // FIXME (bug 116233): Get rid of EmptyFrameLoaderClient. It is a travesty.
240
241 class EmptyFrameLoaderClient : public FrameLoaderClient {
242     WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
243 public:
244     EmptyFrameLoaderClient() { }
245     virtual ~EmptyFrameLoaderClient() {  }
246     void frameLoaderDestroyed() override { }
247
248     bool hasWebView() const override { return true; } // mainly for assertions
249
250     void makeRepresentation(DocumentLoader*) override { }
251 #if PLATFORM(IOS)
252     bool forceLayoutOnRestoreFromPageCache() override { return false; }
253 #endif
254     void forceLayoutForNonHTML() override { }
255
256     void setCopiesOnScroll() override { }
257
258     void detachedFromParent2() override { }
259     void detachedFromParent3() override { }
260
261     void convertMainResourceLoadToDownload(DocumentLoader*, SessionID, const ResourceRequest&, const ResourceResponse&) override { }
262
263     void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) override { }
264     bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) override { return false; }
265     void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) override { }
266     void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) override { }
267     void dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) override { }
268 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
269     bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) override { return false; }
270 #endif
271
272 #if PLATFORM(IOS)
273     RetainPtr<CFDictionaryRef> connectionProperties(DocumentLoader*, unsigned long) override { return nullptr; }
274 #endif
275
276     void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) override { }
277     void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) override { }
278     void dispatchDidFinishLoading(DocumentLoader*, unsigned long) override { }
279 #if ENABLE(DATA_DETECTION)
280     void dispatchDidFinishDataDetection(NSArray *) override { }
281 #endif
282     void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) override { }
283     bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) override { return false; }
284
285     void dispatchDidDispatchOnloadEvents() override { }
286     void dispatchDidReceiveServerRedirectForProvisionalLoad() override { }
287     void dispatchDidCancelClientRedirect() override { }
288     void dispatchWillPerformClientRedirect(const URL&, double, double) override { }
289     void dispatchDidChangeLocationWithinPage() override { }
290     void dispatchDidPushStateWithinPage() override { }
291     void dispatchDidReplaceStateWithinPage() override { }
292     void dispatchDidPopStateWithinPage() override { }
293     void dispatchWillClose() override { }
294     void dispatchDidReceiveIcon() override { }
295     void dispatchDidStartProvisionalLoad() override { }
296     void dispatchDidReceiveTitle(const StringWithDirection&) override { }
297     void dispatchDidCommitLoad() override { }
298     void dispatchDidFailProvisionalLoad(const ResourceError&) override { }
299     void dispatchDidFailLoad(const ResourceError&) override { }
300     void dispatchDidFinishDocumentLoad() override { }
301     void dispatchDidFinishLoad() override { }
302     void dispatchDidLayout(LayoutMilestones) override { }
303
304     Frame* dispatchCreatePage(const NavigationAction&) override { return nullptr; }
305     void dispatchShow() override { }
306
307     void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, FramePolicyFunction) override { }
308     void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&, FramePolicyFunction) override;
309     void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, FramePolicyFunction) override;
310     void cancelPolicyCheck() override { }
311
312     void dispatchUnableToImplementPolicy(const ResourceError&) override { }
313
314     void dispatchWillSendSubmitEvent(PassRefPtr<FormState>) override;
315     void dispatchWillSubmitForm(PassRefPtr<FormState>, FramePolicyFunction) override;
316
317     void revertToProvisionalState(DocumentLoader*) override { }
318     void setMainDocumentError(DocumentLoader*, const ResourceError&) override { }
319
320     void setMainFrameDocumentReady(bool) override { }
321
322     void startDownload(const ResourceRequest&, const String& suggestedName = String()) override { UNUSED_PARAM(suggestedName); }
323
324     void willChangeTitle(DocumentLoader*) override { }
325     void didChangeTitle(DocumentLoader*) override { }
326
327     void willReplaceMultipartContent() override { }
328     void didReplaceMultipartContent() override { }
329
330     void committedLoad(DocumentLoader*, const char*, int) override { }
331     void finishedLoading(DocumentLoader*) override { }
332
333     ResourceError cancelledError(const ResourceRequest&) override { return ResourceError(ResourceError::Type::Cancellation); }
334     ResourceError blockedError(const ResourceRequest&) override { return { }; }
335     ResourceError blockedByContentBlockerError(const ResourceRequest&) override { return { }; }
336     ResourceError cannotShowURLError(const ResourceRequest&) override { return { }; }
337     ResourceError interruptedForPolicyChangeError(const ResourceRequest&) override { return { }; }
338
339     ResourceError cannotShowMIMETypeError(const ResourceResponse&) override { return { }; }
340     ResourceError fileDoesNotExistError(const ResourceResponse&) override { return { }; }
341     ResourceError pluginWillHandleLoadError(const ResourceResponse&) override { return { }; }
342
343     bool shouldFallBack(const ResourceError&) override { return false; }
344
345     bool canHandleRequest(const ResourceRequest&) const override { return false; }
346     bool canShowMIMEType(const String&) const override { return false; }
347     bool canShowMIMETypeAsHTML(const String&) const override { return false; }
348     bool representationExistsForURLScheme(const String&) const override { return false; }
349     String generatedMIMETypeForURLScheme(const String&) const override { return ""; }
350
351     void frameLoadCompleted() override { }
352     void restoreViewState() override { }
353     void provisionalLoadStarted() override { }
354     void didFinishLoad() override { }
355     void prepareForDataSourceReplacement() override { }
356
357     Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) override;
358     void updateCachedDocumentLoader(DocumentLoader&) override { }
359     void setTitle(const StringWithDirection&, const URL&) override { }
360
361     String userAgent(const URL&) override { return ""; }
362
363     void savePlatformDataToCachedFrame(CachedFrame*) override { }
364     void transitionToCommittedFromCachedFrame(CachedFrame*) override { }
365 #if PLATFORM(IOS)
366     void didRestoreFrameHierarchyForCachedFrame() override { }
367 #endif
368     void transitionToCommittedForNewPage() override { }
369
370     void didSaveToPageCache() override { }
371     void didRestoreFromPageCache() override { }
372
373     void dispatchDidBecomeFrameset(bool) override { }
374
375     void updateGlobalHistory() override { }
376     void updateGlobalHistoryRedirectLinks() override { }
377     bool shouldGoToHistoryItem(HistoryItem*) const override { return false; }
378     void updateGlobalHistoryItemForPage() override { }
379     void saveViewStateToItem(HistoryItem&) override { }
380     bool canCachePage() const override { return false; }
381     void didDisplayInsecureContent() override { }
382     void didRunInsecureContent(SecurityOrigin*, const URL&) override { }
383     void didDetectXSS(const URL&, bool) override { }
384     RefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) override;
385     RefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) override;
386     void recreatePlugin(Widget*) override;
387     PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) override;
388
389     ObjectContentType objectContentType(const URL&, const String&) override { return ObjectContentType(); }
390     String overrideMediaType() const override { return String(); }
391
392     void redirectDataToPlugin(Widget*) override { }
393     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&) override { }
394
395     void registerForIconNotification(bool) override { }
396
397 #if PLATFORM(COCOA)
398     RemoteAXObjectRef accessibilityRemoteObject() override { return nullptr; }
399     NSCachedURLResponse* willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse* response) const override { return response; }
400 #endif
401 #if PLATFORM(WIN) && USE(CFNETWORK)
402     // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
403     bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) override { return true; }
404 #endif
405
406     PassRefPtr<FrameNetworkingContext> createNetworkingContext() override;
407
408 #if ENABLE(REQUEST_AUTOCOMPLETE)
409     void didRequestAutocomplete(PassRefPtr<FormState>) override { }
410 #endif
411
412     bool isEmptyFrameLoaderClient() override { return true; }
413
414     void prefetchDNS(const String&) override { }
415 };
416
417 class EmptyTextCheckerClient : public TextCheckerClient {
418 public:
419     bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const override { return true; }
420     void ignoreWordInSpellDocument(const String&) override { }
421     void learnWord(const String&) override { }
422     void checkSpellingOfString(StringView, int*, int*) override { }
423     String getAutoCorrectSuggestionForMisspelledWord(const String&) override { return String(); }
424     void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) override { }
425
426 #if USE(UNIFIED_TEXT_CHECKING)
427     Vector<TextCheckingResult> checkTextOfParagraph(StringView, TextCheckingTypeMask, const VisibleSelection&) override { return Vector<TextCheckingResult>(); }
428 #endif
429
430     void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) override { }
431     void requestCheckingOfString(PassRefPtr<TextCheckingRequest>, const VisibleSelection&) override;
432 };
433
434 class EmptyEditorClient : public EditorClient {
435     WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
436 public:
437     EmptyEditorClient() { }
438     virtual ~EmptyEditorClient() { }
439
440     bool shouldDeleteRange(Range*) override { return false; }
441     bool smartInsertDeleteEnabled() override { return false; }
442     bool isSelectTrailingWhitespaceEnabled() override { return false; }
443     bool isContinuousSpellCheckingEnabled() override { return false; }
444     void toggleContinuousSpellChecking() override { }
445     bool isGrammarCheckingEnabled() override { return false; }
446     void toggleGrammarChecking() override { }
447     int spellCheckerDocumentTag() override { return -1; }
448
449
450     bool shouldBeginEditing(Range*) override { return false; }
451     bool shouldEndEditing(Range*) override { return false; }
452     bool shouldInsertNode(Node*, Range*, EditorInsertAction) override { return false; }
453     bool shouldInsertText(const String&, Range*, EditorInsertAction) override { return false; }
454     bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) override { return false; }
455
456     bool shouldApplyStyle(StyleProperties*, Range*) override { return false; }
457     void didApplyStyle() override { }
458     bool shouldMoveRangeAfterDelete(Range*, Range*) override { return false; }
459
460     void didBeginEditing() override { }
461     void respondToChangedContents() override { }
462     void respondToChangedSelection(Frame*) override { }
463     void didChangeSelectionAndUpdateLayout() override { }
464     void discardedComposition(Frame*) override { }
465     void didEndEditing() override { }
466     void willWriteSelectionToPasteboard(Range*) override { }
467     void didWriteSelectionToPasteboard() override { }
468     void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) override { }
469     void requestCandidatesForSelection(const VisibleSelection&) override { }
470     void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) override { }
471
472     void registerUndoStep(PassRefPtr<UndoStep>) override;
473     void registerRedoStep(PassRefPtr<UndoStep>) override;
474     void clearUndoRedoOperations() override { }
475
476     bool canCopyCut(Frame*, bool defaultValue) const override { return defaultValue; }
477     bool canPaste(Frame*, bool defaultValue) const override { return defaultValue; }
478     bool canUndo() const override { return false; }
479     bool canRedo() const override { return false; }
480
481     void undo() override { }
482     void redo() override { }
483
484     void handleKeyboardEvent(KeyboardEvent*) override { }
485     void handleInputMethodKeydown(KeyboardEvent*) override { }
486
487     void textFieldDidBeginEditing(Element*) override { }
488     void textFieldDidEndEditing(Element*) override { }
489     void textDidChangeInTextField(Element*) override { }
490     bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) override { return false; }
491     void textWillBeDeletedInTextField(Element*) override { }
492     void textDidChangeInTextArea(Element*) override { }
493     void overflowScrollPositionChanged() override { }
494
495 #if PLATFORM(IOS)
496     void startDelayingAndCoalescingContentChangeNotifications() override { }
497     void stopDelayingAndCoalescingContentChangeNotifications() override { }
498     void writeDataToPasteboard(NSDictionary*) override { }
499     NSArray* supportedPasteboardTypesForCurrentSelection() override { return nullptr; }
500     NSArray* readDataFromPasteboard(NSString*, int) override { return nullptr; }
501     bool hasRichlyEditableSelection() override { return false; }
502     int getPasteboardItemsCount() override { return 0; }
503     DocumentFragment* documentFragmentFromDelegate(int) override { return nullptr; }
504     bool performsTwoStepPaste(DocumentFragment*) override { return false; }
505     int pasteboardChangeCount() override { return 0; }
506 #endif
507
508 #if PLATFORM(COCOA)
509     NSString* userVisibleString(NSURL*) override { return nullptr; }
510     DocumentFragment* documentFragmentFromAttributedString(NSAttributedString*, Vector<RefPtr<ArchiveResource>>&) override { return nullptr; };
511     void setInsertionPasteboard(const String&) override { };
512     NSURL *canonicalizeURL(NSURL*) override { return nullptr; }
513     NSURL *canonicalizeURLString(NSString*) override { return nullptr; }
514 #endif
515
516 #if USE(APPKIT)
517     void uppercaseWord() override { }
518     void lowercaseWord() override { }
519     void capitalizeWord() override { }
520 #endif
521
522 #if USE(AUTOMATIC_TEXT_REPLACEMENT)
523     void showSubstitutionsPanel(bool) override { }
524     bool substitutionsPanelIsShowing() override { return false; }
525     void toggleSmartInsertDelete() override { }
526     bool isAutomaticQuoteSubstitutionEnabled() override { return false; }
527     void toggleAutomaticQuoteSubstitution() override { }
528     bool isAutomaticLinkDetectionEnabled() override { return false; }
529     void toggleAutomaticLinkDetection() override { }
530     bool isAutomaticDashSubstitutionEnabled() override { return false; }
531     void toggleAutomaticDashSubstitution() override { }
532     bool isAutomaticTextReplacementEnabled() override { return false; }
533     void toggleAutomaticTextReplacement() override { }
534     bool isAutomaticSpellingCorrectionEnabled() override { return false; }
535     void toggleAutomaticSpellingCorrection() override { }
536 #endif
537
538 #if PLATFORM(GTK)
539     bool shouldShowUnicodeMenu() override { return false; }
540 #endif
541     TextCheckerClient* textChecker() override { return &m_textCheckerClient; }
542
543     void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) override { }
544     void updateSpellingUIWithMisspelledWord(const String&) override { }
545     void showSpellingUI(bool) override { }
546     bool spellingUIIsShowing() override { return false; }
547
548     void willSetInputMethodState() override { }
549     void setInputMethodState(bool) override { }
550
551 private:
552     EmptyTextCheckerClient m_textCheckerClient;
553 };
554
555 #if ENABLE(CONTEXT_MENUS)
556 class EmptyContextMenuClient : public ContextMenuClient {
557     WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
558 public:
559     EmptyContextMenuClient() { }
560     virtual ~EmptyContextMenuClient() {  }
561     void contextMenuDestroyed() override { }
562
563     void downloadURL(const URL&) override { }
564     void searchWithGoogle(const Frame*) override { }
565     void lookUpInDictionary(Frame*) override { }
566     bool isSpeaking() override { return false; }
567     void speak(const String&) override { }
568     void stopSpeaking() override { }
569
570 #if PLATFORM(COCOA)
571     void searchWithSpotlight() override { }
572 #endif
573
574 #if USE(ACCESSIBILITY_CONTEXT_MENUS)
575     void showContextMenu() override { }
576 #endif
577 };
578 #endif // ENABLE(CONTEXT_MENUS)
579
580 #if ENABLE(DRAG_SUPPORT)
581 class EmptyDragClient : public DragClient {
582     WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
583 public:
584     EmptyDragClient() { }
585     virtual ~EmptyDragClient() {}
586     void willPerformDragDestinationAction(DragDestinationAction, DragData&) override { }
587     void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) override { }
588     DragDestinationAction actionMaskForDrag(DragData&) override { return DragDestinationActionNone; }
589     DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) override { return DragSourceActionNone; }
590     void startDrag(DragImageRef, const IntPoint&, const IntPoint&, DataTransfer&, Frame&, bool) override { }
591     void dragControllerDestroyed() override { }
592 };
593 #endif // ENABLE(DRAG_SUPPORT)
594
595 class EmptyInspectorClient : public InspectorClient {
596     WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
597 public:
598     EmptyInspectorClient() { }
599     virtual ~EmptyInspectorClient() { }
600
601     void inspectedPageDestroyed() override { }
602     
603     Inspector::FrontendChannel* openLocalFrontend(InspectorController*) override { return nullptr; }
604     void bringFrontendToFront() override { }
605
606     void highlight() override { }
607     void hideHighlight() override { }
608 };
609
610 class EmptyDeviceClient : public DeviceClient {
611 public:
612     void startUpdating() override { }
613     void stopUpdating() override { }
614 };
615
616 class EmptyDeviceMotionClient : public DeviceMotionClient {
617 public:
618     void setController(DeviceMotionController*) override { }
619     DeviceMotionData* lastMotion() const override { return nullptr; }
620     void deviceMotionControllerDestroyed() override { }
621 };
622
623 class EmptyDeviceOrientationClient : public DeviceOrientationClient {
624 public:
625     void setController(DeviceOrientationController*) override { }
626     DeviceOrientationData* lastOrientation() const override { return nullptr; }
627     void deviceOrientationControllerDestroyed() override { }
628 };
629
630 class EmptyProgressTrackerClient : public ProgressTrackerClient {
631     void willChangeEstimatedProgress() override { }
632     void didChangeEstimatedProgress() override { }
633
634     void progressStarted(Frame&) override { }
635     void progressEstimateChanged(Frame&) override { }
636     void progressFinished(Frame&) override { }
637 };
638
639 class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
640     void logDiagnosticMessage(const String&, const String&, ShouldSample) override { }
641     void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) override { }
642     void logDiagnosticMessageWithValue(const String&, const String&, const String&, ShouldSample) override { }
643 };
644
645 void fillWithEmptyClients(PageConfiguration&);
646
647 }
648
649 #endif // EmptyClients_h