WebCore/loader/FrameLoader.h

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifndef FrameLoader_h
  31 #define FrameLoader_h
  32
  33 #include "CachePolicy.h"
  34 #include "FormState.h"
  35 #include "FrameLoaderTypes.h"
  36 #include "ResourceRequest.h"
  37 #include "Timer.h"
  38
  39 namespace WebCore {
  40
  41     class Archive;
  42     class AuthenticationChallenge;
  43     class CachedFrame;
  44     class CachedPage;
  45     class CachedResource;
  46     class Document;
  47     class DocumentLoader;
  48     class Element;
  49     class Event;
  50     class FormData;
  51     class Frame;
  52     class FrameLoaderClient;
  53     class HistoryItem;
  54     class HTMLAppletElement;
  55     class HTMLFormElement;
  56     class HTMLFrameOwnerElement;
  57     class IconLoader;
  58     class IntSize;
  59     class NavigationAction;
  60     class RenderPart;
  61     class ResourceError;
  62     class ResourceLoader;
  63     class ResourceResponse;
  64     class ScriptSourceCode;
  65     class ScriptValue;
  66     class SecurityOrigin;
  67     class SharedBuffer;
  68     class SubstituteData;
  69     class TextResourceDecoder;
  70     class Widget;
  71
  72     struct FormSubmission;
  73     struct FrameLoadRequest;
  74     struct ScheduledRedirection;
  75     struct WindowFeatures;
  76
  77     bool isBackForwardLoadType(FrameLoadType);
  78
  79     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
  80         const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
  81     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
  82         const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
  83     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
  84
  85     class PolicyCheck {
  86     public:
  87         PolicyCheck();
  88
  89         void clear();
  90         void set(const ResourceRequest&, PassRefPtr<FormState>,
  91             NavigationPolicyDecisionFunction, void* argument);
  92         void set(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName,
  93             NewWindowPolicyDecisionFunction, void* argument);
  94         void set(ContentPolicyDecisionFunction, void* argument);
  95
  96         const ResourceRequest& request() const { return m_request; }
  97         void clearRequest();
  98
  99         void call(bool shouldContinue);
 100         void call(PolicyAction);
 101         void cancel();
 102
 103     private:
 104         ResourceRequest m_request;
 105         RefPtr<FormState> m_formState;
 106         String m_frameName;
 107
 108         NavigationPolicyDecisionFunction m_navigationFunction;
 109         NewWindowPolicyDecisionFunction m_newWindowFunction;
 110         ContentPolicyDecisionFunction m_contentFunction;
 111         void* m_argument;
 112     };
 113
 114     class FrameLoader : Noncopyable {
 115     public:
 116         FrameLoader(Frame*, FrameLoaderClient*);
 117         ~FrameLoader();
 118
 119         void init();
 120
 121         Frame* frame() const { return m_frame; }
 122
 123         // FIXME: This is not cool, people. We should aim to consolidate these variety of loading related methods into a smaller set,
 124         // and try to reuse more of the same logic by extracting common code paths.
 125         void prepareForLoadStart();
 126         void setupForReplace();
 127         void setupForReplaceByMIMEType(const String& newMIMEType);
 128
 129         void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);         // Calls continueLoadAfterNavigationPolicy
 130         void load(DocumentLoader*);                                                                 // Calls loadWithDocumentLoader
 131
 132         void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,              // Calls loadWithDocumentLoader()
 133             bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
 134
 135         void loadPostRequest(const ResourceRequest&, const String& referrer,                        // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction
 136             const String& frameName, bool lockHistory, FrameLoadType, Event*, PassRefPtr<FormState>);
 137
 138         void loadURL(const KURL& newURL, const String& referrer, const String& frameName,           // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction or else dispatches to navigation policy delegate
 139             bool lockHistory, FrameLoadType, Event*, PassRefPtr<FormState>);
 140         void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
 141
 142         void loadFrameRequestWithFormAndValues(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,           // Called by submitForm, calls loadPostRequest()
 143             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
 144
 145         void load(const ResourceRequest&, bool lockHistory);                                                          // Called by WebFrame, calls (ResourceRequest, SubstituteData)
 146         void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                                   // Called both by WebFrame and internally, calls (DocumentLoader*)
 147         void load(const ResourceRequest&, const String& frameName, bool lockHistory);                                 // Called by WebPluginController
 148
 149         void loadArchive(PassRefPtr<Archive> archive);
 150
 151         // Returns true for any non-local URL. If Document parameter is supplied, its local load policy dictates,
 152         // otherwise if referrer is non-empty and represents a local file, then the local load is allowed.
 153         static bool canLoad(const KURL&, const String& referrer, const Document* theDocument = 0);
 154         static void reportLocalLoadFailed(Frame*, const String& url);
 155
 156         static bool shouldHideReferrer(const KURL& url, const String& referrer);
 157
 158         // Called by createWindow in JSDOMWindowBase.cpp, e.g. to fulfill a modal dialog creation
 159         Frame* createWindow(FrameLoader* frameLoaderForFrameLookup, const FrameLoadRequest&, const WindowFeatures&, bool& created);
 160
 161         unsigned long loadResourceSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>& data);
 162
 163         bool canHandleRequest(const ResourceRequest&);
 164
 165         // Also not cool.
 166         void stopAllLoaders();
 167         void stopForUserCancel(bool deferCheckLoadComplete = false);
 168
 169         bool isLoadingMainResource() const { return m_isLoadingMainResource; }
 170         bool isLoading() const;
 171         bool frameHasLoaded() const;
 172
 173         int numPendingOrLoadingRequests(bool recurse) const;
 174         String referrer() const;
 175         String outgoingReferrer() const;
 176         String outgoingOrigin() const;
 177         void loadEmptyDocumentSynchronously();
 178
 179         DocumentLoader* activeDocumentLoader() const;
 180         DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
 181         DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
 182         DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
 183         FrameState state() const { return m_state; }
 184         static double timeOfLastCompletedLoad();
 185
 186         bool shouldUseCredentialStorage(ResourceLoader*);
 187         void didReceiveAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
 188         void didCancelAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
 189
 190         void assignIdentifierToInitialRequest(unsigned long identifier, const ResourceRequest&);
 191         void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
 192         void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
 193         void didReceiveData(ResourceLoader*, const char*, int, int lengthReceived);
 194         void didFinishLoad(ResourceLoader*);
 195         void didFailToLoad(ResourceLoader*, const ResourceError&);
 196         const ResourceRequest& originalRequest() const;
 197         const ResourceRequest& initialRequest() const;
 198         void receivedMainResourceError(const ResourceError&, bool isComplete);
 199         void receivedData(const char*, int);
 200
 201         void handleFallbackContent();
 202         bool isStopping() const;
 203
 204         void finishedLoading();
 205
 206         ResourceError cancelledError(const ResourceRequest&) const;
 207         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
 208         ResourceError blockedError(const ResourceRequest&) const;
 209         ResourceError cannotShowURLError(const ResourceRequest&) const;
 210
 211         void cannotShowMIMEType(const ResourceResponse&);
 212         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
 213
 214         bool isHostedByObjectElement() const;
 215         bool isLoadingMainFrame() const;
 216         bool canShowMIMEType(const String& MIMEType) const;
 217         bool representationExistsForURLScheme(const String& URLScheme);
 218         String generatedMIMETypeForURLScheme(const String& URLScheme);
 219
 220         void notifyIconChanged();
 221
 222         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
 223         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
 224         void cancelContentPolicyCheck();
 225
 226         void reload(bool endToEndReload = false);
 227         void reloadWithOverrideEncoding(const String& overrideEncoding);
 228
 229         void didReceiveServerRedirectForProvisionalLoadForFrame();
 230         void finishedLoadingDocument(DocumentLoader*);
 231         void committedLoad(DocumentLoader*, const char*, int);
 232         bool isReplacing() const;
 233         void setReplacing();
 234         void revertToProvisional(DocumentLoader*);
 235         void setMainDocumentError(DocumentLoader*, const ResourceError&);
 236         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
 237         bool subframeIsLoading() const;
 238         void willChangeTitle(DocumentLoader*);
 239         void didChangeTitle(DocumentLoader*);
 240
 241         FrameLoadType loadType() const;
 242         CachePolicy cachePolicy() const;
 243
 244         void didFirstLayout();
 245         bool firstLayoutDone() const;
 246
 247         void didFirstVisuallyNonEmptyLayout();
 248
 249         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
 250         void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList, bool isJavaScriptFormAction);
 251         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
 252 #if ENABLE(WML)
 253         void setForceReloadWmlDeck(bool);
 254 #endif
 255
 256         bool isQuickRedirectComing() const;
 257
 258         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, int length, const ResourceError&);
 259         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
 260         void loadedResourceFromMemoryCache(const CachedResource*);
 261         void tellClientAboutPastMemoryCacheLoads();
 262
 263         void recursiveCheckLoadComplete();
 264         void checkLoadComplete();
 265         void detachFromParent();
 266         void detachChildren();
 267         void closeAndRemoveChild(Frame*);
 268
 269         void addExtraFieldsToSubresourceRequest(ResourceRequest&);
 270         void addExtraFieldsToMainResourceRequest(ResourceRequest&);
 271
 272         static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
 273
 274         FrameLoaderClient* client() const { return m_client; }
 275
 276         void setDefersLoading(bool);
 277
 278         void changeLocation(const String& url, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
 279         void changeLocation(const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
 280         void urlSelected(const ResourceRequest&, const String& target, Event*, bool lockHistory, bool lockBackForwardList, bool userGesture);
 281         void urlSelected(const FrameLoadRequest&, Event*, bool lockHistory, bool lockBackForwardList);
 282
 283         bool requestFrame(HTMLFrameOwnerElement*, const String& url, const AtomicString& frameName);
 284         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL&, const String& name, const String& referrer);
 285
 286         void submitForm(const char* action, const String& url, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, Event*, bool lockHistory, bool lockBackForwardList);
 287         void submitFormAgain();
 288         void submitForm(const FrameLoadRequest&, Event*, bool lockHistory, bool lockBackForwardList);
 289
 290         void stop();
 291         void stopLoading(bool sendUnload);
 292         bool closeURL();
 293
 294         void didExplicitOpen();
 295
 296         KURL iconURL();
 297         void commitIconURLToIconDatabase(const KURL&);
 298
 299         KURL baseURL() const;
 300         String baseTarget() const;
 301         KURL dataURLBaseFromRequest(const ResourceRequest& request) const;
 302
 303         bool isScheduledLocationChangePending() const { return m_scheduledRedirection && isLocationChange(*m_scheduledRedirection); }
 304         void scheduleHTTPRedirection(double delay, const String& url);
 305         void scheduleLocationChange(const String& url, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false);
 306         void scheduleRefresh(bool userGesture = false);
 307         void scheduleHistoryNavigation(int steps);
 308
 309         bool canGoBackOrForward(int distance) const;
 310         void goBackOrForward(int distance);
 311         int getHistoryLength();
 312         KURL historyURL(int distance);
 313
 314         void begin();
 315         void begin(const KURL&, bool dispatchWindowObjectAvailable = true, SecurityOrigin* forcedSecurityOrigin = 0);
 316
 317         void write(const char* str, int len = -1, bool flush = false);
 318         void write(const String&);
 319         void end();
 320         void endIfNotLoadingMainResource();
 321
 322         void setEncoding(const String& encoding, bool userChosen);
 323         String encoding() const;
 324
 325         // Returns true if url is a JavaScript URL.
 326         bool executeIfJavaScriptURL(const KURL& url, bool userGesture = false, bool replaceDocument = true);
 327
 328         ScriptValue executeScript(const ScriptSourceCode&);
 329         ScriptValue executeScript(const String& script, bool forceUserGesture = false);
 330
 331         void gotoAnchor();
 332         bool gotoAnchor(const String& name); // returns true if the anchor was found
 333         void scrollToAnchor(const KURL&);
 334
 335         void tokenizerProcessedData();
 336
 337         void handledOnloadEvents();
 338         String userAgent(const KURL&) const;
 339
 340         Widget* createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const HashMap<String, String>& args);
 341
 342         void dispatchWindowObjectAvailable();
 343         void dispatchDocumentElementAvailable();
 344         void restoreDocumentState();
 345
 346         Frame* opener();
 347         void setOpener(Frame*);
 348         bool openedByDOM() const;
 349         void setOpenedByDOM();
 350
 351         void provisionalLoadStarted();
 352
 353         bool userGestureHint();
 354
 355         void resetMultipleFormSubmissionProtection();
 356         void didNotOpenURL(const KURL&);
 357
 358         void addData(const char* bytes, int length);
 359
 360         bool canCachePage();
 361
 362         void checkCallImplicitClose();
 363         bool didOpenURL(const KURL&);
 364
 365         void frameDetached();
 366
 367         const KURL& url() const { return m_URL; }
 368
 369         void updateBaseURLForEmptyDocument();
 370
 371         void setResponseMIMEType(const String&);
 372         const String& responseMIMEType() const;
 373
 374         bool containsPlugins() const;
 375
 376         void loadDone();
 377         void finishedParsing();
 378         void checkCompleted();
 379         void scheduleCheckCompleted();
 380         void scheduleCheckLoadComplete();
 381
 382         void clearRecordedFormValues();
 383         void setFormAboutToBeSubmitted(PassRefPtr<HTMLFormElement> element);
 384         void recordFormValue(const String& name, const String& value);
 385
 386         bool isComplete() const;
 387
 388         bool requestObject(RenderPart* frame, const String& url, const AtomicString& frameName,
 389             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
 390
 391         KURL completeURL(const String& url);
 392
 393         KURL originalRequestURL() const;
 394
 395         void cancelAndClear();
 396
 397         void setTitle(const String&);
 398
 399         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
 400
 401         void commitProvisionalLoad(PassRefPtr<CachedPage>);
 402
 403         void goToItem(HistoryItem*, FrameLoadType);
 404         void saveDocumentAndScrollState();
 405         void saveScrollPositionAndViewStateToItem(HistoryItem*);
 406
 407         // FIXME: These accessors are here for a dwindling number of users in WebKit, WebFrame
 408         // being the primary one.  After they're no longer needed there, they can be removed!
 409         HistoryItem* currentHistoryItem();
 410         void setCurrentHistoryItem(PassRefPtr<HistoryItem>);
 411         void setProvisionalHistoryItem(PassRefPtr<HistoryItem>);
 412
 413         void continueLoadWithData(SharedBuffer*, const String& mimeType, const String& textEncoding, const KURL&);
 414
 415         enum LocalLoadPolicy {
 416           AllowLocalLoadsForAll,  // No restriction on local loads.
 417           AllowLocalLoadsForLocalAndSubstituteData,
 418           AllowLocalLoadsForLocalOnly,
 419         };
 420         static void setLocalLoadPolicy(LocalLoadPolicy);
 421         static bool restrictAccessToLocal();
 422         static bool allowSubstituteDataAccessToLocal();
 423
 424         static void registerURLSchemeAsLocal(const String&);
 425         static bool shouldTreatURLAsLocal(const String&);
 426         static bool shouldTreatURLSchemeAsLocal(const String&);
 427
 428         static void registerURLSchemeAsNoAccess(const String&);
 429         static bool shouldTreatURLSchemeAsNoAccess(const String&);
 430
 431         bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
 432
 433         void iconLoadDecisionAvailable();
 434
 435         bool shouldAllowNavigation(Frame* targetFrame) const;
 436         Frame* findFrameForNavigation(const AtomicString& name);
 437
 438         void startIconLoader();
 439
 440         void applyUserAgent(ResourceRequest& request);
 441
 442     private:
 443         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
 444         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
 445
 446         bool canCachePageContainingThisFrame();
 447 #ifndef NDEBUG
 448         void logCanCachePageDecision();
 449         bool logCanCacheFrameDecision(int indentLevel);
 450 #endif
 451
 452         void addBackForwardItemClippedAtTarget(bool doClip);
 453         void restoreScrollPositionAndViewState();
 454         void saveDocumentState();
 455         void loadItem(HistoryItem*, FrameLoadType);
 456         bool urlsMatchItem(HistoryItem*) const;
 457         void invalidateCurrentItemCachedPage();
 458         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
 459         bool childFramesMatchItem(HistoryItem*) const;
 460
 461         void updateHistoryForBackForwardNavigation();
 462         void updateHistoryForReload();
 463         void updateHistoryForStandardLoad();
 464         void updateHistoryForRedirectWithLockedBackForwardList();
 465         void updateHistoryForClientRedirect();
 466         void updateHistoryForCommit();
 467         void updateHistoryForAnchorScroll();
 468
 469         void redirectionTimerFired(Timer<FrameLoader>*);
 470         void checkCompletedTimerFired(Timer<FrameLoader>*);
 471         void checkLoadCompleteTimerFired(Timer<FrameLoader>*);
 472
 473         void cancelRedirection(bool newLoadInProgress = false);
 474
 475         void started();
 476
 477         void completed();
 478         void parentCompleted();
 479
 480         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
 481         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
 482         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
 483
 484         bool loadProvisionalItemFromCachedPage();
 485         void cachePageForHistoryItem(HistoryItem*);
 486
 487         void receivedFirstData();
 488
 489         void updatePolicyBaseURL();
 490         void setPolicyBaseURL(const KURL&);
 491
 492         void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
 493
 494         // Also not cool.
 495         void stopLoadingSubframes();
 496
 497         void clearProvisionalLoad();
 498         void markLoadComplete();
 499         void transitionToCommitted(PassRefPtr<CachedPage>);
 500         void frameLoadCompleted();
 501
 502         void mainReceivedError(const ResourceError&, bool isComplete);
 503
 504         void setLoadType(FrameLoadType);
 505
 506         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>,
 507                                    NavigationPolicyDecisionFunction, void* argument);
 508         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&,
 509                                   PassRefPtr<FormState>, const String& frameName);
 510
 511         void continueAfterNavigationPolicy(PolicyAction);
 512         void continueAfterNewWindowPolicy(PolicyAction);
 513         void continueAfterContentPolicy(PolicyAction);
 514         void continueLoadAfterWillSubmitForm(PolicyAction = PolicyUse);
 515
 516         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 517         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 518         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
 519         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
 520         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
 521         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
 522         bool shouldScrollToAnchor(bool isFormSubmission, FrameLoadType loadType, const KURL& url);
 523         void addHistoryItemForFragmentScroll();
 524
 525         void stopPolicyCheck();
 526
 527         void closeDocument();
 528
 529         void checkLoadCompleteForThisFrame();
 530
 531         void setDocumentLoader(DocumentLoader*);
 532         void setPolicyDocumentLoader(DocumentLoader*);
 533         void setProvisionalDocumentLoader(DocumentLoader*);
 534
 535         void setState(FrameState);
 536
 537         void closeOldDataSources();
 538         void open(CachedPage&);
 539         void open(CachedFrame&);
 540
 541         void updateHistoryAfterClientRedirect();
 542
 543         void clear(bool clearWindowProperties = true, bool clearScriptObjects = true);
 544
 545         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
 546         void handleUnimplementablePolicy(const ResourceError&);
 547
 548         void scheduleRedirection(ScheduledRedirection*);
 549         void startRedirectionTimer();
 550         void stopRedirectionTimer();
 551
 552         void dispatchDidCommitLoad();
 553         void dispatchAssignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&);
 554         void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse);
 555         void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&);
 556         void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int length);
 557         void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier);
 558
 559         static bool isLocationChange(const ScheduledRedirection&);
 560
 561         Frame* m_frame;
 562         FrameLoaderClient* m_client;
 563
 564         FrameState m_state;
 565         FrameLoadType m_loadType;
 566
 567         // Document loaders for the three phases of frame loading. Note that while
 568         // a new request is being loaded, the old document loader may still be referenced.
 569         // E.g. while a new request is in the "policy" state, the old document loader may
 570         // be consulted in particular as it makes sense to imply certain settings on the new loader.
 571         RefPtr<DocumentLoader> m_documentLoader;
 572         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
 573         RefPtr<DocumentLoader> m_policyDocumentLoader;
 574
 575         // This identifies the type of navigation action which prompted this load. Note
 576         // that WebKit conveys this value as the WebActionNavigationTypeKey value
 577         // on navigation action delegate callbacks.
 578         FrameLoadType m_policyLoadType;
 579         PolicyCheck m_policyCheck;
 580
 581         bool m_delegateIsHandlingProvisionalLoadError;
 582         bool m_delegateIsDecidingNavigationPolicy;
 583         bool m_delegateIsHandlingUnimplementablePolicy;
 584
 585         bool m_firstLayoutDone;
 586         bool m_quickRedirectComing;
 587         bool m_sentRedirectNotification;
 588         bool m_inStopAllLoaders;
 589         bool m_navigationDuringLoad;
 590
 591         String m_outgoingReferrer;
 592
 593         OwnPtr<FormSubmission> m_deferredFormSubmission;
 594
 595         bool m_isExecutingJavaScriptFormAction;
 596         bool m_isRunningScript;
 597
 598         String m_responseMIMEType;
 599
 600         bool m_didCallImplicitClose;
 601         bool m_wasUnloadEventEmitted;
 602         bool m_isComplete;
 603         bool m_isLoadingMainResource;
 604
 605         KURL m_URL;
 606         KURL m_workingURL;
 607
 608         OwnPtr<IconLoader> m_iconLoader;
 609         bool m_mayLoadIconLater;
 610
 611         bool m_cancellingWithLoadInProgress;
 612
 613         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
 614
 615         bool m_needsClear;
 616         bool m_receivedData;
 617
 618         bool m_encodingWasChosenByUser;
 619         String m_encoding;
 620         RefPtr<TextResourceDecoder> m_decoder;
 621
 622         bool m_containsPlugIns;
 623
 624         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
 625         HashMap<String, String> m_formValuesAboutToBeSubmitted;
 626         KURL m_submittedFormURL;
 627
 628         Timer<FrameLoader> m_redirectionTimer;
 629         Timer<FrameLoader> m_checkCompletedTimer;
 630         Timer<FrameLoader> m_checkLoadCompleteTimer;
 631
 632         Frame* m_opener;
 633         HashSet<Frame*> m_openedFrames;
 634
 635         bool m_openedByDOM;
 636
 637         bool m_creatingInitialEmptyDocument;
 638         bool m_isDisplayingInitialEmptyDocument;
 639         bool m_committedFirstRealDocumentLoad;
 640
 641         RefPtr<HistoryItem> m_currentHistoryItem;
 642         RefPtr<HistoryItem> m_previousHistoryItem;
 643         RefPtr<HistoryItem> m_provisionalHistoryItem;
 644
 645         bool m_didPerformFirstNavigation;
 646
 647 #ifndef NDEBUG
 648         bool m_didDispatchDidCommitLoad;
 649 #endif
 650
 651 #if ENABLE(WML)
 652         bool m_forceReloadWmlDeck;
 653 #endif
 654     };
 655
 656 } // namespace WebCore
 657
 658 #endif // FrameLoader_h