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.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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.
35 #include "core/dom/IconURL.h"
36 #include "core/dom/SandboxFlags.h"
37 #include "core/dom/SecurityContext.h"
38 #include "core/fetch/ResourceLoaderOptions.h"
39 #include "core/loader/FrameLoaderStateMachine.h"
40 #include "core/loader/FrameLoaderTypes.h"
41 #include "core/loader/HistoryItem.h"
42 #include "core/loader/MixedContentChecker.h"
43 #include "platform/Timer.h"
44 #include "platform/network/ResourceRequest.h"
45 #include "wtf/Forward.h"
46 #include "wtf/HashSet.h"
47 #include "wtf/OwnPtr.h"
53 class DOMWrapperWorld;
59 class FrameLoaderClient;
61 class NavigationAction;
63 class ProgressTracker;
65 class ResourceResponse;
67 class SerializedScriptValue;
70 struct FrameLoadRequest;
71 struct WindowFeatures;
73 bool isBackForwardLoadType(FrameLoadType);
76 WTF_MAKE_NONCOPYABLE(FrameLoader);
78 FrameLoader(LocalFrame*, FrameLoaderClient*);
83 LocalFrame* frame() const { return m_frame; }
85 MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
86 ProgressTracker& progress() const { return *m_progressTracker; }
88 // These functions start a load. All eventually call into loadWithNavigationAction() or loadInSameDocument().
89 void load(const FrameLoadRequest&); // The entry point for non-reload, non-history loads.
90 void reload(ReloadPolicy = NormalReload, const KURL& overrideURL = KURL(), const AtomicString& overrideEncoding = nullAtom);
91 void loadHistoryItem(HistoryItem*, HistoryLoadType = HistoryDifferentDocumentLoad, ResourceRequestCachePolicy = UseProtocolCachePolicy); // The entry point for all back/forward loads
93 static void reportLocalLoadFailed(LocalFrame*, const String& url);
95 // FIXME: These are all functions which stop loads. We have too many.
96 // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
97 // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
98 void stopAllLoaders();
101 // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
104 // Sets a timer to notify the client that the initial empty document has
105 // been accessed, and thus it is no longer safe to show a provisional URL
106 // above the document without risking a URL spoof.
107 void didAccessInitialDocument();
109 // If the initial empty document is showing and has been accessed, this
110 // cancels the timer and immediately notifies the client in cases that
111 // waiting to notify would allow a URL spoof.
112 void notifyIfInitialDocumentAccessed();
114 bool isLoading() const;
116 DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
117 DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
118 DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
119 FrameState state() const { return m_state; }
120 FetchContext& fetchContext() const { return *m_fetchContext; }
122 void receivedMainResourceError(const ResourceError&);
124 bool isLoadingMainFrame() const;
126 bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
127 bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
129 FrameLoadType loadType() const;
130 void setLoadType(FrameLoadType loadType) { m_loadType = loadType; }
132 void checkLoadComplete();
134 static void addHTTPOriginIfNeeded(ResourceRequest&, const AtomicString& origin);
136 FrameLoaderClient* client() const { return m_client; }
138 void setDefersLoading(bool);
140 void didExplicitOpen();
142 // Callbacks from DocumentWriter
143 void didBeginDocument(bool dispatchWindowObjectAvailable);
145 void receivedFirstData();
147 String userAgent(const KURL&) const;
149 void dispatchDidClearWindowObjectInMainWorld();
150 void dispatchDidClearDocumentOfWindowObject();
151 void dispatchDocumentElementAvailable();
153 // The following sandbox flags will be forced, regardless of changes to
154 // the sandbox attribute of any parent frames.
155 void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
156 SandboxFlags effectiveSandboxFlags() const;
158 LocalFrame* opener();
159 void setOpener(LocalFrame*);
161 void frameDetached();
164 void finishedParsing();
165 void checkCompleted();
167 void commitProvisionalLoad();
169 FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
171 LocalFrame* findFrameForNavigation(const AtomicString& name, Document* activeDocument);
173 void applyUserAgent(ResourceRequest&);
175 bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&, unsigned long requestIdentifier);
177 bool allAncestorsAreComplete() const; // including this
183 bool allowPlugins(ReasonForCallingAllowPlugins);
185 void updateForSameDocumentNavigation(const KURL&, SameDocumentNavigationSource, PassRefPtr<SerializedScriptValue>, UpdateBackForwardListPolicy);
187 HistoryItem* currentItem() const { return m_currentItem.get(); }
188 void saveScrollState();
189 void clearScrollPositionAndViewState();
191 void restoreScrollPositionAndViewState();
194 bool allChildrenAreComplete() const; // immediate children, not all descendants
198 void checkTimerFired(Timer<FrameLoader>*);
199 void didAccessInitialDocumentTimerFired(Timer<FrameLoader>*);
201 bool prepareRequestForThisFrame(FrameLoadRequest&);
202 void setReferrerForFrameRequest(ResourceRequest&, ShouldSendReferrer, Document*);
203 FrameLoadType determineFrameLoadType(const FrameLoadRequest&);
204 bool isScriptTriggeredFormSubmissionInChildFrame(const FrameLoadRequest&) const;
206 SubstituteData defaultSubstituteDataForURL(const KURL&);
208 bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
209 void scrollToFragmentWithParentBoundary(const KURL&);
211 bool checkLoadCompleteForThisFrame();
213 // Calls continueLoadAfterNavigationPolicy
214 void loadWithNavigationAction(const NavigationAction&, FrameLoadType, PassRefPtrWillBeRawPtr<FormState>,
215 const SubstituteData&, ClientRedirectPolicy = NotClientRedirect, const AtomicString& overrideEncoding = nullAtom);
217 void detachFromParent();
218 void detachChildren();
219 void closeAndRemoveChild(LocalFrame*);
222 void setHistoryItemStateForCommit(HistoryCommitType, bool isPushOrReplaceState = false, PassRefPtr<SerializedScriptValue> = nullptr);
224 void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, UpdateBackForwardListPolicy, ClientRedirectPolicy);
226 void scheduleCheckCompleted();
227 void startCheckCompleteTimer();
230 FrameLoaderClient* m_client;
232 // FIXME: These should be OwnPtr<T> to reduce build times and simplify
233 // header dependencies unless performance testing proves otherwise.
234 // Some of these could be lazily created for memory savings on devices.
235 mutable FrameLoaderStateMachine m_stateMachine;
236 mutable MixedContentChecker m_mixedContentChecker;
238 OwnPtr<ProgressTracker> m_progressTracker;
241 FrameLoadType m_loadType;
243 // Document loaders for the three phases of frame loading. Note that while
244 // a new request is being loaded, the old document loader may still be referenced.
245 // E.g. while a new request is in the "policy" state, the old document loader may
246 // be consulted in particular as it makes sense to imply certain settings on the new loader.
247 RefPtr<DocumentLoader> m_documentLoader;
248 RefPtr<DocumentLoader> m_provisionalDocumentLoader;
249 RefPtr<DocumentLoader> m_policyDocumentLoader;
250 OwnPtr<FetchContext> m_fetchContext;
252 RefPtr<HistoryItem> m_currentItem;
253 RefPtr<HistoryItem> m_provisionalItem;
254 struct DeferredHistoryLoad {
255 DeferredHistoryLoad(HistoryItem* item, HistoryLoadType type, ResourceRequestCachePolicy cachePolicy)
258 , m_cachePolicy(cachePolicy)
262 DeferredHistoryLoad() { }
264 bool isValid() { return m_item; }
266 RefPtr<HistoryItem> m_item;
267 HistoryLoadType m_type;
268 ResourceRequestCachePolicy m_cachePolicy;
270 DeferredHistoryLoad m_deferredHistoryLoad;
272 bool m_inStopAllLoaders;
274 // FIXME: This is only used in checkCompleted(). Figure out a way to disentangle it.
277 Timer<FrameLoader> m_checkTimer;
278 bool m_shouldCallCheckCompleted;
280 bool m_didAccessInitialDocument;
281 Timer<FrameLoader> m_didAccessInitialDocumentTimer;
283 SandboxFlags m_forcedSandboxFlags;
286 } // namespace WebCore
288 #endif // FrameLoader_h