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 static ResourceRequest requestFromHistoryItem(HistoryItem*, ResourceRequestCachePolicy);
80 FrameLoader(LocalFrame*);
85 LocalFrame* frame() const { return m_frame; }
87 MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
88 ProgressTracker& progress() const { return *m_progressTracker; }
90 // These functions start a load. All eventually call into loadWithNavigationAction() or loadInSameDocument().
91 void load(const FrameLoadRequest&); // The entry point for non-reload, non-history loads.
92 void reload(ReloadPolicy = NormalReload, const KURL& overrideURL = KURL(), const AtomicString& overrideEncoding = nullAtom, ClientRedirectPolicy = NotClientRedirect);
93 void loadHistoryItem(HistoryItem*, HistoryLoadType = HistoryDifferentDocumentLoad, ResourceRequestCachePolicy = UseProtocolCachePolicy); // The entry point for all back/forward loads
95 static void reportLocalLoadFailed(LocalFrame*, const String& url);
97 // FIXME: These are all functions which stop loads. We have too many.
98 // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
99 // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
100 void stopAllLoaders();
103 // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
106 // Sets a timer to notify the client that the initial empty document has
107 // been accessed, and thus it is no longer safe to show a provisional URL
108 // above the document without risking a URL spoof.
109 void didAccessInitialDocument();
111 // If the initial empty document is showing and has been accessed, this
112 // cancels the timer and immediately notifies the client in cases that
113 // waiting to notify would allow a URL spoof.
114 void notifyIfInitialDocumentAccessed();
116 bool isLoading() const;
118 DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
119 DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
120 DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
121 FrameState state() const { return m_state; }
122 FetchContext& fetchContext() const { return *m_fetchContext; }
124 void receivedMainResourceError(const ResourceError&);
126 bool isLoadingMainFrame() const;
128 bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
129 bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
131 FrameLoadType loadType() const;
132 void setLoadType(FrameLoadType loadType) { m_loadType = loadType; }
134 void checkLoadComplete();
136 FrameLoaderClient* client() const;
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 detachFromParent();
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>, FrameLoadType);
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&, ContentSecurityPolicyCheck shouldCheckMainWorldContentSecurityPolicy, ClientRedirectPolicy = NotClientRedirect, const AtomicString& overrideEncoding = nullAtom);
217 bool validateTransitionNavigationMode();
218 bool dispatchNavigationTransitionData();
221 void setHistoryItemStateForCommit(HistoryCommitType, bool isPushOrReplaceState = false, PassRefPtr<SerializedScriptValue> = nullptr);
223 void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, FrameLoadType, ClientRedirectPolicy);
225 void scheduleCheckCompleted();
229 // FIXME: These should be OwnPtr<T> to reduce build times and simplify
230 // header dependencies unless performance testing proves otherwise.
231 // Some of these could be lazily created for memory savings on devices.
232 mutable FrameLoaderStateMachine m_stateMachine;
233 mutable MixedContentChecker m_mixedContentChecker;
235 OwnPtr<ProgressTracker> m_progressTracker;
238 FrameLoadType m_loadType;
240 // Document loaders for the three phases of frame loading. Note that while
241 // a new request is being loaded, the old document loader may still be referenced.
242 // E.g. while a new request is in the "policy" state, the old document loader may
243 // be consulted in particular as it makes sense to imply certain settings on the new loader.
244 RefPtr<DocumentLoader> m_documentLoader;
245 RefPtr<DocumentLoader> m_provisionalDocumentLoader;
246 RefPtr<DocumentLoader> m_policyDocumentLoader;
247 OwnPtr<FetchContext> m_fetchContext;
249 RefPtr<HistoryItem> m_currentItem;
250 RefPtr<HistoryItem> m_provisionalItem;
251 struct DeferredHistoryLoad {
252 DeferredHistoryLoad(HistoryItem* item, HistoryLoadType type, ResourceRequestCachePolicy cachePolicy)
255 , m_cachePolicy(cachePolicy)
259 DeferredHistoryLoad() { }
261 bool isValid() { return m_item; }
263 RefPtr<HistoryItem> m_item;
264 HistoryLoadType m_type;
265 ResourceRequestCachePolicy m_cachePolicy;
267 DeferredHistoryLoad m_deferredHistoryLoad;
269 bool m_inStopAllLoaders;
271 // FIXME: This is only used in checkCompleted(). Figure out a way to disentangle it.
274 Timer<FrameLoader> m_checkTimer;
276 bool m_didAccessInitialDocument;
277 Timer<FrameLoader> m_didAccessInitialDocumentTimer;
279 SandboxFlags m_forcedSandboxFlags;
281 bool m_willDetachClient;
286 #endif // FrameLoader_h