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;
64 class ResourceResponse;
66 class SerializedScriptValue;
69 struct FrameLoadRequest;
70 struct WindowFeatures;
72 bool isBackForwardLoadType(FrameLoadType);
75 WTF_MAKE_NONCOPYABLE(FrameLoader);
77 FrameLoader(LocalFrame*, FrameLoaderClient*);
82 LocalFrame* frame() const { return m_frame; }
84 MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
86 // These functions start a load. All eventually call into loadWithNavigationAction() or loadInSameDocument().
87 void load(const FrameLoadRequest&); // The entry point for non-reload, non-history loads.
88 void reload(ReloadPolicy = NormalReload, const KURL& overrideURL = KURL(), const AtomicString& overrideEncoding = nullAtom);
89 void loadHistoryItem(HistoryItem*, HistoryLoadType = HistoryDifferentDocumentLoad, ResourceRequestCachePolicy = UseProtocolCachePolicy); // The entry point for all back/forward loads
91 static void reportLocalLoadFailed(LocalFrame*, const String& url);
93 // FIXME: These are all functions which stop loads. We have too many.
94 // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
95 // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
96 void stopAllLoaders();
99 // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
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 bool isLoading() const;
114 int numPendingOrLoadingRequests(bool recurse) 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(DocumentLoader*);
133 void checkLoadComplete();
135 static void addHTTPOriginIfNeeded(ResourceRequest&, const AtomicString& origin);
137 FrameLoaderClient* client() const { return m_client; }
139 void setDefersLoading(bool);
141 void didExplicitOpen();
143 // Callbacks from DocumentWriter
144 void didBeginDocument(bool dispatchWindowObjectAvailable);
146 void receivedFirstData();
148 String userAgent(const KURL&) const;
150 void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
151 void dispatchDidClearWindowObjectsInAllWorlds();
152 void dispatchDocumentElementAvailable();
154 // The following sandbox flags will be forced, regardless of changes to
155 // the sandbox attribute of any parent frames.
156 void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
157 SandboxFlags effectiveSandboxFlags() const;
159 LocalFrame* opener();
160 void setOpener(LocalFrame*);
162 void frameDetached();
165 void finishedParsing();
166 void checkCompleted();
168 void commitProvisionalLoad();
170 FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
172 LocalFrame* findFrameForNavigation(const AtomicString& name, Document* activeDocument);
174 void applyUserAgent(ResourceRequest&);
176 bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&, unsigned long requestIdentifier);
178 bool allAncestorsAreComplete() const; // including this
184 bool allowPlugins(ReasonForCallingAllowPlugins);
186 void updateForSameDocumentNavigation(const KURL&, SameDocumentNavigationSource, PassRefPtr<SerializedScriptValue>, UpdateBackForwardListPolicy);
188 HistoryItem* currentItem() const { return m_currentItem.get(); }
189 void markDocumentStateDirty();
190 void saveDocumentState();
191 void saveScrollState();
192 void clearScrollPositionAndViewState();
194 void restoreScrollPositionAndViewState();
197 bool allChildrenAreComplete() const; // immediate children, not all descendants
201 void checkTimerFired(Timer<FrameLoader>*);
202 void didAccessInitialDocumentTimerFired(Timer<FrameLoader>*);
204 bool prepareRequestForThisFrame(FrameLoadRequest&);
205 void setReferrerForFrameRequest(ResourceRequest&, ShouldSendReferrer, Document*);
206 FrameLoadType determineFrameLoadType(const FrameLoadRequest&);
207 bool isScriptTriggeredFormSubmissionInChildFrame(const FrameLoadRequest&) const;
209 SubstituteData defaultSubstituteDataForURL(const KURL&);
211 bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
212 void scrollToFragmentWithParentBoundary(const KURL&);
214 bool checkLoadCompleteForThisFrame();
216 // Calls continueLoadAfterNavigationPolicy
217 void loadWithNavigationAction(const NavigationAction&, FrameLoadType, PassRefPtr<FormState>,
218 const SubstituteData&, ClientRedirectPolicy = NotClientRedirect, const AtomicString& overrideEncoding = nullAtom);
220 void detachFromParent();
221 void detachChildren();
222 void closeAndRemoveChild(LocalFrame*);
225 void setHistoryItemStateForCommit(HistoryCommitType, bool isPushOrReplaceState = false, PassRefPtr<SerializedScriptValue> = nullptr);
227 void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, UpdateBackForwardListPolicy, ClientRedirectPolicy);
229 void scheduleCheckCompleted();
230 void startCheckCompleteTimer();
233 FrameLoaderClient* m_client;
235 // FIXME: These should be OwnPtr<T> to reduce build times and simplify
236 // header dependencies unless performance testing proves otherwise.
237 // Some of these could be lazily created for memory savings on devices.
238 mutable FrameLoaderStateMachine m_stateMachine;
239 mutable MixedContentChecker m_mixedContentChecker;
241 class FrameProgressTracker;
242 OwnPtr<FrameProgressTracker> m_progressTracker;
245 FrameLoadType m_loadType;
247 // Document loaders for the three phases of frame loading. Note that while
248 // a new request is being loaded, the old document loader may still be referenced.
249 // E.g. while a new request is in the "policy" state, the old document loader may
250 // be consulted in particular as it makes sense to imply certain settings on the new loader.
251 RefPtr<DocumentLoader> m_documentLoader;
252 RefPtr<DocumentLoader> m_provisionalDocumentLoader;
253 RefPtr<DocumentLoader> m_policyDocumentLoader;
254 OwnPtr<FetchContext> m_fetchContext;
256 RefPtr<HistoryItem> m_currentItem;
257 RefPtr<HistoryItem> m_provisionalItem;
258 struct DeferredHistoryLoad {
259 DeferredHistoryLoad(HistoryItem* item, HistoryLoadType type, ResourceRequestCachePolicy cachePolicy)
262 , m_cachePolicy(cachePolicy)
266 DeferredHistoryLoad() { }
268 bool isValid() { return m_item; }
270 RefPtr<HistoryItem> m_item;
271 HistoryLoadType m_type;
272 ResourceRequestCachePolicy m_cachePolicy;
274 DeferredHistoryLoad m_deferredHistoryLoad;
276 bool m_inStopAllLoaders;
278 // FIXME: This is only used in checkCompleted(). Figure out a way to disentangle it.
281 Timer<FrameLoader> m_checkTimer;
282 bool m_shouldCallCheckCompleted;
284 bool m_didAccessInitialDocument;
285 Timer<FrameLoader> m_didAccessInitialDocumentTimer;
287 SandboxFlags m_forcedSandboxFlags;
290 } // namespace WebCore
292 #endif // FrameLoader_h