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