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/heap/Handle.h"
45 #include "platform/network/ResourceRequest.h"
46 #include "wtf/Forward.h"
47 #include "wtf/HashSet.h"
48 #include "wtf/OwnPtr.h"
56 class FrameLoaderClient;
57 class NavigationAction;
58 class ProgressTracker;
60 class SerializedScriptValue;
63 struct FrameLoadRequest;
65 bool isBackForwardLoadType(FrameLoadType);
67 class FrameLoader FINAL {
68 WTF_MAKE_NONCOPYABLE(FrameLoader);
69 DISALLOW_ALLOCATION();
71 static ResourceRequest requestFromHistoryItem(HistoryItem*, ResourceRequestCachePolicy);
73 FrameLoader(LocalFrame*);
78 LocalFrame* frame() const { return m_frame; }
80 MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
81 ProgressTracker& progress() const { return *m_progressTracker; }
83 // These functions start a load. All eventually call into loadWithNavigationAction() or loadInSameDocument().
84 void load(const FrameLoadRequest&); // The entry point for non-reload, non-history loads.
85 void reload(ReloadPolicy = NormalReload, const KURL& overrideURL = KURL(), const AtomicString& overrideEncoding = nullAtom, ClientRedirectPolicy = NotClientRedirect);
86 void loadHistoryItem(HistoryItem*, HistoryLoadType = HistoryDifferentDocumentLoad, ResourceRequestCachePolicy = UseProtocolCachePolicy); // The entry point for all back/forward loads
88 static void reportLocalLoadFailed(LocalFrame*, const String& url);
90 // FIXME: These are all functions which stop loads. We have too many.
91 // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
92 // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
93 void stopAllLoaders();
97 // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
100 void replaceDocumentWhileExecutingJavaScriptURL(const String& source, Document* ownerDocument);
102 // Sets a timer to notify the client that the initial empty document has
103 // been accessed, and thus it is no longer safe to show a provisional URL
104 // above the document without risking a URL spoof.
105 void didAccessInitialDocument();
107 // If the initial empty document is showing and has been accessed, this
108 // cancels the timer and immediately notifies the client in cases that
109 // waiting to notify would allow a URL spoof.
110 void notifyIfInitialDocumentAccessed();
112 DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
113 DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
114 DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
115 FrameState state() const { return m_state; }
116 FetchContext& fetchContext() const { return *m_fetchContext; }
118 void receivedMainResourceError(const ResourceError&);
120 bool isLoadingMainFrame() const;
122 bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
123 bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
125 FrameLoadType loadType() const;
126 void setLoadType(FrameLoadType loadType) { m_loadType = loadType; }
128 void checkLoadComplete();
130 FrameLoaderClient* client() const;
132 void setDefersLoading(bool);
134 void didExplicitOpen();
136 // Callbacks from DocumentWriter
137 void didBeginDocument(bool dispatchWindowObjectAvailable);
139 void receivedFirstData();
141 String userAgent(const KURL&) const;
143 void dispatchDidClearWindowObjectInMainWorld();
144 void dispatchDidClearDocumentOfWindowObject();
145 void dispatchDocumentElementAvailable();
147 // The following sandbox flags will be forced, regardless of changes to
148 // the sandbox attribute of any parent frames.
149 void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
150 SandboxFlags effectiveSandboxFlags() const;
153 void setOpener(LocalFrame*);
155 void detachFromParent();
158 void finishedParsing();
159 void checkCompleted();
161 void commitProvisionalLoad();
163 FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
165 LocalFrame* findFrameForNavigation(const AtomicString& name, Document* activeDocument);
167 void applyUserAgent(ResourceRequest&);
169 bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&, unsigned long requestIdentifier);
171 bool allAncestorsAreComplete() const; // including this
175 bool allowPlugins(ReasonForCallingAllowPlugins);
177 void updateForSameDocumentNavigation(const KURL&, SameDocumentNavigationSource, PassRefPtr<SerializedScriptValue>, FrameLoadType);
179 HistoryItem* currentItem() const { return m_currentItem.get(); }
180 void saveScrollState();
181 void clearScrollPositionAndViewState();
183 void restoreScrollPositionAndViewState();
185 void trace(Visitor*);
188 bool allChildrenAreComplete() const; // immediate children, not all descendants
192 void checkTimerFired(Timer<FrameLoader>*);
193 void didAccessInitialDocumentTimerFired(Timer<FrameLoader>*);
195 bool prepareRequestForThisFrame(FrameLoadRequest&);
196 void setReferrerForFrameRequest(ResourceRequest&, ShouldSendReferrer, Document*);
197 FrameLoadType determineFrameLoadType(const FrameLoadRequest&);
198 bool isScriptTriggeredFormSubmissionInChildFrame(const FrameLoadRequest&) const;
200 SubstituteData defaultSubstituteDataForURL(const KURL&);
202 bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
203 void scrollToFragmentWithParentBoundary(const KURL&);
205 bool checkLoadCompleteForThisFrame();
207 // Calls continueLoadAfterNavigationPolicy
208 void loadWithNavigationAction(const NavigationAction&, FrameLoadType, PassRefPtrWillBeRawPtr<FormState>,
209 const SubstituteData&, ContentSecurityPolicyCheck shouldCheckMainWorldContentSecurityPolicy, ClientRedirectPolicy = NotClientRedirect, const AtomicString& overrideEncoding = nullAtom);
211 bool validateTransitionNavigationMode();
212 bool dispatchNavigationTransitionData();
215 void setHistoryItemStateForCommit(HistoryCommitType, bool isPushOrReplaceState = false, PassRefPtr<SerializedScriptValue> = nullptr);
217 void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, FrameLoadType, ClientRedirectPolicy);
219 void scheduleCheckCompleted();
221 RawPtrWillBeMember<LocalFrame> m_frame;
223 // FIXME: These should be OwnPtr<T> to reduce build times and simplify
224 // header dependencies unless performance testing proves otherwise.
225 // Some of these could be lazily created for memory savings on devices.
226 mutable FrameLoaderStateMachine m_stateMachine;
227 mutable MixedContentChecker m_mixedContentChecker;
229 OwnPtrWillBeMember<ProgressTracker> m_progressTracker;
232 FrameLoadType m_loadType;
234 // Document loaders for the three phases of frame loading. Note that while
235 // a new request is being loaded, the old document loader may still be referenced.
236 // E.g. while a new request is in the "policy" state, the old document loader may
237 // be consulted in particular as it makes sense to imply certain settings on the new loader.
238 RefPtr<DocumentLoader> m_documentLoader;
239 RefPtr<DocumentLoader> m_provisionalDocumentLoader;
240 RefPtr<DocumentLoader> m_policyDocumentLoader;
241 OwnPtrWillBeMember<FetchContext> m_fetchContext;
243 RefPtr<HistoryItem> m_currentItem;
244 RefPtr<HistoryItem> m_provisionalItem;
245 struct DeferredHistoryLoad {
246 DeferredHistoryLoad(HistoryItem* item, HistoryLoadType type, ResourceRequestCachePolicy cachePolicy)
249 , m_cachePolicy(cachePolicy)
253 DeferredHistoryLoad() { }
255 bool isValid() { return m_item; }
257 RefPtr<HistoryItem> m_item;
258 HistoryLoadType m_type;
259 ResourceRequestCachePolicy m_cachePolicy;
261 DeferredHistoryLoad m_deferredHistoryLoad;
263 bool m_inStopAllLoaders;
265 Timer<FrameLoader> m_checkTimer;
267 bool m_didAccessInitialDocument;
268 Timer<FrameLoader> m_didAccessInitialDocumentTimer;
270 SandboxFlags m_forcedSandboxFlags;
275 #endif // FrameLoader_h