← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebKit/chromium/src/FrameLoaderClientImpl.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebKit/chromium/src/FrameLoaderClientImpl.h
 
1
/*
 
2
 * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
 
3
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions are
 
7
 * met:
 
8
 *
 
9
 *     * Redistributions of source code must retain the above copyright
 
10
 * notice, this list of conditions and the following disclaimer.
 
11
 *     * Redistributions in binary form must reproduce the above
 
12
 * copyright notice, this list of conditions and the following disclaimer
 
13
 * in the documentation and/or other materials provided with the
 
14
 * distribution.
 
15
 *     * Neither the name of Google Inc. nor the names of its
 
16
 * contributors may be used to endorse or promote products derived from
 
17
 * this software without specific prior written permission.
 
18
 *
 
19
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
20
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
21
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
22
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
23
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
24
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
25
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
26
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
27
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
28
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
29
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
30
 */
 
31
 
 
32
#ifndef FrameLoaderClientImpl_h
 
33
#define FrameLoaderClientImpl_h
 
34
 
 
35
#include "FrameLoaderClient.h"
 
36
#include "KURL.h"
 
37
#include "WebNavigationPolicy.h"
 
38
#include <wtf/PassOwnPtr.h>
 
39
#include <wtf/RefPtr.h>
 
40
 
 
41
namespace WebKit {
 
42
 
 
43
class WebFrameImpl;
 
44
class WebPluginContainerImpl;
 
45
class WebPluginLoadObserver;
 
46
 
 
47
class FrameLoaderClientImpl : public WebCore::FrameLoaderClient {
 
48
public:
 
49
    FrameLoaderClientImpl(WebFrameImpl* webFrame);
 
50
    ~FrameLoaderClientImpl();
 
51
 
 
52
    WebFrameImpl* webFrame() const { return m_webFrame; }
 
53
 
 
54
    // WebCore::FrameLoaderClient ----------------------------------------------
 
55
 
 
56
    virtual void frameLoaderDestroyed();
 
57
 
 
58
    // Notifies the WebView delegate that the JS window object has been cleared,
 
59
    // giving it a chance to bind native objects to the window before script
 
60
    // parsing begins.
 
61
    virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*);
 
62
    virtual void documentElementAvailable();
 
63
 
 
64
    // Script in the page tried to allocate too much memory.
 
65
    virtual void didExhaustMemoryAvailableForScript();
 
66
 
 
67
#if USE(V8)
 
68
    virtual void didCreateScriptContext(v8::Handle<v8::Context>, int extensionGroup, int worldId);
 
69
    virtual void willReleaseScriptContext(v8::Handle<v8::Context>, int worldId);
 
70
#endif
 
71
 
 
72
    // Returns true if we should allow the given V8 extension to be added to
 
73
    // the script context at the currently loading page and given extension group.
 
74
    virtual bool allowScriptExtension(const String& extensionName, int extensionGroup, int worldId);
 
75
 
 
76
    virtual bool hasWebView() const;
 
77
    virtual bool hasFrameView() const;
 
78
    virtual void makeRepresentation(WebCore::DocumentLoader*) { }
 
79
    virtual void forceLayout();
 
80
    virtual void forceLayoutForNonHTML();
 
81
    virtual void setCopiesOnScroll();
 
82
    virtual void detachedFromParent2();
 
83
    virtual void detachedFromParent3();
 
84
    virtual void assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&);
 
85
    virtual void dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long identifier, WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse);
 
86
    virtual bool shouldUseCredentialStorage(WebCore::DocumentLoader*, unsigned long identifier);
 
87
    virtual void dispatchDidReceiveAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::AuthenticationChallenge&);
 
88
    virtual void dispatchDidCancelAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::AuthenticationChallenge&);
 
89
    virtual void dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::ResourceResponse&);
 
90
    virtual void dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long identifier, int dataLength);
 
