https://bugs.webkit.org/show_bug.cgi?id=77383
[WebKit-https.git] / Source / WebCore / loader / EmptyClients.h
1 /*
2  * Copyright (C) 2006 Eric Seidel (eric@webkit.org)
3  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
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 COMPUTER, 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 COMPUTER, 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 #ifndef EmptyClients_h
29 #define EmptyClients_h
30
31 #include "ChromeClient.h"
32 #include "ContextMenuClient.h"
33 #include "DeviceMotionClient.h"
34 #include "DeviceOrientationClient.h"
35 #include "DocumentLoader.h"
36 #include "DragClient.h"
37 #include "EditCommand.h"
38 #include "EditorClient.h"
39 #include "TextCheckerClient.h"
40 #include "FloatRect.h"
41 #include "FocusDirection.h"
42 #include "FrameLoaderClient.h"
43 #include "FrameNetworkingContext.h"
44 #include "InspectorClient.h"
45 #include "PopupMenu.h"
46 #include "ResourceError.h"
47 #include "SearchPopupMenu.h"
48
49 #if USE(V8)
50 #include <v8.h>
51 #endif
52
53 #if ENABLE(INPUT_COLOR)
54 #include "ColorChooser.h"
55 #endif
56
57 #if ENABLE(WEB_INTENTS)
58 #include "IntentRequest.h"
59 #endif
60
61 /*
62  This file holds empty Client stubs for use by WebCore.
63  Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.
64  This tree depends heavily on Clients (usually provided by WebKit classes).
65
66  This file was first created for SVGImage as it had no way to access the current Page (nor should it,
67  since Images are not tied to a page).
68  See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
69
70  Ideally, whenever you change a Client class, you should add a stub here.
71  Brittle, yes.  Unfortunate, yes.  Hopefully temporary.
72 */
73
74 namespace WebCore {
75
76 class GraphicsContext3D;
77
78 class EmptyPopupMenu : public PopupMenu {
79 public:
80     virtual void show(const IntRect&, FrameView*, int) {}
81     virtual void hide() {}
82     virtual void updateFromElement() {}
83     virtual void disconnectClient() {}
84 };
85
86 class EmptySearchPopupMenu : public SearchPopupMenu {
87 public:
88     virtual PopupMenu* popupMenu() { return m_popup.get(); }
89     virtual void saveRecentSearches(const AtomicString&, const Vector<String>&) {}
90     virtual void loadRecentSearches(const AtomicString&, Vector<String>&) {}
91     virtual bool enabled() { return false; }
92
93 private:
94     RefPtr<EmptyPopupMenu> m_popup;
95 };
96
97 class EmptyChromeClient : public ChromeClient {
98 public:
99     virtual ~EmptyChromeClient() { }
100     virtual void chromeDestroyed() { }
101
102     virtual void* webView() const { return 0; }
103     virtual void setWindowRect(const FloatRect&) { }
104     virtual FloatRect windowRect() { return FloatRect(); }
105
106     virtual FloatRect pageRect() { return FloatRect(); }
107
108     virtual void focus() { }
109     virtual void unfocus() { }
110
111     virtual bool canTakeFocus(FocusDirection) { return false; }
112     virtual void takeFocus(FocusDirection) { }
113
114     virtual void focusedNodeChanged(Node*) { }
115     virtual void focusedFrameChanged(Frame*) { }
116
117     virtual Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) { return 0; }
118     virtual void show() { }
119
120     virtual bool canRunModal() { return false; }
121     virtual void runModal() { }
122
123     virtual void setToolbarsVisible(bool) { }
124     virtual bool toolbarsVisible() { return false; }
125
126     virtual void setStatusbarVisible(bool) { }
127     virtual bool statusbarVisible() { return false; }
128
129     virtual void setScrollbarsVisible(bool) { }
130     virtual bool scrollbarsVisible() { return false; }
131
132     virtual void setMenubarVisible(bool) { }
133     virtual bool menubarVisible() { return false; }
134
135     virtual void setResizable(bool) { }
136
137     virtual void addMessageToConsole(MessageSource, MessageType, MessageLevel, const String&, unsigned, const String&) { }
138
139     virtual bool canRunBeforeUnloadConfirmPanel() { return false; }
140     virtual bool runBeforeUnloadConfirmPanel(const String&, Frame*) { return true; }
141
142     virtual void closeWindowSoon() { }
143
144     virtual void runJavaScriptAlert(Frame*, const String&) { }
145     virtual bool runJavaScriptConfirm(Frame*, const String&) { return false; }
146     virtual bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) { return false; }
147     virtual bool shouldInterruptJavaScript() { return false; }
148
149     virtual bool selectItemWritingDirectionIsNatural() { return false; }
150     virtual bool selectItemAlignmentFollowsMenuWritingDirection() { return false; }
151     virtual bool hasOpenedPopup() const OVERRIDE { return false; }
152     virtual PassRefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const { return adoptRef(new EmptyPopupMenu()); }
153     virtual PassRefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const { return adoptRef(new EmptySearchPopupMenu()); }
154
155 #if ENABLE(CONTEXT_MENUS)
156     virtual void showContextMenu() { }
157 #endif
158
159 #if ENABLE(REGISTER_PROTOCOL_HANDLER)
160     virtual void registerProtocolHandler(const String&, const String&, const String&, const String&) { }
161 #endif
162
163     virtual void setStatusbarText(const String&) { }
164
165     virtual KeyboardUIMode keyboardUIMode() { return KeyboardAccessDefault; }
166
167     virtual IntRect windowResizerRect() const { return IntRect(); }
168
169     virtual void invalidateRootView(const IntRect&, bool) OVERRIDE { }
170     virtual void invalidateContentsAndRootView(const IntRect&, bool) OVERRIDE { }
171     virtual void invalidateContentsForSlowScroll(const IntRect&, bool) OVERRIDE { }
172     virtual void scroll(const IntSize&, const IntRect&, const IntRect&) { }
173 #if USE(TILED_BACKING_STORE)
174     virtual void delegatedScrollRequested(const IntPoint&) { }
175 #endif
176 #if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
177     virtual void scheduleAnimation() { }
178 #endif
179
180     virtual IntPoint screenToRootView(const IntPoint& p) const OVERRIDE { return p; }
181     virtual IntRect rootViewToScreen(const IntRect& r) const OVERRIDE { return r; }
182     virtual PlatformPageClient platformPageClient() const { return 0; }
183     virtual void contentsSizeChanged(Frame*, const IntSize&) const { }
184
185     virtual void scrollbarsModeDidChange() const { }
186     virtual void mouseDidMoveOverElement(const HitTestResult&, unsigned) { }
187
188     virtual void setToolTip(const String&, TextDirection) { }
189
190     virtual void print(Frame*) { }
191
192 #if ENABLE(SQL_DATABASE)
193     virtual void exceededDatabaseQuota(Frame*, const String&) { }
194 #endif
195
196     virtual void reachedMaxAppCacheSize(int64_t) { }
197     virtual void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t) { }
198
199 #if ENABLE(DIRECTORY_UPLOAD)
200     virtual void enumerateChosenDirectory(FileChooser*) { }
201 #endif
202
203 #if ENABLE(INPUT_COLOR)
204     virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) { return nullptr; }
205 #endif
206
207     virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) { }
208     virtual void loadIconForFiles(const Vector<String>&, FileIconLoader*) { }
209
210     virtual void formStateDidChange(const Node*) { }
211
212     virtual void elementDidFocus(const Node*) { }
213     virtual void elementDidBlur(const Node*) { }
214
215     virtual void setCursor(const Cursor&) { }
216     virtual void setCursorHiddenUntilMouseMoves(bool) { }
217
218     virtual void scrollRectIntoView(const IntRect&) const { }
219
220     virtual void requestGeolocationPermissionForFrame(Frame*, Geolocation*) {}
221     virtual void cancelGeolocationPermissionRequestForFrame(Frame*, Geolocation*) {}
222
223 #if USE(ACCELERATED_COMPOSITING)
224     virtual void attachRootGraphicsLayer(Frame*, GraphicsLayer*) {}
225     virtual void setNeedsOneShotDrawingSynchronization() {}
226     virtual void scheduleCompositingLayerSync() {}
227 #endif
228
229 #if PLATFORM(WIN)
230     virtual void setLastSetCursorToCurrentCursor() { }
231 #endif
232 #if ENABLE(TOUCH_EVENTS)
233     virtual void needTouchEvents(bool) { }
234 #endif
235     
236     virtual void numWheelEventHandlersChanged(unsigned) { }
237     
238     virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return false; }
239 };
240
241 class EmptyFrameLoaderClient : public FrameLoaderClient {
242     WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
243 public:
244     EmptyFrameLoaderClient() { }
245     virtual ~EmptyFrameLoaderClient() {  }
246     virtual void frameLoaderDestroyed() { }
247
248     virtual bool hasWebView() const { return true; } // mainly for assertions
249
250     virtual void makeRepresentation(DocumentLoader*) { }
251     virtual void forceLayout() { }
252     virtual void forceLayoutForNonHTML() { }
253
254     virtual void setCopiesOnScroll() { }
255
256     virtual void detachedFromParent2() { }
257     virtual void detachedFromParent3() { }
258
259     virtual void download(ResourceHandle*, const ResourceRequest&, const ResourceResponse&) { }
260
261     virtual void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) { }
262     virtual bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) { return false; }
263     virtual void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) { }
264     virtual void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) { }
265     virtual void dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) { }
266 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
267     virtual bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) { return false; }
268 #endif
269     virtual void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) { }
270     virtual void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) { }
271     virtual void dispatchDidFinishLoading(DocumentLoader*, unsigned long) { }
272     virtual void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) { }
273     virtual bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) { return false; }
274
275     virtual void dispatchDidHandleOnloadEvents() { }
276     virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { }
277     virtual void dispatchDidCancelClientRedirect() { }
278     virtual void dispatchWillPerformClientRedirect(const KURL&, double, double) { }
279     virtual void dispatchDidChangeLocationWithinPage() { }
280     virtual void dispatchDidPushStateWithinPage() { }
281     virtual void dispatchDidReplaceStateWithinPage() { }
282     virtual void dispatchDidPopStateWithinPage() { }
283     virtual void dispatchWillClose() { }
284     virtual void dispatchDidReceiveIcon() { }
285     virtual void dispatchDidStartProvisionalLoad() { }
286     virtual void dispatchDidReceiveTitle(const StringWithDirection&) { }
287     virtual void dispatchDidChangeIcons(IconType) { }
288     virtual void dispatchDidCommitLoad() { }
289     virtual void dispatchDidFailProvisionalLoad(const ResourceError&) { }
290     virtual void dispatchDidFailLoad(const ResourceError&) { }
291     virtual void dispatchDidFinishDocumentLoad() { }
292     virtual void dispatchDidFinishLoad() { }
293     virtual void dispatchDidFirstLayout() { }
294     virtual void dispatchDidFirstVisuallyNonEmptyLayout() { }
295     virtual void dispatchDidNewFirstVisuallyNonEmptyLayout() { }
296
297     virtual Frame* dispatchCreatePage(const NavigationAction&) { return 0; }
298     virtual void dispatchShow() { }
299
300     virtual void dispatchDecidePolicyForResponse(FramePolicyFunction, const ResourceResponse&, const ResourceRequest&) { }
301     virtual void dispatchDecidePolicyForNewWindowAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&) { }
302     virtual void dispatchDecidePolicyForNavigationAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>) { }
303     virtual void cancelPolicyCheck() { }
304
305     virtual void dispatchUnableToImplementPolicy(const ResourceError&) { }
306
307     virtual void dispatchWillSendSubmitEvent(HTMLFormElement*) { }
308     virtual void dispatchWillSubmitForm(FramePolicyFunction, PassRefPtr<FormState>) { }
309
310     virtual void dispatchDidLoadMainResource(DocumentLoader*) { }
311     virtual void revertToProvisionalState(DocumentLoader*) { }
312     virtual void setMainDocumentError(DocumentLoader*, const ResourceError&) { }
313
314     virtual void willChangeEstimatedProgress() { }
315     virtual void didChangeEstimatedProgress() { }
316     virtual void postProgressStartedNotification() { }
317     virtual void postProgressEstimateChangedNotification() { }
318     virtual void postProgressFinishedNotification() { }
319
320     virtual void setMainFrameDocumentReady(bool) { }
321
322     virtual void startDownload(const ResourceRequest&, const String& suggestedName = String()) { UNUSED_PARAM(suggestedName); }
323
324     virtual void willChangeTitle(DocumentLoader*) { }
325     virtual void didChangeTitle(DocumentLoader*) { }
326
327     virtual void committedLoad(DocumentLoader*, const char*, int) { }
328     virtual void finishedLoading(DocumentLoader*) { }
329
330     virtual ResourceError cancelledError(const ResourceRequest&) { ResourceError error("", 0, "", ""); error.setIsCancellation(true); return error; }
331     virtual ResourceError blockedError(const ResourceRequest&) { return ResourceError("", 0, "", ""); }
332     virtual ResourceError cannotShowURLError(const ResourceRequest&) { return ResourceError("", 0, "", ""); }
333     virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) { return ResourceError("", 0, "", ""); }
334
335     virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) { return ResourceError("", 0, "", ""); }
336     virtual ResourceError fileDoesNotExistError(const ResourceResponse&) { return ResourceError("", 0, "", ""); }
337     virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) { return ResourceError("", 0, "", ""); }
338
339     virtual bool shouldFallBack(const ResourceError&) { return false; }
340
341     virtual bool canHandleRequest(const ResourceRequest&) const { return false; }
342     virtual bool canShowMIMEType(const String&) const { return false; }
343     virtual bool canShowMIMETypeAsHTML(const String&) const { return false; }
344     virtual bool representationExistsForURLScheme(const String&) const { return false; }
345     virtual String generatedMIMETypeForURLScheme(const String&) const { return ""; }
346
347     virtual void frameLoadCompleted() { }
348     virtual void restoreViewState() { }
349     virtual void provisionalLoadStarted() { }
350     virtual bool shouldTreatURLAsSameAsCurrent(const KURL&) const { return false; }
351     virtual void didFinishLoad() { }
352     virtual void prepareForDataSourceReplacement() { }
353
354     virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData) { return DocumentLoader::create(request, substituteData); }
355     virtual void setTitle(const StringWithDirection&, const KURL&) { }
356
357     virtual String userAgent(const KURL&) { return ""; }
358
359     virtual void savePlatformDataToCachedFrame(CachedFrame*) { }
360     virtual void transitionToCommittedFromCachedFrame(CachedFrame*) { }
361     virtual void transitionToCommittedForNewPage() { }    
362
363     virtual void didSaveToPageCache() { }
364     virtual void didRestoreFromPageCache() { }
365
366     virtual void dispatchDidBecomeFrameset(bool) { }
367
368     virtual void updateGlobalHistory() { }
369     virtual void updateGlobalHistoryRedirectLinks() { }
370     virtual bool shouldGoToHistoryItem(HistoryItem*) const { return false; }
371     virtual bool shouldStopLoadingForHistoryItem(HistoryItem*) const { return false; }
372     virtual void updateGlobalHistoryItemForPage() { }
373     virtual void saveViewStateToItem(HistoryItem*) { }
374     virtual bool canCachePage() const { return false; }
375     virtual void didDisplayInsecureContent() { }
376     virtual void didRunInsecureContent(SecurityOrigin*, const KURL&) { }
377     virtual void didDetectXSS(const KURL&, bool) { }
378     virtual PassRefPtr<Frame> createFrame(const KURL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) { return 0; }
379     virtual void didTransferChildFrameToNewDocument(Page*) { }
380     virtual void transferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*) { }
381     virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool) { return 0; }
382     virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL&, const Vector<String>&, const Vector<String>&) { return 0; }
383 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
384     virtual PassRefPtr<Widget> createMediaPlayerProxyPlugin(const IntSize&, HTMLMediaElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&) { return 0; }
385     virtual void hideMediaPlayerProxyPlugin(Widget*) { }
386     virtual void showMediaPlayerProxyPlugin(Widget*) { }
387 #endif
388
389     virtual ObjectContentType objectContentType(const KURL&, const String&, bool) { return ObjectContentType(); }
390     virtual String overrideMediaType() const { return String(); }
391
392     virtual void redirectDataToPlugin(Widget*) { }
393     virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*) { }
394     virtual void documentElementAvailable() { }
395     virtual void didPerformFirstNavigation() const { }
396
397     virtual void registerForIconNotification(bool) { }
398
399 #if USE(V8)
400     virtual void didCreateScriptContext(v8::Handle<v8::Context>, int worldId) { }
401     virtual void willReleaseScriptContext(v8::Handle<v8::Context>, int worldId) { }
402     virtual bool allowScriptExtension(const String& extensionName, int extensionGroup, int worldId) { return false; }
403 #endif
404
405 #if PLATFORM(MAC)
406     virtual RemoteAXObjectRef accessibilityRemoteObject() { return 0; }
407     virtual NSCachedURLResponse* willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse* response) const { return response; }
408 #endif
409 #if PLATFORM(WIN) && USE(CFNETWORK)
410     // FIXME: Windows should use willCacheResponse - <https://bugs.webkit.org/show_bug.cgi?id=57257>.
411     virtual bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) { return true; }
412 #endif
413
414     virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext() { return PassRefPtr<FrameNetworkingContext>(); }
415
416 #if ENABLE(WEB_INTENTS)
417     virtual void dispatchIntent(PassRefPtr<IntentRequest>) { }
418 #endif
419 };
420
421 class EmptyTextCheckerClient : public TextCheckerClient {
422 public:
423     virtual void ignoreWordInSpellDocument(const String&) { }
424     virtual void learnWord(const String&) { }
425     virtual void checkSpellingOfString(const UChar*, int, int*, int*) { }
426     virtual String getAutoCorrectSuggestionForMisspelledWord(const String&) { return String(); }
427     virtual void checkGrammarOfString(const UChar*, int, Vector<GrammarDetail>&, int*, int*) { }
428
429 #if USE(UNIFIED_TEXT_CHECKING)
430     virtual void checkTextOfParagraph(const UChar*, int, TextCheckingTypeMask, Vector<TextCheckingResult>&) { };
431 #endif
432
433     virtual void getGuessesForWord(const String&, const String&, Vector<String>&) { }
434     virtual void requestCheckingOfString(SpellChecker*, int, TextCheckingTypeMask, const String&) { }
435 };
436
437 class EmptyEditorClient : public EditorClient {
438     WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
439 public:
440     EmptyEditorClient() { }
441     virtual ~EmptyEditorClient() { }
442     virtual void pageDestroyed() { }
443
444     virtual bool shouldDeleteRange(Range*) { return false; }
445     virtual bool shouldShowDeleteInterface(HTMLElement*) { return false; }
446     virtual bool smartInsertDeleteEnabled() { return false; }
447     virtual bool isSelectTrailingWhitespaceEnabled() { return false; }
448     virtual bool isContinuousSpellCheckingEnabled() { return false; }
449     virtual void toggleContinuousSpellChecking() { }
450     virtual bool isGrammarCheckingEnabled() { return false; }
451     virtual void toggleGrammarChecking() { }
452     virtual int spellCheckerDocumentTag() { return -1; }
453
454     virtual bool selectWordBeforeMenuEvent() { return false; }
455     virtual bool isEditable() { return false; }
456
457     virtual bool shouldBeginEditing(Range*) { return false; }
458     virtual bool shouldEndEditing(Range*) { return false; }
459     virtual bool shouldInsertNode(Node*, Range*, EditorInsertAction) { return false; }
460     virtual bool shouldInsertText(const String&, Range*, EditorInsertAction) { return false; }
461     virtual bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) { return false; }
462
463     virtual bool shouldApplyStyle(CSSStyleDeclaration*, Range*) { return false; }
464     virtual bool shouldMoveRangeAfterDelete(Range*, Range*) { return false; }
465
466     virtual void didBeginEditing() { }
467     virtual void respondToChangedContents() { }
468     virtual void respondToChangedSelection(Frame*) { }
469     virtual void didEndEditing() { }
470     virtual void didWriteSelectionToPasteboard() { }
471     virtual void didSetSelectionTypesForPasteboard() { }
472
473     virtual void registerUndoStep(PassRefPtr<UndoStep>) { }
474     virtual void registerRedoStep(PassRefPtr<UndoStep>) { }
475     virtual void clearUndoRedoOperations() { }
476
477     virtual bool canCopyCut(Frame*, bool defaultValue) const { return defaultValue; }
478     virtual bool canPaste(Frame*, bool defaultValue) const { return defaultValue; }
479     virtual bool canUndo() const { return false; }
480     virtual bool canRedo() const { return false; }
481
482     virtual void undo() { }
483     virtual void redo() { }
484
485     virtual void handleKeyboardEvent(KeyboardEvent*) { }
486     virtual void handleInputMethodKeydown(KeyboardEvent*) { }
487
488     virtual void textFieldDidBeginEditing(Element*) { }
489     virtual void textFieldDidEndEditing(Element*) { }
490     virtual void textDidChangeInTextField(Element*) { }
491     virtual bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) { return false; }
492     virtual void textWillBeDeletedInTextField(Element*) { }
493     virtual void textDidChangeInTextArea(Element*) { }
494
495 #if PLATFORM(MAC)
496     virtual void markedTextAbandoned(Frame*) { }
497
498     virtual NSString* userVisibleString(NSURL*) { return 0; }
499     virtual DocumentFragment* documentFragmentFromAttributedString(NSAttributedString*, Vector<RefPtr<ArchiveResource> >&) { return 0; };
500     virtual void setInsertionPasteboard(NSPasteboard*) { };
501     virtual NSURL* canonicalizeURL(NSURL*) { return 0; }
502     virtual NSURL* canonicalizeURLString(NSString*) { return 0; }
503 #endif
504 #if PLATFORM(MAC) && !defined(BUILDING_ON_LEOPARD)
505     virtual void uppercaseWord() { }
506     virtual void lowercaseWord() { }
507     virtual void capitalizeWord() { }
508     virtual void showSubstitutionsPanel(bool) { }
509     virtual bool substitutionsPanelIsShowing() { return false; }
510     virtual void toggleSmartInsertDelete() { }
511     virtual bool isAutomaticQuoteSubstitutionEnabled() { return false; }
512     virtual void toggleAutomaticQuoteSubstitution() { }
513     virtual bool isAutomaticLinkDetectionEnabled() { return false; }
514     virtual void toggleAutomaticLinkDetection() { }
515     virtual bool isAutomaticDashSubstitutionEnabled() { return false; }
516     virtual void toggleAutomaticDashSubstitution() { }
517     virtual bool isAutomaticTextReplacementEnabled() { return false; }
518     virtual void toggleAutomaticTextReplacement() { }
519     virtual bool isAutomaticSpellingCorrectionEnabled() { return false; }
520     virtual void toggleAutomaticSpellingCorrection() { }
521 #endif
522     TextCheckerClient* textChecker() { return &m_textCheckerClient; }
523
524 #if USE(AUTOCORRECTION_PANEL)
525     virtual void showCorrectionPanel(CorrectionPanelInfo::PanelType, const FloatRect&, const String&, const String&, const Vector<String>&) { }
526     virtual void dismissCorrectionPanel(ReasonForDismissingCorrectionPanel) { }
527     virtual String dismissCorrectionPanelSoon(ReasonForDismissingCorrectionPanel) { return String(); }
528     virtual void recordAutocorrectionResponse(AutocorrectionResponseType, const String&, const String&) { }
529 #endif
530     virtual void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) { }
531     virtual void updateSpellingUIWithMisspelledWord(const String&) { }
532     virtual void showSpellingUI(bool) { }
533     virtual bool spellingUIIsShowing() { return false; }
534
535     virtual void willSetInputMethodState() { }
536     virtual void setInputMethodState(bool) { }
537
538 private:
539     EmptyTextCheckerClient m_textCheckerClient;
540 };
541
542 #if ENABLE(CONTEXT_MENUS)
543 class EmptyContextMenuClient : public ContextMenuClient {
544     WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
545 public:
546     EmptyContextMenuClient() { }
547     virtual ~EmptyContextMenuClient() {  }
548     virtual void contextMenuDestroyed() { }
549
550 #if USE(CROSS_PLATFORM_CONTEXT_MENUS)
551     virtual PassOwnPtr<ContextMenu> customizeMenu(PassOwnPtr<ContextMenu>) { return nullptr; }
552 #else
553     virtual PlatformMenuDescription getCustomMenuFromDefaultItems(ContextMenu*) { return 0; }
554 #endif
555     virtual void contextMenuItemSelected(ContextMenuItem*, const ContextMenu*) { }
556
557     virtual void downloadURL(const KURL&) { }
558     virtual void copyImageToClipboard(const HitTestResult&) { }
559     virtual void searchWithGoogle(const Frame*) { }
560     virtual void lookUpInDictionary(Frame*) { }
561     virtual bool isSpeaking() { return false; }
562     virtual void speak(const String&) { }
563     virtual void stopSpeaking() { }
564
565 #if PLATFORM(MAC)
566     virtual void searchWithSpotlight() { }
567 #endif
568 };
569 #endif // ENABLE(CONTEXT_MENUS)
570
571 #if ENABLE(DRAG_SUPPORT)
572 class EmptyDragClient : public DragClient {
573     WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
574 public:
575     EmptyDragClient() { }
576     virtual ~EmptyDragClient() {}
577     virtual void willPerformDragDestinationAction(DragDestinationAction, DragData*) { }
578     virtual void willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*) { }
579     virtual DragDestinationAction actionMaskForDrag(DragData*) { return DragDestinationActionNone; }
580     virtual DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) { return DragSourceActionNone; }
581     virtual void startDrag(DragImageRef, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool) { }
582     virtual void dragControllerDestroyed() { }
583 };
584 #endif // ENABLE(DRAG_SUPPORT)
585
586 class EmptyInspectorClient : public InspectorClient {
587     WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
588 public:
589     EmptyInspectorClient() { }
590     virtual ~EmptyInspectorClient() { }
591
592     virtual void inspectorDestroyed() { }
593     
594     virtual void openInspectorFrontend(InspectorController*) { }
595     virtual void closeInspectorFrontend() { }
596     virtual void bringFrontendToFront() { }
597
598     virtual void highlight() { }
599     virtual void hideHighlight() { }
600
601     virtual bool sendMessageToFrontend(const String&) { return false; }
602 };
603
604 class EmptyDeviceMotionClient : public DeviceMotionClient {
605 public:
606     virtual void setController(DeviceMotionController*) { }
607     virtual void startUpdating() { }
608     virtual void stopUpdating() { }
609     virtual DeviceMotionData* currentDeviceMotion() const { return 0; }
610     virtual void deviceMotionControllerDestroyed() { }
611 };
612
613 class EmptyDeviceOrientationClient : public DeviceOrientationClient {
614 public:
615     virtual void setController(DeviceOrientationController*) { }
616     virtual void startUpdating() { }
617     virtual void stopUpdating() { }
618     virtual DeviceOrientation* lastOrientation() const { return 0; }
619     virtual void deviceOrientationControllerDestroyed() { }
620 };
621
622 }
623
624 #endif // EmptyClients_h