code.vuplus.com Git - vuplus_webkit/blob - 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  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1.  Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  * 2.  Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in the
  14  *     documentation and/or other materials provided with the distribution.
  15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  16  *     its contributors may be used to endorse or promote products derived
  17  *     from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef FrameLoader_h
  32 #define FrameLoader_h
  33
  34 #include "CachePolicy.h"
  35 #include "FrameLoaderStateMachine.h"
  36 #include "FrameLoaderTypes.h"
  37 #include "HistoryController.h"
  38 #include "IconController.h"
  39 #include "IconURL.h"
  40 #include "PolicyChecker.h"
  41 #include "ResourceHandle.h"
  42 #include "ResourceLoadNotifier.h"
  43 #include "SubframeLoader.h"
  44 #include "Timer.h"
  45 #include <wtf/Forward.h>
  46 #include <wtf/HashSet.h>
  47
  48 namespace WebCore {
  49
  50 class Archive;
  51 class CachedFrameBase;
  52 class CachedPage;
  53 class CachedResource;
  54 class Chrome;
  55 class DOMWrapperWorld;
  56 class DocumentLoader;
  57 class Event;
  58 class FormState;
  59 class FormSubmission;
  60 class FrameLoaderClient;
  61 class FrameNetworkingContext;
  62 class NavigationAction;
  63 class NetworkingContext;
  64 class Page;
  65 class ResourceError;
  66 class ResourceRequest;
  67 class ResourceResponse;
  68 class SecurityOrigin;
  69 class SerializedScriptValue;
  70 class StringWithDirection;
  71 class SubstituteData;
  72
  73 struct FrameLoadRequest;
  74 struct WindowFeatures;
  75
  76 bool isBackForwardLoadType(FrameLoadType);
  77
  78 class FrameLoader {
  79     WTF_MAKE_NONCOPYABLE(FrameLoader);
  80 public:
  81     FrameLoader(Frame*, FrameLoaderClient*);
  82     ~FrameLoader();
  83
  84     void init();
  85
  86     Frame* frame() const { return m_frame; }
  87
  88     PolicyChecker* policyChecker() const { return &m_policyChecker; }
  89     HistoryController* history() const { return &m_history; }
  90     ResourceLoadNotifier* notifier() const { return &m_notifer; }
  91     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
  92     IconController* icon() const { return &m_icon; }
  93
  94     void prepareForHistoryNavigation();
  95     void prepareForLoadStart();
  96     void setupForReplace();
  97
  98     // FIXME: These are all functions which start loads. We have too many.
  99     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
 100     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
 101         PassRefPtr<Event>, PassRefPtr<FormState>, ReferrerPolicy);
 102
 103     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
 104     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
 105     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
 106 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 107     void loadArchive(PassRefPtr<Archive>);
 108 #endif
 109     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
 110
 111     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
 112     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy);
 113     void submitForm(PassRefPtr<FormSubmission>);
 114
 115     void reload(bool endToEndReload = false);
 116     void reloadWithOverrideEncoding(const String& overrideEncoding);
 117
 118     void open(CachedFrameBase&);
 119     void loadItem(HistoryItem*, FrameLoadType);
 120
 121     static void reportLocalLoadFailed(Frame*, const String& url);
 122
 123     // FIXME: These are all functions which stop loads. We have too many.
 124     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
 125     void stopForUserCancel(bool deferCheckLoadComplete = false);
 126     void stop();
 127     void stopLoading(UnloadEventPolicy);
 128     bool closeURL();
 129     void cancelAndClear();
 130     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
 131
 132     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
 133     bool isLoading() const;
 134     bool frameHasLoaded() const;
 135     void transferLoadingResourcesFromPage(Page*);
 136     void dispatchTransferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*);
 137
 138     int numPendingOrLoadingRequests(bool recurse) const;
 139     String referrer() const;
 140     String outgoingReferrer() const;
 141     String outgoingOrigin() const;
 142
 143     DocumentLoader* activeDocumentLoader() const;
 144     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
 145     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
 146     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
 147     FrameState state() const { return m_state; }
 148     static double timeOfLastCompletedLoad();
 149
 150     const ResourceRequest& originalRequest() const;
 151     const ResourceRequest& initialRequest() const;
 152     void receivedMainResourceError(const ResourceError&, bool isComplete);
 153
 154     bool willLoadMediaElementURL(KURL&);
 155
 156     void handleFallbackContent();
 157
 158     void finishedLoading();
 159
 160     ResourceError cancelledError(const ResourceRequest&) const;
 161
 162     bool isHostedByObjectElement() const;
 163     bool isLoadingMainFrame() const;
 164
 165     void finishedLoadingDocument(DocumentLoader*);
 166     bool isReplacing() const;
 167     void setReplacing();
 168     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
 169     bool subframeIsLoading() const;
 170     void willChangeTitle(DocumentLoader*);
 171     void didChangeTitle(DocumentLoader*);
 172     void didChangeIcons(DocumentLoader*, IconType);
 173
 174     FrameLoadType loadType() const;
 175
 176     CachePolicy subresourceCachePolicy() const;
 177
 178     void didFirstLayout();
 179     void didFirstVisuallyNonEmptyLayout();
 180
 181     void loadedResourceFromMemoryCache(CachedResource*);
 182     void tellClientAboutPastMemoryCacheLoads();
 183
 184     void checkLoadComplete();
 185     void detachFromParent();
 186     void detachViewsAndDocumentLoader();
 187
 188     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
 189     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
 190
 191     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
 192
 193     FrameLoaderClient* client() const { return m_client; }
 194
 195     void setDefersLoading(bool);
 196
 197     void didExplicitOpen();
 198
 199     // Callbacks from DocumentWriter
 200     void didBeginDocument(bool dispatchWindowObjectAvailable);
 201     void didEndDocument();
 202     void willSetEncoding();
 203
 204     void handledOnloadEvents();
 205     String userAgent(const KURL&) const;
 206
 207     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
 208     void dispatchDidClearWindowObjectsInAllWorlds();
 209     void dispatchDocumentElementAvailable();
 210
 211     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
 212
 213     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
 214     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
 215     // The following sandbox flags will be forced, regardless of changes to
 216     // the sandbox attribute of any parent frames.
 217     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
 218
 219     // Mixed content related functions.
 220     static bool isMixedContent(SecurityOrigin* context, const KURL&);
 221     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
 222     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
 223
 224     Frame* opener();
 225     void setOpener(Frame*);
 226
 227     void resetMultipleFormSubmissionProtection();
 228
 229     void checkCallImplicitClose();
 230
 231     void frameDetached();
 232
 233     void setOutgoingReferrer(const KURL&);
 234
 235     void loadDone();
 236     void finishedParsing();
 237     void checkCompleted();
 238
 239     void checkDidPerformFirstNavigation();
 240
 241     bool isComplete() const;
 242
 243     void setTitle(const StringWithDirection&);
 244
 245     void commitProvisionalLoad();
 246
 247     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
 248
 249     bool shouldAllowNavigation(Frame* targetFrame) const;
 250     Frame* findFrameForNavigation(const AtomicString& name);
 251
 252     void applyUserAgent(ResourceRequest&);
 253
 254     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
 255
 256     void completed();
 257     bool allAncestorsAreComplete() const; // including this
 258     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
 259     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
 260
 261     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
 262     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
 263     // introduce a proper callback type for this function, we should make it private again.
 264     void continueLoadAfterWillSubmitForm();
 265
 266     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
 267
 268     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
 269
 270     bool quickRedirectComing() const { return m_quickRedirectComing; }
 271
 272     bool shouldClose();
 273
 274     void started();
 275
 276     enum PageDismissalType {
 277         NoDismissal = 0,
 278         BeforeUnloadDismissal = 1,
 279         PageHideDismissal = 2,
 280         UnloadDismissal = 3
 281     };
 282     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
 283
 284     NetworkingContext* networkingContext() const;
 285
 286 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 287     Archive* archive() const { return m_archive.get(); }
 288 #endif
 289
 290 private:
 291     bool allChildrenAreComplete() const; // immediate children, not all descendants
 292
 293     void checkTimerFired(Timer<FrameLoader>*);
 294
 295     void loadSameDocumentItem(HistoryItem*);
 296     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
 297
 298     void loadProvisionalItemFromCachedPage();
 299
 300     void receivedFirstData();
 301
 302     void updateFirstPartyForCookies();
 303     void setFirstPartyForCookies(const KURL&);
 304
 305     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
 306
 307     void clearProvisionalLoad();
 308     void transitionToCommitted(PassRefPtr<CachedPage>);
 309     void frameLoadCompleted();
 310
 311     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 312     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
 313     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 314
 315     bool fireBeforeUnloadEvent(Chrome*);
 316
 317     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 318     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
 319     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
 320
 321     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
 322
 323     void checkLoadCompleteForThisFrame();
 324
 325     void setDocumentLoader(DocumentLoader*);
 326     void setPolicyDocumentLoader(DocumentLoader*);
 327     void setProvisionalDocumentLoader(DocumentLoader*);
 328
 329     void setState(FrameState);
 330
 331     void closeOldDataSources();
 332     void prepareForCachedPageRestore();
 333
 334     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
 335
 336     void dispatchDidCommitLoad();
 337
 338     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
 339
 340     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
 341     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader
 342
 343     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
 344         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
 345
 346     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
 347         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
 348     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
 349         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
 350
 351     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
 352
 353     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
 354
 355     void detachChildren();
 356     void closeAndRemoveChild(Frame*);
 357
 358     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
 359
 360     void provisionalLoadStarted();
 361
 362     bool didOpenURL();
 363
 364     void scheduleCheckCompleted();
 365     void scheduleCheckLoadComplete();
 366     void startCheckCompleteTimer();
 367
 368     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
 369
 370     void updateSandboxFlags();
 371
 372     Frame* m_frame;
 373     FrameLoaderClient* m_client;
 374
 375     mutable PolicyChecker m_policyChecker;
 376     mutable HistoryController m_history;
 377     mutable ResourceLoadNotifier m_notifer;
 378     mutable SubframeLoader m_subframeLoader;
 379     mutable FrameLoaderStateMachine m_stateMachine;
 380     mutable IconController m_icon;
 381
 382     FrameState m_state;
 383     FrameLoadType m_loadType;
 384
 385     // Document loaders for the three phases of frame loading. Note that while
 386     // a new request is being loaded, the old document loader may still be referenced.
 387     // E.g. while a new request is in the "policy" state, the old document loader may
 388     // be consulted in particular as it makes sense to imply certain settings on the new loader.
 389     RefPtr<DocumentLoader> m_documentLoader;
 390     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
 391     RefPtr<DocumentLoader> m_policyDocumentLoader;
 392
 393     bool m_delegateIsHandlingProvisionalLoadError;
 394
 395     bool m_quickRedirectComing;
 396     bool m_sentRedirectNotification;
 397     bool m_inStopAllLoaders;
 398
 399     String m_outgoingReferrer;
 400
 401     bool m_isExecutingJavaScriptFormAction;
 402
 403     bool m_didCallImplicitClose;
 404     bool m_wasUnloadEventEmitted;
 405     PageDismissalType m_pageDismissalEventBeingDispatched;
 406     bool m_isComplete;
 407     bool m_isLoadingMainResource;
 408
 409     RefPtr<SerializedScriptValue> m_pendingStateObject;
 410
 411     bool m_hasReceivedFirstData;
 412
 413     bool m_needsClear;
 414
 415     KURL m_submittedFormURL;
 416
 417     Timer<FrameLoader> m_checkTimer;
 418     bool m_shouldCallCheckCompleted;
 419     bool m_shouldCallCheckLoadComplete;
 420
 421     Frame* m_opener;
 422     HashSet<Frame*> m_openedFrames;
 423
 424     bool m_didPerformFirstNavigation;
 425     bool m_loadingFromCachedPage;
 426     bool m_suppressOpenerInNewFrame;
 427
 428     SandboxFlags m_sandboxFlags;
 429     SandboxFlags m_forcedSandboxFlags;
 430
 431     RefPtr<FrameNetworkingContext> m_networkingContext;
 432
 433 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 434     RefPtr<Archive> m_archive;
 435 #endif
 436
 437     KURL m_previousUrl;
 438 };
 439
 440 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
 441 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
 442 // the frame name references a frame different from the openerFrame, e.g. when it is
 443 // "_self" or "_parent".
 444 //
 445 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
 446 // and moving it to a more appropriate location.
 447 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
 448
 449 } // namespace WebCore
 450
 451 #endif // FrameLoader_h