91
    virtual void dispatchDidFinishLoading(WebCore::DocumentLoader*, unsigned long identifier);
 
92
    virtual void dispatchDidFailLoading(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::ResourceError&);
 
93
    virtual bool dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int length);
 
94
    virtual void dispatchDidHandleOnloadEvents();
 
95
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
 
96
    virtual void dispatchDidCancelClientRedirect();
 
97
    virtual void dispatchWillPerformClientRedirect(const WebCore::KURL&, double interval, double fireDate);
 
98
    virtual void dispatchDidNavigateWithinPage();
 
99
    virtual void dispatchDidChangeLocationWithinPage();
 
100
    virtual void dispatchDidPushStateWithinPage();
 
101
    virtual void dispatchDidReplaceStateWithinPage();
 
102
    virtual void dispatchDidPopStateWithinPage();
 
103
    virtual void dispatchWillClose();
 
104
    virtual void dispatchDidReceiveIcon();
 
105
    virtual void dispatchDidStartProvisionalLoad();
 
106
    virtual void dispatchDidReceiveTitle(const WebCore::StringWithDirection&);
 
107
    virtual void dispatchDidChangeIcons(WebCore::IconType);
 
108
    virtual void dispatchDidCommitLoad();
 
109
    virtual void dispatchDidFailProvisionalLoad(const WebCore::ResourceError&);
 
110
    virtual void dispatchDidFailLoad(const WebCore::ResourceError&);
 
111
    virtual void dispatchDidFinishDocumentLoad();
 
112
    virtual void dispatchDidFinishLoad();
 
113
    virtual void dispatchDidLayout(WebCore::LayoutMilestones);
 
114
    virtual WebCore::Frame* dispatchCreatePage(const WebCore::NavigationAction&);
 
115
    virtual void dispatchShow();
 
116
    virtual void dispatchDecidePolicyForResponse(WebCore::FramePolicyFunction function, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&);
 
117
    virtual void dispatchDecidePolicyForNewWindowAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request, PassRefPtr<WebCore::FormState> form_state, const WTF::String& frame_name);
 
118
    virtual void dispatchDecidePolicyForNavigationAction(WebCore::FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request, PassRefPtr<WebCore::FormState> form_state);
 
119
    virtual void cancelPolicyCheck();
 
120
    virtual void dispatchUnableToImplementPolicy(const WebCore::ResourceError&);
 
121
    virtual void dispatchWillRequestResource(WebCore::CachedResourceRequest*);
 
122
    virtual void dispatchWillSendSubmitEvent(PassRefPtr<WebCore::FormState>);
 
123
    virtual void dispatchWillSubmitForm(WebCore::FramePolicyFunction, PassRefPtr<WebCore::FormState>);
 
124
    virtual void revertToProvisionalState(WebCore::DocumentLoader*) { }
 
125
    virtual void setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&);
 
126
    virtual void willChangeEstimatedProgress() { }
 
127
    virtual void didChangeEstimatedProgress() { }
 
128
    virtual void postProgressStartedNotification();
 
129
    virtual void postProgressEstimateChangedNotification();
 
130
    virtual void postProgressFinishedNotification();
 
131
    virtual void setMainFrameDocumentReady(bool);
 
132
    virtual void startDownload(const WebCore::ResourceRequest&, const String& suggestedName = String());
 
133
    virtual void willChangeTitle(WebCore::DocumentLoader*);
 
134
    virtual void didChangeTitle(WebCore::DocumentLoader*);
 
135
    virtual void committedLoad(WebCore::DocumentLoader*, const char*, int);
 
136
    virtual void finishedLoading(WebCore::DocumentLoader*);
 
137
    virtual void updateGlobalHistory();
 
138
    virtual void updateGlobalHistoryRedirectLinks();
 
139
    virtual bool shouldGoToHistoryItem(WebCore::HistoryItem*) const;
 
140
    virtual bool shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const;
 
