Source/WebCore/loader/FrameLoader.h

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