Home | History | Annotate | Download | only in loader 
      1 /*
      2  * Copyright (C) 2006 Eric Seidel (eric (at) webkit.org)
      3  * Copyright (C) 2008, 2009, 2010, 2011, 2012 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 COMPUTER, 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 COMPUTER, 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 "core/dom/DeviceOrientationClient.h"
     33 #include "core/history/BackForwardClient.h"
     34 #include "core/inspector/InspectorClient.h"
     35 #include "core/loader/FrameLoaderClient.h"
     36 #include "core/page/ChromeClient.h"
     37 #include "core/page/ContextMenuClient.h"
     38 #include "core/page/DragClient.h"
     39 #include "core/page/EditorClient.h"
     40 #include "core/page/FocusDirection.h"
     41 #include "core/page/Page.h"
     42 #include "core/platform/DragImage.h"
     43 #include "core/platform/graphics/FloatRect.h"
     44 #include "core/platform/network/ResourceError.h"
     45 #include "core/platform/text/TextCheckerClient.h"
     46 #include "public/platform/WebScreenInfo.h"
     47 #include "wtf/Forward.h"
     48 
     49 #include <v8.h>
     50 
     51 /*
     52  This file holds empty Client stubs for use by WebCore.
     53  Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.
     54  This tree depends heavily on Clients (usually provided by WebKit classes).
     55 
     56  This file was first created for SVGImage as it had no way to access the current Page (nor should it,
     57  since Images are not tied to a page).
     58  See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
     59 
     60  Ideally, whenever you change a Client class, you should add a stub here.
     61  Brittle, yes.  Unfortunate, yes.  Hopefully temporary.
     62 */
     63 
     64 namespace WebCore {
     65 
     66 class GraphicsContext3D;
     67 
     68 class EmptyChromeClient : public ChromeClient {
     69     WTF_MAKE_FAST_ALLOCATED;
     70 public:
     71     virtual ~EmptyChromeClient() { }
     72     virtual void chromeDestroyed() OVERRIDE { }
     73 
     74     virtual void* webView() const OVERRIDE { return 0; }
     75     virtual void setWindowRect(const FloatRect&) OVERRIDE { }
     76     virtual FloatRect windowRect() OVERRIDE { return FloatRect(); }
     77 
     78     virtual FloatRect pageRect() OVERRIDE { return FloatRect(); }
     79 
     80     virtual void focus() OVERRIDE { }
     81     virtual void unfocus() OVERRIDE { }
     82 
     83     virtual bool canTakeFocus(FocusDirection) OVERRIDE { return false; }
     84     virtual void takeFocus(FocusDirection) OVERRIDE { }
     85 
     86     virtual void focusedNodeChanged(Node*) OVERRIDE { }
     87     virtual Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&, NavigationPolicy) OVERRIDE { return 0; }
     88     virtual void show(NavigationPolicy) OVERRIDE { }
     89 
     90     virtual bool canRunModal() OVERRIDE { return false; }
     91     virtual void runModal() OVERRIDE { }
     92 
     93     virtual void setToolbarsVisible(bool) OVERRIDE { }
     94     virtual bool toolbarsVisible() OVERRIDE { return false; }
     95 
     96     virtual void setStatusbarVisible(bool) OVERRIDE { }
     97     virtual bool statusbarVisible() OVERRIDE { return false; }
     98 
     99     virtual void setScrollbarsVisible(bool) OVERRIDE { }
    100     virtual bool scrollbarsVisible() OVERRIDE { return false; }
    101 
    102     virtual void setMenubarVisible(bool) OVERRIDE { }
    103     virtual bool menubarVisible() OVERRIDE { return false; }
    104 
    105     virtual void setResizable(bool) OVERRIDE { }
    106 
    107     virtual void addMessageToConsole(MessageSource, MessageLevel, const String&, unsigned, const String&) OVERRIDE { }
    108 
    109     virtual bool canRunBeforeUnloadConfirmPanel() OVERRIDE { return false; }
    110     virtual bool runBeforeUnloadConfirmPanel(const String&, Frame*) OVERRIDE { return true; }
    111 
    112     virtual void closeWindowSoon() OVERRIDE { }
    113 
    114     virtual void runJavaScriptAlert(Frame*, const String&) OVERRIDE { }
    115     virtual bool runJavaScriptConfirm(Frame*, const String&) OVERRIDE { return false; }
    116     virtual bool runJavaScriptPrompt(Frame*, const String&, const String&, String&) OVERRIDE { return false; }
    117 
    118     virtual bool hasOpenedPopup() const OVERRIDE { return false; }
    119     virtual PassRefPtr<PopupMenu> createPopupMenu(Frame&, PopupMenuClient*) const OVERRIDE;
    120     virtual PagePopup* openPagePopup(PagePopupClient*, const IntRect&) OVERRIDE { return 0; }
    121     virtual void closePagePopup(PagePopup*) OVERRIDE { }
    122     virtual void setPagePopupDriver(PagePopupDriver*) OVERRIDE { }
    123     virtual void resetPagePopupDriver() OVERRIDE { }
    124 
    125     virtual void setStatusbarText(const String&) OVERRIDE { }
    126 
    127     virtual bool tabsToLinks() OVERRIDE { return false; }
    128 
    129     virtual IntRect windowResizerRect() const OVERRIDE { return IntRect(); }
    130 
    131     virtual void invalidateContentsAndRootView(const IntRect&) OVERRIDE { }
    132     virtual void invalidateContentsForSlowScroll(const IntRect&) OVERRIDE { }
    133     virtual void scroll(const IntSize&, const IntRect&, const IntRect&) OVERRIDE { }
    134     virtual void scheduleAnimation() OVERRIDE { }
    135 
    136     virtual IntPoint screenToRootView(const IntPoint& p) const OVERRIDE { return p; }
    137     virtual IntRect rootViewToScreen(const IntRect& r) const OVERRIDE { return r; }
    138     virtual WebKit::WebScreenInfo screenInfo() const OVERRIDE { return WebKit::WebScreenInfo(); }
    139     virtual void contentsSizeChanged(Frame*, const IntSize&) const OVERRIDE { }
    140 
    141     virtual void mouseDidMoveOverElement(const HitTestResult&, unsigned) OVERRIDE { }
    142 
    143     virtual void setToolTip(const String&, TextDirection) OVERRIDE { }
    144 
    145     virtual void print(Frame*) OVERRIDE { }
    146 
    147     virtual void enumerateChosenDirectory(FileChooser*) OVERRIDE { }
    148 
    149     virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) OVERRIDE;
    150 
    151     virtual PassRefPtr<DateTimeChooser> openDateTimeChooser(DateTimeChooserClient*, const DateTimeChooserParameters&) OVERRIDE;
    152 
    153     virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) OVERRIDE;
    154 
    155     virtual void formStateDidChange(const Node*) OVERRIDE { }
    156 
    157     virtual void setCursor(const Cursor&) OVERRIDE { }
    158 
    159     virtual void attachRootGraphicsLayer(Frame*, GraphicsLayer*) OVERRIDE { }
    160     virtual void scheduleCompositingLayerFlush() OVERRIDE { }
    161 
    162     virtual void needTouchEvents(bool) OVERRIDE { }
    163 
    164     virtual void numWheelEventHandlersChanged(unsigned) OVERRIDE { }
    165 
    166     virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const OVERRIDE { return false; }
    167 
    168     virtual bool isEmptyChromeClient() const OVERRIDE { return true; }
    169 
    170     virtual void didAssociateFormControls(const Vector<RefPtr<Element> >&) OVERRIDE { }
    171 
    172     virtual void popupOpened(PopupContainer* popupContainer, const IntRect& bounds,
    173                              bool handleExternal) { }
    174     virtual void popupClosed(PopupContainer* popupContainer) OVERRIDE { }
    175 
    176     virtual void annotatedRegionsChanged() OVERRIDE { }
    177     virtual bool paintCustomOverhangArea(GraphicsContext*, const IntRect&, const IntRect&, const IntRect&) OVERRIDE { return false; }
    178     virtual String acceptLanguages() OVERRIDE;
    179 };
    180 
    181 class EmptyFrameLoaderClient : public FrameLoaderClient {
    182     WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
    183 public:
    184     EmptyFrameLoaderClient() { }
    185     virtual ~EmptyFrameLoaderClient() {  }
    186     virtual void frameLoaderDestroyed() OVERRIDE { }
    187 
    188     virtual bool hasWebView() const OVERRIDE { return true; } // mainly for assertions
    189 
    190     virtual void detachedFromParent() OVERRIDE { }
    191 
    192     virtual void dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) OVERRIDE { }
    193     virtual void dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse&) OVERRIDE { }
    194     virtual void dispatchDidFinishLoading(DocumentLoader*, unsigned long) OVERRIDE { }
    195     virtual void dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) OVERRIDE { }
    196 
    197     virtual void dispatchDidHandleOnloadEvents() OVERRIDE { }
    198     virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() OVERRIDE { }
    199     virtual void dispatchWillClose() OVERRIDE { }
    200     virtual void dispatchDidStartProvisionalLoad() OVERRIDE { }
    201     virtual void dispatchDidReceiveTitle(const StringWithDirection&) OVERRIDE { }
    202     virtual void dispatchDidChangeIcons(IconType) OVERRIDE { }
    203     virtual void dispatchDidCommitLoad() OVERRIDE { }
    204     virtual void dispatchDidFailProvisionalLoad(const ResourceError&) OVERRIDE { }
    205     virtual void dispatchDidFailLoad(const ResourceError&) OVERRIDE { }
    206     virtual void dispatchDidFinishDocumentLoad() OVERRIDE { }
    207     virtual void dispatchDidFinishLoad() OVERRIDE { }
    208     virtual void dispatchDidLayout(LayoutMilestones) OVERRIDE { }
    209 
    210     virtual NavigationPolicy decidePolicyForNavigation(const ResourceRequest&, DocumentLoader*, NavigationPolicy) OVERRIDE;
    211     virtual bool shouldAbortNavigationAfterUrlResolve(const KURL&, const String&, const KURL&) OVERRIDE;
    212 
    213     virtual void dispatchWillSendSubmitEvent(PassRefPtr<FormState>) OVERRIDE;
    214     virtual void dispatchWillSubmitForm(PassRefPtr<FormState>) OVERRIDE;
    215 
    216     virtual void postProgressStartedNotification() OVERRIDE { }
    217     virtual void postProgressEstimateChangedNotification() OVERRIDE { }
    218     virtual void postProgressFinishedNotification() OVERRIDE { }
    219 
    220     virtual void loadURLExternally(const ResourceRequest&, NavigationPolicy, const String& = String()) OVERRIDE { }
    221 
    222     virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) OVERRIDE { return ResourceError("", 0, "", ""); }
    223 
    224     virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) OVERRIDE;
    225 
    226     virtual String userAgent(const KURL&) OVERRIDE { return ""; }
    227 
    228     virtual String doNotTrackValue() OVERRIDE { return String(); }
    229 
    230     virtual void transitionToCommittedForNewPage() OVERRIDE { }
    231 
    232     virtual bool shouldGoToHistoryItem(HistoryItem*) const OVERRIDE { return false; }
    233     virtual bool shouldStopLoadingForHistoryItem(HistoryItem*) const OVERRIDE { return false; }
    234     virtual void didDisplayInsecureContent() OVERRIDE { }
    235     virtual void didRunInsecureContent(SecurityOrigin*, const KURL&) OVERRIDE { }
    236     virtual void didDetectXSS(const KURL&, bool) OVERRIDE { }
    237     virtual void didDispatchPingLoader(const KURL&) OVERRIDE { }
    238     virtual PassRefPtr<Frame> createFrame(const KURL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) OVERRIDE;
    239     virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool) OVERRIDE;
    240     virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL&, const Vector<String>&, const Vector<String>&) OVERRIDE;
    241 
    242     virtual ObjectContentType objectContentType(const KURL&, const String&, bool) OVERRIDE { return ObjectContentType(); }
    243 
    244     virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*) OVERRIDE { }
    245     virtual void documentElementAvailable() OVERRIDE { }
    246 
    247     virtual void didCreateScriptContext(v8::Handle<v8::Context>, int extensionGroup, int worldId) OVERRIDE { }
    248     virtual void willReleaseScriptContext(v8::Handle<v8::Context>, int worldId) OVERRIDE { }
    249     virtual bool allowScriptExtension(const String& extensionName, int extensionGroup, int worldId) OVERRIDE { return false; }
    250 
    251     virtual WebKit::WebCookieJar* cookieJar() const { return 0; }
    252 
    253     virtual void didRequestAutocomplete(PassRefPtr<FormState>) OVERRIDE;
    254 };
    255 
    256 class EmptyTextCheckerClient : public TextCheckerClient {
    257 public:
    258     virtual bool shouldEraseMarkersAfterChangeSelection(TextCheckingType) const OVERRIDE { return true; }
    259     virtual void checkSpellingOfString(const String&, int*, int*) OVERRIDE { }
    260     virtual String getAutoCorrectSuggestionForMisspelledWord(const String&) OVERRIDE { return String(); }
    261     virtual void checkGrammarOfString(const String&, Vector<GrammarDetail>&, int*, int*) OVERRIDE { }
    262     virtual void requestCheckingOfString(PassRefPtr<TextCheckingRequest>) OVERRIDE;
    263 };
    264 
    265 class EmptyEditorClient : public EditorClient {
    266     WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
    267 public:
    268     EmptyEditorClient() { }
    269     virtual ~EmptyEditorClient() { }
    270 
    271     virtual bool shouldDeleteRange(Range*) OVERRIDE { return false; }
    272     virtual bool smartInsertDeleteEnabled() OVERRIDE { return false; }
    273     virtual bool isSelectTrailingWhitespaceEnabled() OVERRIDE { return false; }
    274     virtual bool isContinuousSpellCheckingEnabled() OVERRIDE { return false; }
    275     virtual void toggleContinuousSpellChecking() OVERRIDE { }
    276     virtual bool isGrammarCheckingEnabled() OVERRIDE { return false; }
    277 
    278     virtual bool shouldBeginEditing(Range*) OVERRIDE { return false; }
    279     virtual bool shouldEndEditing(Range*) OVERRIDE { return false; }
    280     virtual bool shouldInsertNode(Node*, Range*, EditorInsertAction) OVERRIDE { return false; }
    281     virtual bool shouldInsertText(const String&, Range*, EditorInsertAction) OVERRIDE { return false; }
    282     virtual bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) OVERRIDE { return false; }
    283 
    284     virtual bool shouldApplyStyle(StylePropertySet*, Range*) OVERRIDE { return false; }
    285 
    286     virtual void didBeginEditing() OVERRIDE { }
    287     virtual void respondToChangedContents() OVERRIDE { }
    288     virtual void respondToChangedSelection(Frame*) OVERRIDE { }
    289     virtual void didEndEditing() OVERRIDE { }
    290     virtual void didCancelCompositionOnSelectionChange() OVERRIDE { }
    291 
    292     virtual void registerUndoStep(PassRefPtr<UndoStep>) OVERRIDE;
    293     virtual void registerRedoStep(PassRefPtr<UndoStep>) OVERRIDE;
    294     virtual void clearUndoRedoOperations() OVERRIDE { }
    295 
    296     virtual bool canCopyCut(Frame*, bool defaultValue) const OVERRIDE { return defaultValue; }
    297     virtual bool canPaste(Frame*, bool defaultValue) const OVERRIDE { return defaultValue; }
    298     virtual bool canUndo() const OVERRIDE { return false; }
    299     virtual bool canRedo() const OVERRIDE { return false; }
    300 
    301     virtual void undo() OVERRIDE { }
    302     virtual void redo() OVERRIDE { }
    303 
    304     virtual void handleKeyboardEvent(KeyboardEvent*) OVERRIDE { }
    305 
    306     virtual void textFieldDidEndEditing(Element*) OVERRIDE { }
    307     virtual void textDidChangeInTextField(Element*) OVERRIDE { }
    308     virtual bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) OVERRIDE { return false; }
    309 
    310     TextCheckerClient* textChecker() { return &m_textCheckerClient; }
    311 
    312     virtual void updateSpellingUIWithMisspelledWord(const String&) OVERRIDE { }
    313     virtual void showSpellingUI(bool) OVERRIDE { }
    314     virtual bool spellingUIIsShowing() OVERRIDE { return false; }
    315 
    316     virtual void willSetInputMethodState() OVERRIDE { }
    317 
    318 private:
    319     EmptyTextCheckerClient m_textCheckerClient;
    320 };
    321 
    322 class EmptyContextMenuClient : public ContextMenuClient {
    323     WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
    324 public:
    325     EmptyContextMenuClient() { }
    326     virtual ~EmptyContextMenuClient() {  }
    327     virtual void showContextMenu(const ContextMenu*) OVERRIDE { }
    328 };
    329 
    330 class EmptyDragClient : public DragClient {
    331     WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
    332 public:
    333     EmptyDragClient() { }
    334     virtual ~EmptyDragClient() {}
    335     virtual DragDestinationAction actionMaskForDrag(DragData*) OVERRIDE { return DragDestinationActionNone; }
    336     virtual void startDrag(DragImage*, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool) OVERRIDE { }
    337 };
    338 
    339 class EmptyInspectorClient : public InspectorClient {
    340     WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
    341 public:
    342     EmptyInspectorClient() { }
    343     virtual ~EmptyInspectorClient() { }
    344 
    345     virtual void highlight() OVERRIDE { }
    346     virtual void hideHighlight() OVERRIDE { }
    347 };
    348 
    349 class EmptyDeviceClient : public DeviceClient {
    350 public:
    351     virtual void startUpdating() OVERRIDE { }
    352     virtual void stopUpdating() OVERRIDE { }
    353 };
    354 
    355 class EmptyDeviceOrientationClient : public DeviceOrientationClient {
    356 public:
    357     virtual void setController(DeviceOrientationController*) OVERRIDE { }
    358     virtual DeviceOrientationData* lastOrientation() const OVERRIDE { return 0; }
    359     virtual void deviceOrientationControllerDestroyed() OVERRIDE { }
    360 };
    361 
    362 class EmptyBackForwardClient : public BackForwardClient {
    363 public:
    364     virtual void addItem(PassRefPtr<HistoryItem>) OVERRIDE { }
    365     virtual void goToItem(HistoryItem*) OVERRIDE { }
    366     virtual HistoryItem* itemAtIndex(int) OVERRIDE { return 0; }
    367     virtual int backListCount() OVERRIDE { return 0; }
    368     virtual int forwardListCount() OVERRIDE { return 0; }
    369     virtual bool isActive() OVERRIDE { return false; }
    370     virtual void close() OVERRIDE { }
    371 };
    372 
    373 void fillWithEmptyClients(Page::PageClients&);
    374 
    375 }
    376 
    377 #endif // EmptyClients_h
    378