141
    virtual void didDisplayInsecureContent();
 
142
    virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::KURL& insecureURL);
 
143
    virtual void didDetectXSS(const WebCore::KURL&, bool didBlockEntirePage);
 
144
    virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&);
 
145
    virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&);
 
146
    virtual WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&);
 
147
    virtual WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&);
 
148
    virtual WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&);
 
149
    virtual WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&);
 
150
    virtual WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&);
 
151
    virtual bool shouldFallBack(const WebCore::ResourceError&);
 
152
    virtual bool canHandleRequest(const WebCore::ResourceRequest&) const;
 
153
    virtual bool canShowMIMEType(const WTF::String& MIMEType) const;
 
154
    virtual bool canShowMIMETypeAsHTML(const String& MIMEType) const;
 
155
    virtual bool representationExistsForURLScheme(const WTF::String& URLScheme) const;
 
156
    virtual WTF::String generatedMIMETypeForURLScheme(const WTF::String& URLScheme) const;
 
157
    virtual void frameLoadCompleted();
 
158
    virtual void saveViewStateToItem(WebCore::HistoryItem*);
 
159
    virtual void restoreViewState();
 
160
    virtual void provisionalLoadStarted();
 
161
    virtual void didFinishLoad();
 
162
    virtual void prepareForDataSourceReplacement();
 
163
    virtual PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(
 
164
        const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
 
165
    virtual void setTitle(const WebCore::StringWithDirection&, const WebCore::KURL&);
 
166
    virtual WTF::String userAgent(const WebCore::KURL&);
 
167
    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*);
 
168
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*);
 
169
    virtual void transitionToCommittedForNewPage();
 
170
    virtual void didSaveToPageCache();
 
171
    virtual void didRestoreFromPageCache();
 
172
    virtual void dispatchDidBecomeFrameset(bool);
 
173
    virtual bool canCachePage() const;
 
174
    virtual void download(
 
175
        WebCore::ResourceHandle*, const WebCore::ResourceRequest&,
 
176
        const WebCore::ResourceResponse&);
 
177
    virtual PassRefPtr<WebCore::Frame> createFrame(
 
178
        const WebCore::KURL& url, const WTF::String& name,
 
179
        WebCore::HTMLFrameOwnerElement* ownerElement,
 
180
        const WTF::String& referrer, bool allowsScrolling,
 
181
        int marginWidth, int marginHeight);
 
182
    virtual PassRefPtr<WebCore::Widget> createPlugin(
 
183
        const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::KURL&,
 
184
        const Vector<WTF::String>&, const Vector<WTF::String>&,
 
185
        const WTF::String&, bool loadManually);
 
186
    virtual void recreatePlugin(WebCore::Widget*) { }
 
187
    virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget);
 
188
    virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(
 
189
        const WebCore::IntSize&,
 
190
        WebCore::HTMLAppletElement*,
 
191
        const WebCore::KURL& /* base_url */,
 
192
        const Vector<WTF::String>& paramNames,
 
193
        const Vector<WTF::String>& paramValues);
 
194
    virtual WebCore::ObjectContentType objectContentType(
 
195
        const WebCore::KURL&, const WTF::String& mimeType, bool shouldPreferPlugInsForImages);
 
196
    virtual WTF::String overrideMediaType() const;
 
197
    virtual void didPerformFirstNavigation() const;
 
198
    virtual void registerForIconNotification(bool listen = true);
 
199
    virtual void didChangeScrollOffset();
 
200
    virtual bool allowScript(bool enabledPerSettings);
 
201
    virtual bool allowScriptFromSource(bool enabledPerSettings, const WebCore::KURL& scriptURL);
 
202
    virtual bool allowPlugins(bool enabledPerSettings);
 
203
    virtual bool allowImage(bool enabledPerSettings, const WebCore::KURL& imageURL);
 
