Move mixed content logic out of FrameLoader
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
5  * Copyright (C) 2011 Google Inc. 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  *
11  * 1.  Redistributions of source code must retain the above copyright
12  *     notice, this list of conditions and the following disclaimer. 
13  * 2.  Redistributions in binary form must reproduce the above copyright
14  *     notice, this list of conditions and the following disclaimer in the
15  *     documentation and/or other materials provided with the distribution. 
16  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
17  *     its contributors may be used to endorse or promote products derived
18  *     from this software without specific prior written permission. 
19  *
20  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #ifndef FrameLoader_h
33 #define FrameLoader_h
34
35 #include "CachePolicy.h"
36 #include "FrameLoaderStateMachine.h"
37 #include "FrameLoaderTypes.h"
38 #include "HistoryController.h"
39 #include "IconController.h"
40 #include "IconURL.h"
41 #include "LayoutMilestones.h"
42 #include "MixedContentChecker.h"
43 #include "PolicyChecker.h"
44 #include "ResourceHandle.h"
45 #include "ResourceLoadNotifier.h"
46 #include "SecurityContext.h"
47 #include "SubframeLoader.h"
48 #include "Timer.h"
49 #include <wtf/Forward.h>
50 #include <wtf/HashSet.h>
51
52 namespace WebCore {
53
54 class Archive;
55 class CachedFrameBase;
56 class CachedPage;
57 class CachedResource;
58 class Chrome;
59 class DOMWrapperWorld;
60 class DocumentLoader;
61 class Event;
62 class FormState;
63 class FormSubmission;
64 class FrameLoaderClient;
65 class FrameNetworkingContext;
66 class NavigationAction;
67 class NetworkingContext;
68 class Page;
69 class ResourceError;
70 class ResourceRequest;
71 class ResourceResponse;
72 class SecurityOrigin;
73 class SerializedScriptValue;
74 class StringWithDirection;
75 class SubstituteData;
76
77 struct FrameLoadRequest;
78 struct WindowFeatures;
79
80 bool isBackForwardLoadType(FrameLoadType);
81
82 class FrameLoader {
83     WTF_MAKE_NONCOPYABLE(FrameLoader);
84 public:
85     FrameLoader(Frame*, FrameLoaderClient*);
86     ~FrameLoader();
87
88     void init();
89
90     Frame* frame() const { return m_frame; }
91
92     PolicyChecker* policyChecker() const { return &m_policyChecker; }
93     HistoryController* history() const { return &m_history; }
94     ResourceLoadNotifier* notifier() const { return &m_notifer; }
95     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
96     IconController* icon() const { return &m_icon; }
97     MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
98
99     void prepareForHistoryNavigation();
100     void setupForReplace();
101
102     // FIXME: These are all functions which start loads. We have too many.
103     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
104     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
105         PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);
106
107     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
108     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
109     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
110 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
111     void loadArchive(PassRefPtr<Archive>);
112 #endif
113     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
114
115     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
116     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
117     void submitForm(PassRefPtr<FormSubmission>);
118
119     void reload(bool endToEndReload = false);
120     void reloadWithOverrideEncoding(const String& overrideEncoding);
121     void reloadWithOverrideURL(const KURL& overrideUrl, bool endToEndReload = false);
122
123     void open(CachedFrameBase&);
124     void loadItem(HistoryItem*, FrameLoadType);
125     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
126
127     static void reportLocalLoadFailed(Frame*, const String& url);
128
129     // FIXME: These are all functions which stop loads. We have too many.
130     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
131     void stopForUserCancel(bool deferCheckLoadComplete = false);
132     void stop();
133     void stopLoading(UnloadEventPolicy);
134     bool closeURL();
135     void cancelAndClear();
136     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
137     void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
138
139     bool isLoading() const;
140     bool frameHasLoaded() const;
141
142     int numPendingOrLoadingRequests(bool recurse) const;
143     String referrer() const;
144     String outgoingReferrer() const;
145     String outgoingOrigin() const;
146
147     DocumentLoader* activeDocumentLoader() const;
148     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
149     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
150     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
151     FrameState state() const { return m_state; }
152     static double timeOfLastCompletedLoad();
153
154     const ResourceRequest& originalRequest() const;
155     const ResourceRequest& initialRequest() const;
156     void receivedMainResourceError(const ResourceError&);
157
158     bool willLoadMediaElementURL(KURL&);
159
160     void handleFallbackContent();
161
162     ResourceError cancelledError(const ResourceRequest&) const;
163
164     bool isHostedByObjectElement() const;
165     bool isLoadingMainFrame() const;
166
167     bool isReplacing() const;
168     void setReplacing();
169     bool subframeIsLoading() const;
170     void willChangeTitle(DocumentLoader*);
171     void didChangeTitle(DocumentLoader*);
172     void didChangeIcons(IconType);
173
174     bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
175
176     FrameLoadType loadType() const;
177
178     CachePolicy subresourceCachePolicy() const;
179
180     void didLayout(LayoutMilestones);
181     void didFirstLayout();
182
183     void loadedResourceFromMemoryCache(CachedResource*);
184     void tellClientAboutPastMemoryCacheLoads();
185
186     void checkLoadComplete();
187     void detachFromParent();
188     void detachViewsAndDocumentLoader();
189
190     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
191     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
192     
193     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
194
195     FrameLoaderClient* client() const { return m_client; }
196
197     void setDefersLoading(bool);
198
199     void didExplicitOpen();
200
201     // Callbacks from DocumentWriter
202     void didBeginDocument(bool dispatchWindowObjectAvailable);
203
204     void receivedFirstData();
205
206     void handledOnloadEvents();
207     String userAgent(const KURL&) const;
208
209     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
210     void dispatchDidClearWindowObjectsInAllWorlds();
211     void dispatchDocumentElementAvailable();
212
213     // The following sandbox flags will be forced, regardless of changes to
214     // the sandbox attribute of any parent frames.
215     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
216     SandboxFlags effectiveSandboxFlags() const;
217
218     bool checkIfFormActionAllowedByCSP(const KURL&) const;
219
220     Frame* opener();
221     void setOpener(Frame*);
222
223     void resetMultipleFormSubmissionProtection();
224
225     void checkCallImplicitClose();
226
227     void frameDetached();
228
229     void setOutgoingReferrer(const KURL&);
230
231     void loadDone();
232     void finishedParsing();
233     void checkCompleted();
234
235     void checkDidPerformFirstNavigation();
236
237     bool isComplete() const;
238
239     void setTitle(const StringWithDirection&);
240
241     void commitProvisionalLoad();
242
243     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
244
245     Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0);
246
247     void applyUserAgent(ResourceRequest&);
248
249     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
250
251     void completed();
252     bool allAncestorsAreComplete() const; // including this
253     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
254     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
255
256     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
257     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
258     // introduce a proper callback type for this function, we should make it private again.
259     void continueLoadAfterWillSubmitForm();
260
261     void setOriginalURLForDownloadRequest(ResourceRequest&);
262
263     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
264
265     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
266
267     bool quickRedirectComing() const { return m_quickRedirectComing; }
268
269     bool shouldClose();
270     
271     void started();
272
273     enum PageDismissalType {
274         NoDismissal = 0,
275         BeforeUnloadDismissal = 1,
276         PageHideDismissal = 2,
277         UnloadDismissal = 3
278     };
279     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
280
281     NetworkingContext* networkingContext() const;
282
283     void reportMemoryUsage(MemoryObjectInfo*) const;
284
285 private:
286     bool allChildrenAreComplete() const; // immediate children, not all descendants
287
288     void checkTimerFired(Timer<FrameLoader>*);
289     
290     void loadSameDocumentItem(HistoryItem*);
291     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
292     
293     void loadProvisionalItemFromCachedPage();
294
295     void updateFirstPartyForCookies();
296     void setFirstPartyForCookies(const KURL&);
297     
298     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
299
300     void clearProvisionalLoad();
301     void transitionToCommitted(PassRefPtr<CachedPage>);
302     void frameLoadCompleted();
303
304     SubstituteData defaultSubstituteDataForURL(const KURL&);
305
306     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
307     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
308     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
309     
310     bool fireBeforeUnloadEvent(Chrome*);
311
312     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
313     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
314     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
315
316     bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
317     void scrollToFragmentWithParentBoundary(const KURL&);
318
319     void checkLoadCompleteForThisFrame();
320
321     void setDocumentLoader(DocumentLoader*);
322     void setPolicyDocumentLoader(DocumentLoader*);
323     void setProvisionalDocumentLoader(DocumentLoader*);
324
325     void setState(FrameState);
326
327     void closeOldDataSources();
328     void prepareForCachedPageRestore();
329
330     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
331
332     void dispatchDidCommitLoad();
333
334     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL);
335
336     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
337     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
338
339     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
340         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
341
342     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
343         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
344     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
345         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
346
347     void reloadWithRequest(const ResourceRequest&, bool endToEndReload);
348
349     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
350
351     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
352
353     void detachChildren();
354     void closeAndRemoveChild(Frame*);
355
356     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
357
358     void prepareForLoadStart();
359     void provisionalLoadStarted();
360
361     bool didOpenURL();
362
363     void scheduleCheckCompleted();
364     void scheduleCheckLoadComplete();
365     void startCheckCompleteTimer();
366
367     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
368
369     void dispatchGlobalObjectAvailableInAllWorlds();
370
371     Frame* m_frame;
372     FrameLoaderClient* m_client;
373
374     // FIXME: These should be OwnPtr<T> to reduce build times and simplify
375     // header dependencies unless performance testing proves otherwise.
376     // Some of these could be lazily created for memory savings on devices.
377     mutable PolicyChecker m_policyChecker;
378     mutable HistoryController m_history;
379     mutable ResourceLoadNotifier m_notifer;
380     mutable SubframeLoader m_subframeLoader;
381     mutable FrameLoaderStateMachine m_stateMachine;
382     mutable IconController m_icon;
383     mutable MixedContentChecker m_mixedContentChecker;
384
385     class FrameProgressTracker;
386     OwnPtr<FrameProgressTracker> m_progressTracker;
387
388     FrameState m_state;
389     FrameLoadType m_loadType;
390
391     // Document loaders for the three phases of frame loading. Note that while 
392     // a new request is being loaded, the old document loader may still be referenced.
393     // E.g. while a new request is in the "policy" state, the old document loader may
394     // be consulted in particular as it makes sense to imply certain settings on the new loader.
395     RefPtr<DocumentLoader> m_documentLoader;
396     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
397     RefPtr<DocumentLoader> m_policyDocumentLoader;
398
399     bool m_delegateIsHandlingProvisionalLoadError;
400
401     bool m_quickRedirectComing;
402     bool m_sentRedirectNotification;
403     bool m_inStopAllLoaders;
404
405     String m_outgoingReferrer;
406
407     bool m_isExecutingJavaScriptFormAction;
408
409     bool m_didCallImplicitClose;
410     bool m_wasUnloadEventEmitted;
411     PageDismissalType m_pageDismissalEventBeingDispatched;
412     bool m_isComplete;
413
414     RefPtr<SerializedScriptValue> m_pendingStateObject;
415
416     bool m_needsClear;
417
418     KURL m_submittedFormURL;
419
420     Timer<FrameLoader> m_checkTimer;
421     bool m_shouldCallCheckCompleted;
422     bool m_shouldCallCheckLoadComplete;
423
424     Frame* m_opener;
425     HashSet<Frame*> m_openedFrames;
426
427     bool m_didPerformFirstNavigation;
428     bool m_loadingFromCachedPage;
429     bool m_suppressOpenerInNewFrame;
430
431     SandboxFlags m_forcedSandboxFlags;
432
433     RefPtr<FrameNetworkingContext> m_networkingContext;
434
435     KURL m_previousUrl;
436     RefPtr<HistoryItem> m_requestedHistoryItem;
437 };
438
439 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
440 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
441 // the frame name references a frame different from the openerFrame, e.g. when it is
442 // "_self" or "_parent".
443 //
444 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
445 // and moving it to a more appropriate location.
446 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
447
448 } // namespace WebCore
449
450 #endif // FrameLoader_h