#pragma once
#include "ChromeClient.h"
#include "ContextMenuClient.h"
#include "DeviceMotionClient.h"
#include "DeviceOrientationClient.h"
#include "DiagnosticLoggingClient.h"
#include "DocumentFragment.h"
#include "DragClient.h"
#include "EditorClient.h"
#include "FloatRect.h"
#include "FocusDirection.h"
#include "FrameLoaderClient.h"
#include "InspectorClient.h"
#include "ProgressTrackerClient.h"
#include "ResourceError.h"
#include "SessionID.h"
#include "SocketProvider.h"
#include "TextCheckerClient.h"
#include "VisitedLinkStore.h"
#include <wtf/text/StringView.h>
#if ENABLE(USER_MESSAGE_HANDLERS)
#include "UserMessageHandlerDescriptor.h"
#endif
#if ENABLE(CONTENT_EXTENSIONS)
#include "CompiledContentExtension.h"
#endif
namespace WebCore {
class GraphicsContext3D;
class Page;
class PageConfiguration;
class EmptyChromeClient : public ChromeClient {
WTF_MAKE_FAST_ALLOCATED;
public:
virtual ~EmptyChromeClient() { }
void chromeDestroyed() override { }
void setWindowRect(const FloatRect&) override { }
FloatRect windowRect() override { return FloatRect(); }
FloatRect pageRect() override { return FloatRect(); }
void focus() override { }
void unfocus() override { }
bool canTakeFocus(FocusDirection) override { return false; }
void takeFocus(FocusDirection) override { }
void focusedElementChanged(Element*) override { }
void focusedFrameChanged(Frame*) override { }
Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) override { return nullptr; }
void show() override { }
bool canRunModal() override { return false; }
void runModal() override { }
void setToolbarsVisible(bool) override { }
bool toolbarsVisible() override { return false; }
void setStatusbarVisible(bool) override { }
bool statusbarVisible() override { return false; }
void setScrollbarsVisible(bool) override { }
bool scrollbarsVisible() override { return false; }
void setMenubarVisible(bool) override { }
bool menubarVisible() override { return false; }
void setResizable(bool) override { }
void addMessageToConsole(MessageSource, MessageLevel, const String&, unsigned, unsigned, const String&) override { }
bool canRunBeforeUnloadConfirmPanel() override { return false; }
bool runBeforeUnloadConfirmPanel(const String&, Frame*) override { return true; }
void closeWindowSoon() override { }
void runJavaScriptAlert(Frame*, const String&) override { }
bool runJavaScriptConfirm(Frame*, const String&) override { return false; }
bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) override { return false; }
bool selectItemWritingDirectionIsNatural() override { return false; }
bool selectItemAlignmentFollowsMenuWritingDirection() override { return false; }
bool hasOpenedPopup() const override { return false; }
RefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const override;
RefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const override;
void setStatusbarText(const String&) override { }
KeyboardUIMode keyboardUIMode() override { return KeyboardAccessDefault; }
void invalidateRootView(const IntRect&) override { }
void invalidateContentsAndRootView(const IntRect&) override { }
void invalidateContentsForSlowScroll(const IntRect&) override { }
void scroll(const IntSize&, const IntRect&, const IntRect&) override { }
#if USE(COORDINATED_GRAPHICS)
void delegatedScrollRequested(const IntPoint&) override { }
#endif
#if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
void scheduleAnimation() override { }
#endif
IntPoint screenToRootView(const IntPoint& p) const override { return p; }
IntRect rootViewToScreen(const IntRect& r) const override { return r; }
#if PLATFORM(IOS)
IntPoint accessibilityScreenToRootView(const IntPoint& p) const override { return p; };
IntRect rootViewToAccessibilityScreen(const IntRect& r) const override { return r; };
#endif
PlatformPageClient platformPageClient() const override { return 0; }
void contentsSizeChanged(Frame*, const IntSize&) const override { }
void scrollbarsModeDidChange() const override { }
void mouseDidMoveOverElement(const HitTestResult&, unsigned) override { }
void setToolTip(const String&, TextDirection) override { }
void print(Frame*) override { }
void exceededDatabaseQuota(Frame*, const String&, DatabaseDetails) override { }
void reachedMaxAppCacheSize(int64_t) override { }
void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t) override { }
#if ENABLE(INPUT_TYPE_COLOR)
std::unique_ptr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) override;
#endif
void runOpenPanel(Frame*, PassRefPtr<FileChooser>) override;
void loadIconForFiles(const Vector<String>&, FileIconLoader*) override { }
void elementDidFocus(const Node*) override { }
void elementDidBlur(const Node*) override { }
#if !PLATFORM(IOS)
void setCursor(const Cursor&) override { }
void setCursorHiddenUntilMouseMoves(bool) override { }
#endif
void scrollRectIntoView(const IntRect&) const override { }
void attachRootGraphicsLayer(Frame*, GraphicsLayer*) override { }
void attachViewOverlayGraphicsLayer(Frame*, GraphicsLayer*) override { }
void setNeedsOneShotDrawingSynchronization() override { }
void scheduleCompositingLayerFlush() override { }
#if PLATFORM(WIN)
void setLastSetCursorToCurrentCursor() override { }
void AXStartFrameLoad() override { }
void AXFinishFrameLoad() override { }
#endif
#if PLATFORM(IOS)
#if ENABLE(IOS_TOUCH_EVENTS)
void didPreventDefaultForEvent() override { }
#endif
void didReceiveMobileDocType(bool) override { }
void setNeedsScrollNotifications(Frame*, bool) override { }
void observedContentChange(Frame*) override { }
void clearContentChangeObservers(Frame*) override { }
void notifyRevealedSelectionByScrollingFrame(Frame*) override { }
void didLayout(LayoutType) override { }
void didStartOverflowScroll() override { }
void didEndOverflowScroll() override { }
void suppressFormNotifications() override { }
void restoreFormNotifications() override { }
void addOrUpdateScrollingLayer(Node*, PlatformLayer*, PlatformLayer*, const IntSize&, bool, bool) override { }
void removeScrollingLayer(Node*, PlatformLayer*, PlatformLayer*) override { }
void webAppOrientationsUpdated() override { };
void showPlaybackTargetPicker(bool) override { };
#endif // PLATFORM(IOS)
#if ENABLE(ORIENTATION_EVENTS)
int deviceOrientation() const override { return 0; }
#endif
#if PLATFORM(IOS)
bool isStopping() override { return false; }
#endif
#if ENABLE(TOUCH_EVENTS)
void needTouchEvents(bool) override { }
#endif
void wheelEventHandlersChanged(bool) override { }
bool isEmptyChromeClient() const override { return true; }
void didAssociateFormControls(const Vector<RefPtr<Element>>&) override { }
bool shouldNotifyOnFormChanges() override { return false; }
};
class EmptyFrameLoaderClient : public FrameLoaderClient {
WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
public:
EmptyFrameLoaderClient() { }
virtual ~EmptyFrameLoaderClient() { }
void frameLoaderDestroyed() override { }
bool hasWebView() const override { return true; }
void makeRepresentation(DocumentLoader*) override { }
#if PLATFORM(IOS)
bool forceLayoutOnRestoreFromPageCache() override { return false; }
#endif
void forceLayoutForNonHTML() override { }
void setCopiesOnScroll() override { }
void detachedFromParent2() override { }
void detachedFromParent3() override { }
void convertMainResourceLoadToDownload(DocumentLoader*, SessionID, const ResourceRequest&, const ResourceResponse&) override { }
void assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const ResourceRequest&) override { }
bool shouldUseCredentialStorage(DocumentLoader*, unsigned long) override { return false; }
void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) override { }
void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&) override { }
#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
bool canAuthenticateAgainstProtectionSpace(DocumentLoader*, unsigned long, const ProtectionSpace&) override { return false; }
#endif
#if PLATFORM(IOS)
RetainPtr<CFDictionaryRef> connectionProperties(DocumentLoader*, unsigned long) override { return nullptr; }
#endif
void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) override { }
void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int) override { }
void dispatchDidFinishLoading(DocumentLoader*, unsigned long) override { }
#if ENABLE(DATA_DETECTION)
void dispatchDidFinishDataDetection(NSArray *) override { }
#endif
void dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&) override { }
bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) override { return false; }
void dispatchDidDispatchOnloadEvents() override { }
void dispatchDidReceiveServerRedirectForProvisionalLoad() override { }
void dispatchDidCancelClientRedirect() override { }
void dispatchWillPerformClientRedirect(const URL&, double, double) override { }
void dispatchDidChangeLocationWithinPage() override { }
void dispatchDidPushStateWithinPage() override { }
void dispatchDidReplaceStateWithinPage() override { }
void dispatchDidPopStateWithinPage() override { }
void dispatchWillClose() override { }
void dispatchDidReceiveIcon() override { }
void dispatchDidStartProvisionalLoad() override { }
void dispatchDidReceiveTitle(const StringWithDirection&) override { }
void dispatchDidCommitLoad(std::optional<HasInsecureContent>) override { }
void dispatchDidFailProvisionalLoad(const ResourceError&) override { }
void dispatchDidFailLoad(const ResourceError&) override { }
void dispatchDidFinishDocumentLoad() override { }
void dispatchDidFinishLoad() override { }
void dispatchDidReachLayoutMilestone(LayoutMilestones) override { }
Frame* dispatchCreatePage(const NavigationAction&) override { return nullptr; }
void dispatchShow() override { }
void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, FramePolicyFunction) override { }
void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&, FramePolicyFunction) override;
void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, FramePolicyFunction) override;
void cancelPolicyCheck() override { }
void dispatchUnableToImplementPolicy(const ResourceError&) override { }
void dispatchWillSendSubmitEvent(PassRefPtr<FormState>) override;
void dispatchWillSubmitForm(PassRefPtr<FormState>, FramePolicyFunction) override;
void revertToProvisionalState(DocumentLoader*) override { }
void setMainDocumentError(DocumentLoader*, const ResourceError&) override { }
void setMainFrameDocumentReady(bool) override { }
void startDownload(const ResourceRequest&, const String& suggestedName = String()) override { UNUSED_PARAM(suggestedName); }
void willChangeTitle(DocumentLoader*) override { }
void didChangeTitle(DocumentLoader*) override { }
void willReplaceMultipartContent() override { }
void didReplaceMultipartContent() override { }
void committedLoad(DocumentLoader*, const char*, int) override { }
void finishedLoading(DocumentLoader*) override { }
ResourceError cancelledError(const ResourceRequest&) override { return ResourceError(ResourceError::Type::Cancellation); }
ResourceError blockedError(const ResourceRequest&) override { return { }; }
ResourceError blockedByContentBlockerError(const ResourceRequest&) override { return { }; }
ResourceError cannotShowURLError(const ResourceRequest&) override { return { }; }
ResourceError interruptedForPolicyChangeError(const ResourceRequest&) override { return { }; }
#if ENABLE(CONTENT_FILTERING)
ResourceError blockedByContentFilterError(const ResourceRequest&) override { return { }; }
#endif
ResourceError cannotShowMIMETypeError(const ResourceResponse&) override { return { }; }
ResourceError fileDoesNotExistError(const ResourceResponse&) override { return { }; }
ResourceError pluginWillHandleLoadError(const ResourceResponse&) override { return { }; }
bool shouldFallBack(const ResourceError&) override { return false; }
bool canHandleRequest(const ResourceRequest&) const override { return false; }
bool canShowMIMEType(const String&) const override { return false; }
bool canShowMIMETypeAsHTML(const String&) const override { return false; }
bool representationExistsForURLScheme(const String&) const override { return false; }
String generatedMIMETypeForURLScheme(const String&) const override { return emptyString(); }
void frameLoadCompleted() override { }
void restoreViewState() override { }
void provisionalLoadStarted() override { }
void didFinishLoad() override { }
void prepareForDataSourceReplacement() override { }
Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) override;
void updateCachedDocumentLoader(DocumentLoader&) override { }
void setTitle(const StringWithDirection&, const URL&) override { }
String userAgent(const URL&) override { return emptyString(); }
void savePlatformDataToCachedFrame(CachedFrame*) override { }
void transitionToCommittedFromCachedFrame(CachedFrame*) override { }
#if PLATFORM(IOS)
void didRestoreFrameHierarchyForCachedFrame() override { }
#endif
void transitionToCommittedForNewPage() override { }
void didSaveToPageCache() override { }
void didRestoreFromPageCache() override { }
void dispatchDidBecomeFrameset(bool) override { }
void updateGlobalHistory() override { }
void updateGlobalHistoryRedirectLinks() override { }
bool shouldGoToHistoryItem(HistoryItem*) const override { return false; }
void updateGlobalHistoryItemForPage() override { }
void saveViewStateToItem(HistoryItem&) override { }
bool canCachePage() const override { return false; }
void didDisplayInsecureContent() override { }
void didRunInsecureContent(SecurityOrigin*, const URL&) override { }
void didDetectXSS(const URL&, bool) override { }
RefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) override;
RefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) override;
void recreatePlugin(Widget*) override;
PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) override;
ObjectContentType objectContentType(const URL&, const String&) override { return ObjectContentType::None; }
String overrideMediaType() const override { return String(); }
void redirectDataToPlugin(Widget*) override { }
void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&) override { }
void registerForIconNotification(bool) override { }
#if PLATFORM(COCOA)
RemoteAXObjectRef accessibilityRemoteObject() override { return nullptr; }
NSCachedURLResponse* willCacheResponse(DocumentLoader*, unsigned long, NSCachedURLResponse* response) const override { return response; }
#endif
#if PLATFORM(WIN) && USE(CFURLCONNECTION)
bool shouldCacheResponse(DocumentLoader*, unsigned long, const ResourceResponse&, const unsigned char*, unsigned long long) override { return true; }
#endif
PassRefPtr<FrameNetworkingContext> createNetworkingContext() override;
#if ENABLE(REQUEST_AUTOCOMPLETE)
void didRequestAutocomplete(PassRefPtr<FormState>) override { }
#endif
bool isEmptyFrameLoaderClient() override { return true; }
void prefetchDNS(const String&) override { }
};
class EmptyTextCheckerClient : public TextCheckerClient {
public:
bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const override { return true; }
void ignoreWordInSpellDocument(const String&) override { }
void learnWord(const String&) override { }
void checkSpellingOfString(StringView, int*, int*) override { }
String getAutoCorrectSuggestionForMisspelledWord(const String&) override { return String(); }
void checkGrammarOfString(StringView, Vector<GrammarDetail>&, int*, int*) override { }
#if USE(UNIFIED_TEXT_CHECKING)
Vector<TextCheckingResult> checkTextOfParagraph(StringView, TextCheckingTypeMask, const VisibleSelection&) override { return Vector<TextCheckingResult>(); }
#endif
void getGuessesForWord(const String&, const String&, const VisibleSelection&, Vector<String>&) override { }
void requestCheckingOfString(PassRefPtr<TextCheckingRequest>, const VisibleSelection&) override;
};
class EmptyEditorClient : public EditorClient {
WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
public:
EmptyEditorClient() { }
virtual ~EmptyEditorClient() { }
bool shouldDeleteRange(Range*) override { return false; }
bool smartInsertDeleteEnabled() override { return false; }
bool isSelectTrailingWhitespaceEnabled() override { return false; }
bool isContinuousSpellCheckingEnabled() override { return false; }
void toggleContinuousSpellChecking() override { }
bool isGrammarCheckingEnabled() override { return false; }
void toggleGrammarChecking() override { }
int spellCheckerDocumentTag() override { return -1; }
bool shouldBeginEditing(Range*) override { return false; }
bool shouldEndEditing(Range*) override { return false; }
bool shouldInsertNode(Node*, Range*, EditorInsertAction) override { return false; }
bool shouldInsertText(const String&, Range*, EditorInsertAction) override { return false; }
bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) override { return false; }
bool shouldApplyStyle(StyleProperties*, Range*) override { return false; }
void didApplyStyle() override { }
bool shouldMoveRangeAfterDelete(Range*, Range*) override { return false; }
void didBeginEditing() override { }
void respondToChangedContents() override { }
void respondToChangedSelection(Frame*) override { }
void didChangeSelectionAndUpdateLayout() override { }
void updateEditorStateAfterLayoutIfEditabilityChanged() override { }
void discardedComposition(Frame*) override { }
void canceledComposition() override { }
void didEndEditing() override { }
void willWriteSelectionToPasteboard(Range*) override { }
void didWriteSelectionToPasteboard() override { }
void getClientPasteboardDataForRange(Range*, Vector<String>&, Vector<RefPtr<SharedBuffer>>&) override { }
void requestCandidatesForSelection(const VisibleSelection&) override { }
void handleAcceptedCandidateWithSoftSpaces(TextCheckingResult) override { }
void registerUndoStep(PassRefPtr<UndoStep>) override;
void registerRedoStep(PassRefPtr<UndoStep>) override;
void clearUndoRedoOperations() override { }
bool canCopyCut(Frame*, bool defaultValue) const override { return defaultValue; }
bool canPaste(Frame*, bool defaultValue) const override { return defaultValue; }
bool canUndo() const override { return false; }
bool canRedo() const override { return false; }
void undo() override { }
void redo() override { }
void handleKeyboardEvent(KeyboardEvent*) override { }
void handleInputMethodKeydown(KeyboardEvent*) override { }
void textFieldDidBeginEditing(Element*) override { }
void textFieldDidEndEditing(Element*) override { }
void textDidChangeInTextField(Element*) override { }
bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) override { return false; }
void textWillBeDeletedInTextField(Element*) override { }
void textDidChangeInTextArea(Element*) override { }
void overflowScrollPositionChanged() override { }
#if PLATFORM(IOS)
void startDelayingAndCoalescingContentChangeNotifications() override { }
void stopDelayingAndCoalescingContentChangeNotifications() override { }
void writeDataToPasteboard(NSDictionary*) override { }
NSArray* supportedPasteboardTypesForCurrentSelection() override { return nullptr; }
NSArray* readDataFromPasteboard(NSString*, int) override { return nullptr; }
bool hasRichlyEditableSelection() override { return false; }
int getPasteboardItemsCount() override { return 0; }
RefPtr<DocumentFragment> documentFragmentFromDelegate(int) override { return nullptr; }
bool performsTwoStepPaste(DocumentFragment*) override { return false; }
int pasteboardChangeCount() override { return 0; }
#endif
#if PLATFORM(COCOA)
NSString *userVisibleString(NSURL *) override { return nullptr; }
void setInsertionPasteboard(const String&) override { };
NSURL *canonicalizeURL(NSURL *) override { return nullptr; }
NSURL *canonicalizeURLString(NSString *) override { return nullptr; }
#endif
#if USE(APPKIT)
void uppercaseWord() override { }
void lowercaseWord() override { }
void capitalizeWord() override { }
#endif
#if USE(AUTOMATIC_TEXT_REPLACEMENT)
void showSubstitutionsPanel(bool) override { }
bool substitutionsPanelIsShowing() override { return false; }
void toggleSmartInsertDelete() override { }
bool isAutomaticQuoteSubstitutionEnabled() override { return false; }
void toggleAutomaticQuoteSubstitution() override { }
bool isAutomaticLinkDetectionEnabled() override { return false; }
void toggleAutomaticLinkDetection() override { }
bool isAutomaticDashSubstitutionEnabled() override { return false; }
void toggleAutomaticDashSubstitution() override { }
bool isAutomaticTextReplacementEnabled() override { return false; }
void toggleAutomaticTextReplacement() override { }
bool isAutomaticSpellingCorrectionEnabled() override { return false; }
void toggleAutomaticSpellingCorrection() override { }
#endif
#if PLATFORM(GTK)
bool shouldShowUnicodeMenu() override { return false; }
#endif
TextCheckerClient* textChecker() override { return &m_textCheckerClient; }
void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) override { }
void updateSpellingUIWithMisspelledWord(const String&) override { }
void showSpellingUI(bool) override { }
bool spellingUIIsShowing() override { return false; }
void willSetInputMethodState() override { }
void setInputMethodState(bool) override { }
private:
EmptyTextCheckerClient m_textCheckerClient;
};
#if ENABLE(CONTEXT_MENUS)
class EmptyContextMenuClient : public ContextMenuClient {
WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
public:
EmptyContextMenuClient() { }
virtual ~EmptyContextMenuClient() { }
void contextMenuDestroyed() override { }
void downloadURL(const URL&) override { }
void searchWithGoogle(const Frame*) override { }
void lookUpInDictionary(Frame*) override { }
bool isSpeaking() override { return false; }
void speak(const String&) override { }
void stopSpeaking() override { }
#if PLATFORM(COCOA)
void searchWithSpotlight() override { }
#endif
#if USE(ACCESSIBILITY_CONTEXT_MENUS)
void showContextMenu() override { }
#endif
};
#endif // ENABLE(CONTEXT_MENUS)
#if ENABLE(DRAG_SUPPORT)
class EmptyDragClient : public DragClient {
WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
public:
EmptyDragClient() { }
virtual ~EmptyDragClient() {}
void willPerformDragDestinationAction(DragDestinationAction, const DragData&) override { }
void willPerformDragSourceAction(DragSourceAction, const IntPoint&, DataTransfer&) override { }
DragDestinationAction actionMaskForDrag(const DragData&) override { return DragDestinationActionNone; }
DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) override { return DragSourceActionNone; }
void startDrag(DragImageRef, const IntPoint&, const IntPoint&, DataTransfer&, Frame&, bool) override { }
void dragControllerDestroyed() override { }
};
#endif // ENABLE(DRAG_SUPPORT)
class EmptyInspectorClient : public InspectorClient {
WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
public:
EmptyInspectorClient() { }
virtual ~EmptyInspectorClient() { }
void inspectedPageDestroyed() override { }
Inspector::FrontendChannel* openLocalFrontend(InspectorController*) override { return nullptr; }
void bringFrontendToFront() override { }
void highlight() override { }
void hideHighlight() override { }
};
class EmptyDeviceClient : public DeviceClient {
public:
void startUpdating() override { }
void stopUpdating() override { }
};
class EmptyDeviceMotionClient : public DeviceMotionClient {
public:
void setController(DeviceMotionController*) override { }
DeviceMotionData* lastMotion() const override { return nullptr; }
void deviceMotionControllerDestroyed() override { }
};
class EmptyDeviceOrientationClient : public DeviceOrientationClient {
public:
void setController(DeviceOrientationController*) override { }
DeviceOrientationData* lastOrientation() const override { return nullptr; }
void deviceOrientationControllerDestroyed() override { }
};
class EmptyProgressTrackerClient : public ProgressTrackerClient {
void willChangeEstimatedProgress() override { }
void didChangeEstimatedProgress() override { }
void progressStarted(Frame&) override { }
void progressEstimateChanged(Frame&) override { }
void progressFinished(Frame&) override { }
};
class EmptyDiagnosticLoggingClient final : public DiagnosticLoggingClient {
void logDiagnosticMessage(const String&, const String&, ShouldSample) override { }
void logDiagnosticMessageWithResult(const String&, const String&, DiagnosticLoggingResultType, ShouldSample) override { }
void logDiagnosticMessageWithValue(const String&, const String&, const String&, ShouldSample) override { }
};
void fillWithEmptyClients(PageConfiguration&);
}