204
    virtual bool allowDisplayingInsecureContent(bool enabledPerSettings, WebCore::SecurityOrigin*, const WebCore::KURL&);
 
205
    virtual bool allowRunningInsecureContent(bool enabledPerSettings, WebCore::SecurityOrigin*, const WebCore::KURL&);
 
206
    virtual void didNotAllowScript();
 
207
    virtual void didNotAllowPlugins();
 
208
 
 
209
    virtual PassRefPtr<WebCore::FrameNetworkingContext> createNetworkingContext();
 
210
    virtual bool willCheckAndDispatchMessageEvent(WebCore::SecurityOrigin* target, WebCore::MessageEvent*) const;
 
211
 
 
212
#if ENABLE(WEB_INTENTS_TAG)
 
213
    virtual void registerIntentService(const String& action,
 
214
                                       const String& type,
 
215
                                       const WebCore::KURL& href,
 
216
                                       const String& title,
 
217
                                       const String& disposition);
 
218
#endif
 
219
#if ENABLE(WEB_INTENTS)
 
220
    virtual void dispatchIntent(PassRefPtr<WebCore::IntentRequest>) OVERRIDE;
 
221
#endif
 
222
 
 
223
    virtual void dispatchWillOpenSocketStream(WebCore::SocketStreamHandle*) OVERRIDE;
 
224
 
 
225
#if ENABLE(MEDIA_STREAM)
 
226
    virtual void dispatchWillStartUsingPeerConnectionHandler(WebCore::RTCPeerConnectionHandler*) OVERRIDE;
 
227
#endif
 
228
 
 
229
#if ENABLE(REQUEST_AUTOCOMPLETE)
 
230
    virtual void didRequestAutocomplete(PassRefPtr<WebCore::FormState>) OVERRIDE;
 
231
#endif
 
232
 
 
233
#if ENABLE(WEBGL)
 
234
    virtual bool allowWebGL(bool enabledPerSettings) OVERRIDE;
 
235
    virtual void didLoseWebGLContext(int arbRobustnessContextLostReason) OVERRIDE;
 
236
#endif
 
237
 
 
238
private:
 
239
    void makeDocumentView();
 
240
 
 
241
    // Given a NavigationAction, determine the associated WebNavigationPolicy.
 
242
    // For example, a middle click means "open in background tab".
 
243
    static bool actionSpecifiesNavigationPolicy(
 
244
        const WebCore::NavigationAction& action, WebNavigationPolicy* policy);
 
245
 
 
246
    PassOwnPtr<WebPluginLoadObserver> pluginLoadObserver();
 
247
 
 
248
    // The WebFrame that owns this object and manages its lifetime. Therefore,
 
249
    // the web frame object is guaranteed to exist.
 
250
    WebFrameImpl* m_webFrame;
 
251
 
 
252
    // Used to help track client redirects. When a provisional load starts, it
 
253
    // has no redirects in its chain. But in the case of client redirects, we want
 
254
    // to add that initial load as a redirect. When we get a new provisional load
 
255
    // and the dest URL matches that load, we know that it was the result of a
 
256
    // previous client redirect and the source should be added as a redirect.
 
257
    // Both should be empty if unused.
 
258
    WebCore::KURL m_expectedClientRedirectSrc;
 
259
    WebCore::KURL m_expectedClientRedirectDest;
 
260
 
 
261
    // Contains a pointer to the plugin widget.
 
262
    RefPtr<WebPluginContainerImpl> m_pluginWidget;
 
263
 
 
264
    // Indicates if we need to send over the initial notification to the plugin
 
265
    // which specifies that the plugin should be ready to accept data.
 
266
    bool m_sentInitialResponseToPlugin;
 
267
 
 
268
    // The navigation policy to use for the next call to dispatchCreatePage.
 
269
    WebNavigationPolicy m_nextNavigationPolicy;
 
270
};
 
271
 
 
272
} // namespace WebKit
 
273
 
 
274
#endif