1/* 2 * Copyright (C) 2006, 2007, 2008, 2009, 2011, 2013 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 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 "IconURL.h" 39#include "LayoutMilestones.h" 40#include "MixedContentChecker.h" 41#include "ResourceHandleTypes.h" 42#include "ResourceLoadNotifier.h" 43#include "SecurityContext.h" 44#include "Timer.h" 45#include <wtf/Forward.h> 46#include <wtf/HashSet.h> 47 48namespace WebCore { 49 50class Archive; 51class CachedFrameBase; 52class CachedPage; 53class CachedResource; 54class Chrome; 55class DOMWrapperWorld; 56class Document; 57class DocumentLoader; 58class Event; 59class FormState; 60class FormSubmission; 61class FrameLoaderClient; 62class FrameNetworkingContext; 63class HistoryController; 64class HistoryItem; 65class IconController; 66class NavigationAction; 67class NetworkingContext; 68class Page; 69class PageActivityAssertionToken; 70class PolicyChecker; 71class ResourceError; 72class ResourceRequest; 73class ResourceResponse; 74class SecurityOrigin; 75class SerializedScriptValue; 76class StringWithDirection; 77class SubframeLoader; 78class SubstituteData; 79 80struct FrameLoadRequest; 81struct WindowFeatures; 82 83bool isBackForwardLoadType(FrameLoadType); 84 85class FrameLoader { 86 WTF_MAKE_NONCOPYABLE(FrameLoader); 87public: 88 FrameLoader(Frame&, FrameLoaderClient&); 89 ~FrameLoader(); 90 91 void init(); 92#if PLATFORM(IOS) 93 void initForSynthesizedDocument(const URL&); 94#endif 95 96 Frame& frame() const { return m_frame; } 97 98 PolicyChecker& policyChecker() const { return *m_policyChecker; } 99 HistoryController& history() const { return *m_history; } 100 ResourceLoadNotifier& notifier() const { return m_notifier; } 101 SubframeLoader& subframeLoader() const { return *m_subframeLoader; } 102 IconController& icon() const { return *m_icon; } 103 MixedContentChecker& mixedContentChecker() const { return m_mixedContentChecker; } 104 105 void prepareForHistoryNavigation(); 106 void setupForReplace(); 107 108 // FIXME: These are all functions which start loads. We have too many. 109 void loadURLIntoChildFrame(const URL&, const String& referer, Frame*); 110 void loadFrameRequest(const FrameLoadRequest&, LockHistory, LockBackForwardList, // Called by submitForm, calls loadPostRequest and loadURL. 111 PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer, AllowNavigationToInvalidURL); 112 113 void load(const FrameLoadRequest&); 114 115#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML) 116 void loadArchive(PassRefPtr<Archive>); 117#endif 118 unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data); 119 120 void changeLocation(SecurityOrigin*, const URL&, const String& referrer, LockHistory = LockHistory::Yes, 121 LockBackForwardList = LockBackForwardList::Yes, bool refresh = false, AllowNavigationToInvalidURL = AllowNavigationToInvalidURL::Yes); 122 void urlSelected(const URL&, const String& target, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer); 123 void submitForm(PassRefPtr<FormSubmission>); 124 125 void reload(bool endToEndReload = false); 126 void reloadWithOverrideEncoding(const String& overrideEncoding); 127 128 void open(CachedFrameBase&); 129 void loadItem(HistoryItem*, FrameLoadType); 130 HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); } 131 132 void retryAfterFailedCacheOnlyMainResourceLoad(); 133 134 static void reportLocalLoadFailed(Frame*, const String& url); 135 136 // FIXME: These are all functions which stop loads. We have too many. 137 void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem); 138 void stopForUserCancel(bool deferCheckLoadComplete = false); 139 void stop(); 140 void stopLoading(UnloadEventPolicy); 141 bool closeURL(); 142 void cancelAndClear(); 143 // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters). 144 void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true); 145 146 bool isLoading() const; 147 bool frameHasLoaded() const; 148 149 int numPendingOrLoadingRequests(bool recurse) const; 150 String referrer() const; 151 String outgoingReferrer() const; 152 String outgoingOrigin() const; 153 154 DocumentLoader* activeDocumentLoader() const; 155 DocumentLoader* documentLoader() const { return m_documentLoader.get(); } 156 DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); } 157 DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); } 158 FrameState state() const { return m_state; } 159 160#if PLATFORM(IOS) 161 RetainPtr<CFDictionaryRef> connectionProperties(ResourceLoader*); 162#endif 163 const ResourceRequest& originalRequest() const; 164 const ResourceRequest& initialRequest() const; 165 void receivedMainResourceError(const ResourceError&); 166 167 bool willLoadMediaElementURL(URL&); 168 169 void handleFallbackContent(); 170 171 ResourceError cancelledError(const ResourceRequest&) const; 172 173 bool isHostedByObjectElement() const; 174 175 bool isReplacing() const; 176 void setReplacing(); 177 bool subframeIsLoading() const; 178 void willChangeTitle(DocumentLoader*); 179 void didChangeTitle(DocumentLoader*); 180 void didChangeIcons(IconType); 181 182 bool shouldTreatURLAsSrcdocDocument(const URL&) const; 183 184 FrameLoadType loadType() const; 185 186 CachePolicy subresourceCachePolicy() const; 187 188 void didLayout(LayoutMilestones); 189 void didFirstLayout(); 190 191 void loadedResourceFromMemoryCache(CachedResource*, ResourceRequest& newRequest); 192 void tellClientAboutPastMemoryCacheLoads(); 193 194 void checkLoadComplete(); 195 void detachFromParent(); 196 void detachViewsAndDocumentLoader(); 197 198 void addExtraFieldsToSubresourceRequest(ResourceRequest&); 199 void addExtraFieldsToMainResourceRequest(ResourceRequest&); 200 201 static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin); 202 203 FrameLoaderClient& client() const { return m_client; } 204 205 void setDefersLoading(bool); 206 207 void didExplicitOpen(); 208 209 // Callbacks from DocumentWriter 210 void didBeginDocument(bool dispatchWindowObjectAvailable); 211 212 void receivedFirstData(); 213 214 void handledOnloadEvents(); 215 String userAgent(const URL&) const; 216 217 void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&); 218 void dispatchDidClearWindowObjectsInAllWorlds(); 219 220 // The following sandbox flags will be forced, regardless of changes to 221 // the sandbox attribute of any parent frames. 222 void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; } 223 SandboxFlags effectiveSandboxFlags() const; 224 225 bool checkIfFormActionAllowedByCSP(const URL&) const; 226 227 Frame* opener(); 228 void setOpener(Frame*); 229 230 void resetMultipleFormSubmissionProtection(); 231 232 void checkCallImplicitClose(); 233 234 void frameDetached(); 235 236 void setOutgoingReferrer(const URL&); 237 238 void loadDone(); 239 void finishedParsing(); 240 void checkCompleted(); 241 242 bool isComplete() const; 243 244 void commitProvisionalLoad(); 245 246 void setLoadsSynchronously(bool loadsSynchronously) { m_loadsSynchronously = loadsSynchronously; } 247 bool loadsSynchronously() const { return m_loadsSynchronously; } 248 249 FrameLoaderStateMachine& stateMachine() { return m_stateMachine; } 250 251 Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0); 252 253 void applyUserAgent(ResourceRequest&); 254 255 bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier); 256 257 void completed(); 258 bool allAncestorsAreComplete() const; // including this 259 void clientRedirected(const URL&, double delay, double fireDate, LockBackForwardList); 260 void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress); 261 262 // FIXME: This is public because this asynchronous callback from the FrameLoaderClient 263 // uses the policy machinery (and therefore is called via the PolicyChecker). Once we 264 // introduce a proper callback type for this function, we should make it private again. 265 void continueLoadAfterWillSubmitForm(); 266 267 void setOriginalURLForDownloadRequest(ResourceRequest&); 268 269 bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; } 270 271 static ObjectContentType defaultObjectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages); 272 273 bool quickRedirectComing() const { return m_quickRedirectComing; } 274 275 bool shouldClose(); 276 277 void started(); 278 279 enum PageDismissalType { 280 NoDismissal = 0, 281 BeforeUnloadDismissal = 1, 282 PageHideDismissal = 2, 283 UnloadDismissal = 3 284 }; 285 PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; } 286 287 NetworkingContext* networkingContext() const; 288 289 void loadProgressingStatusChanged(); 290 291 const URL& previousURL() const { return m_previousURL; } 292 293 void forcePageTransitionIfNeeded(); 294 295private: 296 enum FormSubmissionCacheLoadPolicy { 297 MayAttemptCacheOnlyLoadForFormSubmissionItem, 298 MayNotAttemptCacheOnlyLoadForFormSubmissionItem 299 }; 300 301 bool allChildrenAreComplete() const; // immediate children, not all descendants 302 303 void checkTimerFired(Timer<FrameLoader>&); 304 305 void loadSameDocumentItem(HistoryItem*); 306 void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy); 307 308 void loadProvisionalItemFromCachedPage(); 309 310 void updateFirstPartyForCookies(); 311 void setFirstPartyForCookies(const URL&); 312 313 void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource); 314 315 void clearProvisionalLoad(); 316 void transitionToCommitted(CachedPage*); 317 void frameLoadCompleted(); 318 319 SubstituteData defaultSubstituteDataForURL(const URL&); 320 321 bool handleBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated); 322 323 void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue, AllowNavigationToInvalidURL); 324 void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue, AllowNavigationToInvalidURL); 325 void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue); 326 327 bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&); 328 void scrollToFragmentWithParentBoundary(const URL&); 329 330 void checkLoadCompleteForThisFrame(); 331 332 void setDocumentLoader(DocumentLoader*); 333 void setPolicyDocumentLoader(DocumentLoader*); 334 void setProvisionalDocumentLoader(DocumentLoader*); 335 336 void setState(FrameState); 337 338 void closeOldDataSources(); 339 void prepareForCachedPageRestore(); 340 341 bool shouldReloadToHandleUnreachableURL(DocumentLoader*); 342 343 void dispatchDidCommitLoad(); 344 345 void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL, AllowNavigationToInvalidURL); 346 347 void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL); // Calls continueLoadAfterNavigationPolicy 348 void load(DocumentLoader*); // Calls loadWithDocumentLoader 349 350 void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&, // Calls loadWithDocumentLoader 351 LockHistory, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL); 352 353 void loadPostRequest(const ResourceRequest&, const String& referrer, // Called by loadFrameRequest, calls loadWithNavigationAction 354 const String& frameName, LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL); 355 void loadURL(const URL&, const String& referrer, const String& frameName, // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate 356 LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL); 357 358 bool shouldReload(const URL& currentURL, const URL& destinationURL); 359 360 void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&); 361 362 void detachChildren(); 363 void closeAndRemoveChild(Frame*); 364 365 void loadInSameDocument(const URL&, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation); 366 367 void prepareForLoadStart(); 368 void provisionalLoadStarted(); 369 370 void willTransitionToCommitted(); 371 bool didOpenURL(); 372 373 void scheduleCheckCompleted(); 374 void scheduleCheckLoadComplete(); 375 void startCheckCompleteTimer(); 376 377 bool shouldTreatURLAsSameAsCurrent(const URL&) const; 378 379 void dispatchGlobalObjectAvailableInAllWorlds(); 380 381 Frame& m_frame; 382 FrameLoaderClient& m_client; 383 384 const std::unique_ptr<PolicyChecker> m_policyChecker; 385 const std::unique_ptr<HistoryController> m_history; 386 mutable ResourceLoadNotifier m_notifier; 387 const std::unique_ptr<SubframeLoader> m_subframeLoader; 388 mutable FrameLoaderStateMachine m_stateMachine; 389 const std::unique_ptr<IconController> m_icon; 390 mutable MixedContentChecker m_mixedContentChecker; 391 392 class FrameProgressTracker; 393 std::unique_ptr<FrameProgressTracker> m_progressTracker; 394 395 FrameState m_state; 396 FrameLoadType m_loadType; 397 398 // Document loaders for the three phases of frame loading. Note that while 399 // a new request is being loaded, the old document loader may still be referenced. 400 // E.g. while a new request is in the "policy" state, the old document loader may 401 // be consulted in particular as it makes sense to imply certain settings on the new loader. 402 RefPtr<DocumentLoader> m_documentLoader; 403 RefPtr<DocumentLoader> m_provisionalDocumentLoader; 404 RefPtr<DocumentLoader> m_policyDocumentLoader; 405 406 bool m_delegateIsHandlingProvisionalLoadError; 407 408 bool m_quickRedirectComing; 409 bool m_sentRedirectNotification; 410 bool m_inStopAllLoaders; 411 412 String m_outgoingReferrer; 413 414 bool m_isExecutingJavaScriptFormAction; 415 416 bool m_didCallImplicitClose; 417 bool m_wasUnloadEventEmitted; 418 PageDismissalType m_pageDismissalEventBeingDispatched; 419 bool m_isComplete; 420 421 RefPtr<SerializedScriptValue> m_pendingStateObject; 422 423 bool m_needsClear; 424 425 URL m_submittedFormURL; 426 427 Timer<FrameLoader> m_checkTimer; 428 bool m_shouldCallCheckCompleted; 429 bool m_shouldCallCheckLoadComplete; 430 431 Frame* m_opener; 432 HashSet<Frame*> m_openedFrames; 433 434 bool m_loadingFromCachedPage; 435 bool m_suppressOpenerInNewFrame; 436 437 bool m_currentNavigationHasShownBeforeUnloadConfirmPanel; 438 439 bool m_loadsSynchronously; 440 441 SandboxFlags m_forcedSandboxFlags; 442 443 RefPtr<FrameNetworkingContext> m_networkingContext; 444 445 URL m_previousURL; 446 RefPtr<HistoryItem> m_requestedHistoryItem; 447 std::unique_ptr<PageActivityAssertionToken> m_activityAssertion; 448}; 449 450// This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for 451// modal dialog creation. The lookupFrame is for looking up the frame name in case 452// the frame name references a frame different from the openerFrame, e.g. when it is 453// "_self" or "_parent". 454// 455// FIXME: Consider making this function part of an appropriate class (not FrameLoader) 456// and moving it to a more appropriate location. 457PassRefPtr<Frame> createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created); 458 459} // namespace WebCore 460 461#endif // FrameLoader_h 462