cb1235e486e0144ae681a61c4f4c76968870412e
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
4  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
5  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
6  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
7  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
8  * Copyright (C) 2011 Google Inc. All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * 1.  Redistributions of source code must retain the above copyright
15  *     notice, this list of conditions and the following disclaimer. 
16  * 2.  Redistributions in binary form must reproduce the above copyright
17  *     notice, this list of conditions and the following disclaimer in the
18  *     documentation and/or other materials provided with the distribution. 
19  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
20  *     its contributors may be used to endorse or promote products derived
21  *     from this software without specific prior written permission. 
22  *
23  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
24  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
27  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
30  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #include "config.h"
36 #include "FrameLoader.h"
37
38 #include "AXObjectCache.h"
39 #include "ApplicationCacheHost.h"
40 #include "BackForwardController.h"
41 #include "BeforeUnloadEvent.h"
42 #include "MemoryCache.h"
43 #include "CachedPage.h"
44 #include "CachedResourceLoader.h"
45 #include "Chrome.h"
46 #include "ChromeClient.h"
47 #include "Console.h"
48 #include "ContentSecurityPolicy.h"
49 #include "DatabaseContext.h"
50 #include "DOMImplementation.h"
51 #include "DOMWindow.h"
52 #include "Document.h"
53 #include "DocumentLoadTiming.h"
54 #include "DocumentLoader.h"
55 #include "Editor.h"
56 #include "EditorClient.h"
57 #include "Element.h"
58 #include "Event.h"
59 #include "EventNames.h"
60 #include "FloatRect.h"
61 #include "FormState.h"
62 #include "FormSubmission.h"
63 #include "Frame.h"
64 #include "FrameLoadRequest.h"
65 #include "FrameLoaderClient.h"
66 #include "FrameNetworkingContext.h"
67 #include "FrameTree.h"
68 #include "FrameView.h"
69 #include "HTMLAnchorElement.h"
70 #include "HTMLFormElement.h"
71 #include "HTMLInputElement.h"
72 #include "HTMLNames.h"
73 #include "HTMLObjectElement.h"
74 #include "HTMLParserIdioms.h"
75 #include "HTTPParsers.h"
76 #include "HistoryItem.h"
77 #include "InspectorController.h"
78 #include "InspectorInstrumentation.h"
79 #include "Logging.h"
80 #include "MIMETypeRegistry.h"
81 #include "MainResourceLoader.h"
82 #include "Page.h"
83 #include "PageCache.h"
84 #include "PageTransitionEvent.h"
85 #include "PluginData.h"
86 #include "PluginDatabase.h"
87 #include "PluginDocument.h"
88 #include "ProgressTracker.h"
89 #include "ResourceHandle.h"
90 #include "ResourceRequest.h"
91 #include "SchemeRegistry.h"
92 #include "ScriptCallStack.h"
93 #include "ScriptController.h"
94 #include "ScriptSourceCode.h"
95 #include "ScrollAnimator.h"
96 #include "SecurityOrigin.h"
97 #include "SecurityPolicy.h"
98 #include "SegmentedString.h"
99 #include "SerializedScriptValue.h"
100 #include "Settings.h"
101 #include "TextResourceDecoder.h"
102 #include "WebCoreMemoryInstrumentation.h"
103 #include "WindowFeatures.h"
104 #include "XMLDocumentParser.h"
105 #include <wtf/CurrentTime.h>
106 #include <wtf/MemoryInstrumentationHashSet.h>
107 #include <wtf/StdLibExtras.h>
108 #include <wtf/text/CString.h>
109 #include <wtf/text/WTFString.h>
110
111 #if ENABLE(SHARED_WORKERS)
112 #include "SharedWorkerRepository.h"
113 #endif
114
115 #if ENABLE(SVG)
116 #include "SVGDocument.h"
117 #include "SVGLocatable.h"
118 #include "SVGNames.h"
119 #include "SVGPreserveAspectRatio.h"
120 #include "SVGSVGElement.h"
121 #include "SVGViewElement.h"
122 #include "SVGViewSpec.h"
123 #endif
124
125 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
126 #include "Archive.h"
127 #endif
128
129
130 namespace WebCore {
131
132 using namespace HTMLNames;
133
134 #if ENABLE(SVG)
135 using namespace SVGNames;
136 #endif
137
138 static const char defaultAcceptHeader[] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
139 static double storedTimeOfLastCompletedLoad;
140
141 bool isBackForwardLoadType(FrameLoadType type)
142 {
143     switch (type) {
144         case FrameLoadTypeStandard:
145         case FrameLoadTypeReload:
146         case FrameLoadTypeReloadFromOrigin:
147         case FrameLoadTypeSame:
148         case FrameLoadTypeRedirectWithLockedBackForwardList:
149         case FrameLoadTypeReplace:
150             return false;
151         case FrameLoadTypeBack:
152         case FrameLoadTypeForward:
153         case FrameLoadTypeIndexedBackForward:
154             return true;
155     }
156     ASSERT_NOT_REACHED();
157     return false;
158 }
159
160 // This is not in the FrameLoader class to emphasize that it does not depend on
161 // private FrameLoader data, and to avoid increasing the number of public functions
162 // with access to private data.  Since only this .cpp file needs it, making it
163 // non-member lets us exclude it from the header file, thus keeping FrameLoader.h's
164 // API simpler.
165 //
166 static bool isDocumentSandboxed(Frame* frame, SandboxFlags mask)
167 {
168     return frame->document() && frame->document()->isSandboxed(mask);
169 }
170
171 class FrameLoader::FrameProgressTracker {
172 public:
173     static PassOwnPtr<FrameProgressTracker> create(Frame* frame) { return adoptPtr(new FrameProgressTracker(frame)); }
174     ~FrameProgressTracker()
175     {
176         ASSERT(!m_inProgress || m_frame->page());
177         if (m_inProgress)
178             m_frame->page()->progress()->progressCompleted(m_frame);
179     }
180
181     void progressStarted()
182     {
183         ASSERT(m_frame->page());
184         if (!m_inProgress)
185             m_frame->page()->progress()->progressStarted(m_frame);
186         m_inProgress = true;
187     }
188
189     void progressCompleted()
190     {
191         ASSERT(m_inProgress);
192         ASSERT(m_frame->page());
193         m_inProgress = false;
194         m_frame->page()->progress()->progressCompleted(m_frame);
195     }
196
197 private:
198     FrameProgressTracker(Frame* frame)
199         : m_frame(frame)
200         , m_inProgress(false)
201     {
202     }
203
204     Frame* m_frame;
205     bool m_inProgress;
206 };
207
208 FrameLoader::FrameLoader(Frame* frame, FrameLoaderClient* client)
209     : m_frame(frame)
210     , m_client(client)
211     , m_policyChecker(frame)
212     , m_history(frame)
213     , m_notifer(frame)
214     , m_subframeLoader(frame)
215     , m_icon(frame)
216     , m_mixedContentChecker(frame)
217     , m_state(FrameStateCommittedPage)
218     , m_loadType(FrameLoadTypeStandard)
219     , m_delegateIsHandlingProvisionalLoadError(false)
220     , m_quickRedirectComing(false)
221     , m_sentRedirectNotification(false)
222     , m_inStopAllLoaders(false)
223     , m_isExecutingJavaScriptFormAction(false)
224     , m_didCallImplicitClose(false)
225     , m_wasUnloadEventEmitted(false)
226     , m_pageDismissalEventBeingDispatched(NoDismissal)
227     , m_isComplete(false)
228     , m_needsClear(false)
229     , m_checkTimer(this, &FrameLoader::checkTimerFired)
230     , m_shouldCallCheckCompleted(false)
231     , m_shouldCallCheckLoadComplete(false)
232     , m_opener(0)
233     , m_didPerformFirstNavigation(false)
234     , m_loadingFromCachedPage(false)
235     , m_suppressOpenerInNewFrame(false)
236     , m_forcedSandboxFlags(SandboxNone)
237 {
238 }
239
240 FrameLoader::~FrameLoader()
241 {
242     setOpener(0);
243
244     HashSet<Frame*>::iterator end = m_openedFrames.end();
245     for (HashSet<Frame*>::iterator it = m_openedFrames.begin(); it != end; ++it)
246         (*it)->loader()->m_opener = 0;
247
248     m_client->frameLoaderDestroyed();
249
250     if (m_networkingContext)
251         m_networkingContext->invalidate();
252 }
253
254 void FrameLoader::init()
255 {
256     // This somewhat odd set of steps gives the frame an initial empty document.
257     // It would be better if this could be done with even fewer steps.
258     m_stateMachine.advanceTo(FrameLoaderStateMachine::CreatingInitialEmptyDocument);
259     setPolicyDocumentLoader(m_client->createDocumentLoader(ResourceRequest(KURL(ParsedURLString, emptyString())), SubstituteData()).get());
260     setProvisionalDocumentLoader(m_policyDocumentLoader.get());
261     setState(FrameStateProvisional);
262     m_provisionalDocumentLoader->setResponse(ResourceResponse(KURL(), "text/html", 0, String(), String()));
263     m_provisionalDocumentLoader->finishedLoading();
264     ASSERT(!m_frame->document());
265     m_documentLoader->writer()->begin(KURL(), false);
266     m_documentLoader->writer()->end();
267     m_frame->document()->cancelParsing();
268     m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocument);
269     m_didCallImplicitClose = true;
270
271     m_networkingContext = m_client->createNetworkingContext();
272     m_progressTracker = FrameProgressTracker::create(m_frame);
273 }
274
275 void FrameLoader::setDefersLoading(bool defers)
276 {
277     if (m_documentLoader)
278         m_documentLoader->setDefersLoading(defers);
279     if (m_provisionalDocumentLoader)
280         m_provisionalDocumentLoader->setDefersLoading(defers);
281     if (m_policyDocumentLoader)
282         m_policyDocumentLoader->setDefersLoading(defers);
283     history()->setDefersLoading(defers);
284
285     if (!defers) {
286         m_frame->navigationScheduler()->startTimer();
287         startCheckCompleteTimer();
288     }
289 }
290
291 void FrameLoader::changeLocation(SecurityOrigin* securityOrigin, const KURL& url, const String& referrer, bool lockHistory, bool lockBackForwardList, bool refresh)
292 {
293     urlSelected(FrameLoadRequest(securityOrigin, ResourceRequest(url, referrer, refresh ? ReloadIgnoringCacheData : UseProtocolCachePolicy), "_self"),
294         0, lockHistory, lockBackForwardList, MaybeSendReferrer, ReplaceDocumentIfJavaScriptURL);
295 }
296
297 void FrameLoader::urlSelected(const KURL& url, const String& passedTarget, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer shouldSendReferrer)
298 {
299     urlSelected(FrameLoadRequest(m_frame->document()->securityOrigin(), ResourceRequest(url), passedTarget),
300         triggeringEvent, lockHistory, lockBackForwardList, shouldSendReferrer, DoNotReplaceDocumentIfJavaScriptURL);
301 }
302
303 // The shouldReplaceDocumentIfJavaScriptURL parameter will go away when the FIXME to eliminate the
304 // corresponding parameter from ScriptController::executeIfJavaScriptURL() is addressed.
305 void FrameLoader::urlSelected(const FrameLoadRequest& passedRequest, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer shouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL)
306 {
307     ASSERT(!m_suppressOpenerInNewFrame);
308
309     RefPtr<Frame> protect(m_frame);
310     FrameLoadRequest frameRequest(passedRequest);
311
312     if (m_frame->script()->executeIfJavaScriptURL(frameRequest.resourceRequest().url(), shouldReplaceDocumentIfJavaScriptURL))
313         return;
314
315     if (frameRequest.frameName().isEmpty())
316         frameRequest.setFrameName(m_frame->document()->baseTarget());
317
318     if (shouldSendReferrer == NeverSendReferrer)
319         m_suppressOpenerInNewFrame = true;
320     if (frameRequest.resourceRequest().httpReferrer().isEmpty())
321         frameRequest.resourceRequest().setHTTPReferrer(outgoingReferrer());
322     addHTTPOriginIfNeeded(frameRequest.resourceRequest(), outgoingOrigin());
323
324     loadFrameRequest(frameRequest, lockHistory, lockBackForwardList, triggeringEvent, 0, shouldSendReferrer);
325
326     m_suppressOpenerInNewFrame = false;
327 }
328
329 void FrameLoader::submitForm(PassRefPtr<FormSubmission> submission)
330 {
331     ASSERT(submission->method() == FormSubmission::PostMethod || submission->method() == FormSubmission::GetMethod);
332
333     // FIXME: Find a good spot for these.
334     ASSERT(submission->data());
335     ASSERT(submission->state());
336     ASSERT(!submission->state()->sourceDocument()->frame() || submission->state()->sourceDocument()->frame() == m_frame);
337     
338     if (!m_frame->page())
339         return;
340     
341     if (submission->action().isEmpty())
342         return;
343
344     if (isDocumentSandboxed(m_frame, SandboxForms))
345         return;
346
347     if (protocolIsJavaScript(submission->action())) {
348         if (!m_frame->document()->contentSecurityPolicy()->allowFormAction(KURL(submission->action())))
349             return;
350         m_isExecutingJavaScriptFormAction = true;
351         m_frame->script()->executeIfJavaScriptURL(submission->action(), DoNotReplaceDocumentIfJavaScriptURL);
352         m_isExecutingJavaScriptFormAction = false;
353         return;
354     }
355
356     Frame* targetFrame = findFrameForNavigation(submission->target(), submission->state()->sourceDocument());
357     if (!targetFrame) {
358         if (!DOMWindow::allowPopUp(m_frame) && !ScriptController::processingUserGesture())
359             return;
360
361         targetFrame = m_frame;
362     } else
363         submission->clearTarget();
364
365     if (!targetFrame->page())
366         return;
367
368     // FIXME: We'd like to remove this altogether and fix the multiple form submission issue another way.
369
370     // We do not want to submit more than one form from the same page, nor do we want to submit a single
371     // form more than once. This flag prevents these from happening; not sure how other browsers prevent this.
372     // The flag is reset in each time we start handle a new mouse or key down event, and
373     // also in setView since this part may get reused for a page from the back/forward cache.
374     // The form multi-submit logic here is only needed when we are submitting a form that affects this frame.
375
376     // FIXME: Frame targeting is only one of the ways the submission could end up doing something other
377     // than replacing this frame's content, so this check is flawed. On the other hand, the check is hardly
378     // needed any more now that we reset m_submittedFormURL on each mouse or key down event.
379
380     if (m_frame->tree()->isDescendantOf(targetFrame)) {
381         if (m_submittedFormURL == submission->requestURL())
382             return;
383         m_submittedFormURL = submission->requestURL();
384     }
385
386     submission->data()->generateFiles(m_frame->document());
387     submission->setReferrer(outgoingReferrer());
388     submission->setOrigin(outgoingOrigin());
389
390     targetFrame->navigationScheduler()->scheduleFormSubmission(submission);
391 }
392
393 void FrameLoader::stopLoading(UnloadEventPolicy unloadEventPolicy)
394 {
395     if (m_frame->document() && m_frame->document()->parser())
396         m_frame->document()->parser()->stopParsing();
397
398     if (unloadEventPolicy != UnloadEventPolicyNone) {
399         if (m_frame->document()) {
400             if (m_didCallImplicitClose && !m_wasUnloadEventEmitted) {
401                 Node* currentFocusedNode = m_frame->document()->focusedNode();
402                 if (currentFocusedNode && currentFocusedNode->toInputElement())
403                     currentFocusedNode->toInputElement()->endEditing();
404                 if (m_pageDismissalEventBeingDispatched == NoDismissal) {
405                     if (unloadEventPolicy == UnloadEventPolicyUnloadAndPageHide) {
406                         m_pageDismissalEventBeingDispatched = PageHideDismissal;
407                         m_frame->document()->domWindow()->dispatchEvent(PageTransitionEvent::create(eventNames().pagehideEvent, m_frame->document()->inPageCache()), m_frame->document());
408                     }
409                     if (!m_frame->document()->inPageCache()) {
410                         RefPtr<Event> unloadEvent(Event::create(eventNames().unloadEvent, false, false));
411                         // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed
412                         // while dispatching the event, so protect it to prevent writing the end
413                         // time into freed memory.
414                         RefPtr<DocumentLoader> documentLoader = m_provisionalDocumentLoader;
415                         m_pageDismissalEventBeingDispatched = UnloadDismissal;
416                         if (documentLoader && !documentLoader->timing()->unloadEventStart() && !documentLoader->timing()->unloadEventEnd()) {
417                             DocumentLoadTiming* timing = documentLoader->timing();
418                             ASSERT(timing->navigationStart());
419                             timing->markUnloadEventStart();
420                             m_frame->document()->domWindow()->dispatchEvent(unloadEvent, m_frame->document());
421                             timing->markUnloadEventEnd();
422                         } else
423                             m_frame->document()->domWindow()->dispatchEvent(unloadEvent, m_frame->document());
424                     }
425                 }
426                 m_pageDismissalEventBeingDispatched = NoDismissal;
427                 if (m_frame->document())
428                     m_frame->document()->updateStyleIfNeeded();
429                 m_wasUnloadEventEmitted = true;
430             }
431         }
432
433         // Dispatching the unload event could have made m_frame->document() null.
434         if (m_frame->document() && !m_frame->document()->inPageCache()) {
435             // Don't remove event listeners from a transitional empty document (see bug 28716 for more information).
436             bool keepEventListeners = m_stateMachine.isDisplayingInitialEmptyDocument() && m_provisionalDocumentLoader
437                 && m_frame->document()->isSecureTransitionTo(m_provisionalDocumentLoader->url());
438
439             if (!keepEventListeners)
440                 m_frame->document()->removeAllEventListeners();
441         }
442     }
443
444     m_isComplete = true; // to avoid calling completed() in finishedParsing()
445     m_didCallImplicitClose = true; // don't want that one either
446
447     if (m_frame->document() && m_frame->document()->parsing()) {
448         finishedParsing();
449         m_frame->document()->setParsing(false);
450     }
451
452     if (Document* doc = m_frame->document()) {
453         // FIXME: HTML5 doesn't tell us to set the state to complete when aborting, but we do anyway to match legacy behavior.
454         // http://www.w3.org/Bugs/Public/show_bug.cgi?id=10537
455         doc->setReadyState(Document::Complete);
456
457 #if ENABLE(SQL_DATABASE)
458         // FIXME: Should the DatabaseContext watch for something like ActiveDOMObject::stop() rather than being special-cased here?
459         DatabaseContext::stopDatabases(doc, 0);
460 #endif
461     }
462
463     // FIXME: This will cancel redirection timer, which really needs to be restarted when restoring the frame from b/f cache.
464     m_frame->navigationScheduler()->cancel();
465 }
466
467 void FrameLoader::stop()
468 {
469     // http://bugs.webkit.org/show_bug.cgi?id=10854
470     // The frame's last ref may be removed and it will be deleted by checkCompleted().
471     RefPtr<Frame> protector(m_frame);
472
473     if (DocumentParser* parser = m_frame->document()->parser()) {
474         parser->stopParsing();
475         parser->finish();
476     }
477     
478     icon()->stopLoader();
479 }
480
481 bool FrameLoader::closeURL()
482 {
483     history()->saveDocumentState();
484     
485     // Should only send the pagehide event here if the current document exists and has not been placed in the page cache.    
486     Document* currentDocument = m_frame->document();
487     stopLoading(currentDocument && !currentDocument->inPageCache() ? UnloadEventPolicyUnloadAndPageHide : UnloadEventPolicyUnloadOnly);
488     
489     m_frame->editor()->clearUndoRedoOperations();
490     return true;
491 }
492
493 bool FrameLoader::didOpenURL()
494 {
495     if (m_frame->navigationScheduler()->redirectScheduledDuringLoad()) {
496         // A redirect was scheduled before the document was created.
497         // This can happen when one frame changes another frame's location.
498         return false;
499     }
500
501     m_frame->navigationScheduler()->cancel();
502     m_frame->editor()->clearLastEditCommand();
503
504     m_isComplete = false;
505     m_didCallImplicitClose = false;
506
507     // If we are still in the process of initializing an empty document then
508     // its frame is not in a consistent state for rendering, so avoid setJSStatusBarText
509     // since it may cause clients to attempt to render the frame.
510     if (!m_stateMachine.creatingInitialEmptyDocument()) {
511         DOMWindow* window = m_frame->document()->domWindow();
512         window->setStatus(String());
513         window->setDefaultStatus(String());
514     }
515
516     started();
517
518     return true;
519 }
520
521 void FrameLoader::didExplicitOpen()
522 {
523     m_isComplete = false;
524     m_didCallImplicitClose = false;
525
526     // Calling document.open counts as committing the first real document load.
527     if (!m_stateMachine.committedFirstRealDocumentLoad())
528         m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocumentPostCommit);
529     
530     // Prevent window.open(url) -- eg window.open("about:blank") -- from blowing away results
531     // from a subsequent window.document.open / window.document.write call. 
532     // Canceling redirection here works for all cases because document.open 
533     // implicitly precedes document.write.
534     m_frame->navigationScheduler()->cancel();
535 }
536
537
538 void FrameLoader::cancelAndClear()
539 {
540     m_frame->navigationScheduler()->cancel();
541
542     if (!m_isComplete)
543         closeURL();
544
545     clear(m_frame->document(), false);
546     m_frame->script()->updatePlatformScriptObjects();
547 }
548
549 void FrameLoader::clear(Document* newDocument, bool clearWindowProperties, bool clearScriptObjects, bool clearFrameView)
550 {
551     m_frame->editor()->clear();
552
553     if (!m_needsClear)
554         return;
555     m_needsClear = false;
556     
557     if (!m_frame->document()->inPageCache()) {
558         m_frame->document()->cancelParsing();
559         m_frame->document()->stopActiveDOMObjects();
560         if (m_frame->document()->attached()) {
561             m_frame->document()->prepareForDestruction();
562             m_frame->document()->removeFocusedNodeOfSubtree(m_frame->document());
563         }
564     }
565
566     // Do this after detaching the document so that the unload event works.
567     if (clearWindowProperties) {
568         InspectorInstrumentation::frameWindowDiscarded(m_frame, m_frame->document()->domWindow());
569         m_frame->document()->domWindow()->resetUnlessSuspendedForPageCache();
570         m_frame->script()->clearWindowShell(newDocument->domWindow(), m_frame->document()->inPageCache());
571     }
572
573     m_frame->selection()->prepareForDestruction();
574     m_frame->eventHandler()->clear();
575     if (clearFrameView && m_frame->view())
576         m_frame->view()->clear();
577
578     // Do not drop the document before the ScriptController and view are cleared
579     // as some destructors might still try to access the document.
580     m_frame->setDocument(0);
581
582     m_subframeLoader.clear();
583
584     if (clearScriptObjects)
585         m_frame->script()->clearScriptObjects();
586
587     m_frame->script()->enableEval();
588
589     m_frame->navigationScheduler()->clear();
590
591     m_checkTimer.stop();
592     m_shouldCallCheckCompleted = false;
593     m_shouldCallCheckLoadComplete = false;
594
595     if (m_stateMachine.isDisplayingInitialEmptyDocument() && m_stateMachine.committedFirstRealDocumentLoad())
596         m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
597 }
598
599 void FrameLoader::receivedFirstData()
600 {
601     dispatchDidCommitLoad();
602     dispatchDidClearWindowObjectsInAllWorlds();
603     dispatchGlobalObjectAvailableInAllWorlds();
604
605     if (m_documentLoader) {
606         StringWithDirection ptitle = m_documentLoader->title();
607         // If we have a title let the WebView know about it.
608         if (!ptitle.isNull())
609             m_client->dispatchDidReceiveTitle(ptitle);
610     }
611
612     if (!m_documentLoader)
613         return;
614     if (m_frame->document()->isViewSource())
615         return;
616
617     double delay;
618     String url;
619     if (!parseHTTPRefresh(m_documentLoader->response().httpHeaderField("Refresh"), false, delay, url))
620         return;
621     if (url.isEmpty())
622         url = m_frame->document()->url().string();
623     else
624         url = m_frame->document()->completeURL(url).string();
625
626     m_frame->navigationScheduler()->scheduleRedirect(delay, url);
627 }
628
629 void FrameLoader::setOutgoingReferrer(const KURL& url)
630 {
631     m_outgoingReferrer = url.strippedForUseAsReferrer();
632 }
633
634 void FrameLoader::didBeginDocument(bool dispatch)
635 {
636     m_needsClear = true;
637     m_isComplete = false;
638     m_didCallImplicitClose = false;
639     m_frame->document()->setReadyState(Document::Loading);
640
641     if (m_pendingStateObject) {
642         m_frame->document()->statePopped(m_pendingStateObject.get());
643         m_pendingStateObject.clear();
644     }
645
646     if (dispatch)
647         dispatchDidClearWindowObjectsInAllWorlds();
648
649     updateFirstPartyForCookies();
650     m_frame->document()->initContentSecurityPolicy();
651
652     Settings* settings = m_frame->document()->settings();
653     if (settings) {
654         m_frame->document()->cachedResourceLoader()->setImagesEnabled(settings->areImagesEnabled());
655         m_frame->document()->cachedResourceLoader()->setAutoLoadImages(settings->loadsImagesAutomatically());
656     }
657
658     if (m_documentLoader) {
659         String dnsPrefetchControl = m_documentLoader->response().httpHeaderField("X-DNS-Prefetch-Control");
660         if (!dnsPrefetchControl.isEmpty())
661             m_frame->document()->parseDNSPrefetchControlHeader(dnsPrefetchControl);
662
663         String policyValue = m_documentLoader->response().httpHeaderField("Content-Security-Policy");
664         if (!policyValue.isEmpty())
665             m_frame->document()->contentSecurityPolicy()->didReceiveHeader(policyValue, ContentSecurityPolicy::EnforceStableDirectives);
666
667         policyValue = m_documentLoader->response().httpHeaderField("Content-Security-Policy-Report-Only");
668         if (!policyValue.isEmpty())
669             m_frame->document()->contentSecurityPolicy()->didReceiveHeader(policyValue, ContentSecurityPolicy::ReportStableDirectives);
670
671         policyValue = m_documentLoader->response().httpHeaderField("X-WebKit-CSP");
672         if (!policyValue.isEmpty())
673             m_frame->document()->contentSecurityPolicy()->didReceiveHeader(policyValue, ContentSecurityPolicy::EnforceAllDirectives);
674
675         policyValue = m_documentLoader->response().httpHeaderField("X-WebKit-CSP-Report-Only");
676         if (!policyValue.isEmpty())
677             m_frame->document()->contentSecurityPolicy()->didReceiveHeader(policyValue, ContentSecurityPolicy::ReportAllDirectives);
678
679         String headerContentLanguage = m_documentLoader->response().httpHeaderField("Content-Language");
680         if (!headerContentLanguage.isEmpty()) {
681             size_t commaIndex = headerContentLanguage.find(',');
682             headerContentLanguage.truncate(commaIndex); // notFound == -1 == don't truncate
683             headerContentLanguage = headerContentLanguage.stripWhiteSpace(isHTMLSpace);
684             if (!headerContentLanguage.isEmpty())
685                 m_frame->document()->setContentLanguage(headerContentLanguage);
686         }
687     }
688
689     history()->restoreDocumentState();
690 }
691
692 void FrameLoader::finishedParsing()
693 {
694     m_frame->injectUserScripts(InjectAtDocumentEnd);
695
696     if (m_stateMachine.creatingInitialEmptyDocument())
697         return;
698
699     // This can be called from the Frame's destructor, in which case we shouldn't protect ourselves
700     // because doing so will cause us to re-enter the destructor when protector goes out of scope.
701     // Null-checking the FrameView indicates whether or not we're in the destructor.
702     RefPtr<Frame> protector = m_frame->view() ? m_frame : 0;
703
704     m_client->dispatchDidFinishDocumentLoad();
705
706     checkCompleted();
707
708     if (!m_frame->view())
709         return; // We are being destroyed by something checkCompleted called.
710
711     // Check if the scrollbars are really needed for the content.
712     // If not, remove them, relayout, and repaint.
713     m_frame->view()->restoreScrollbar();
714     scrollToFragmentWithParentBoundary(m_frame->document()->url());
715 }
716
717 void FrameLoader::loadDone()
718 {
719     checkCompleted();
720 }
721
722 bool FrameLoader::allChildrenAreComplete() const
723 {
724     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
725         if (!child->loader()->m_isComplete)
726             return false;
727     }
728     return true;
729 }
730
731 bool FrameLoader::allAncestorsAreComplete() const
732 {
733     for (Frame* ancestor = m_frame; ancestor; ancestor = ancestor->tree()->parent()) {
734         if (!ancestor->loader()->m_isComplete)
735             return false;
736     }
737     return true;
738 }
739
740 void FrameLoader::checkCompleted()
741 {
742     m_shouldCallCheckCompleted = false;
743
744     if (m_frame->view())
745         m_frame->view()->handleLoadCompleted();
746
747     // Have we completed before?
748     if (m_isComplete)
749         return;
750
751     // Are we still parsing?
752     if (m_frame->document()->parsing())
753         return;
754
755     // Still waiting for images/scripts?
756     if (m_frame->document()->cachedResourceLoader()->requestCount())
757         return;
758
759     // Still waiting for elements that don't go through a FrameLoader?
760     if (m_frame->document()->isDelayingLoadEvent())
761         return;
762
763     // Any frame that hasn't completed yet?
764     if (!allChildrenAreComplete())
765         return;
766
767     // OK, completed.
768     m_isComplete = true;
769     m_requestedHistoryItem = 0;
770     m_frame->document()->setReadyState(Document::Complete);
771
772     RefPtr<Frame> protect(m_frame);
773     checkCallImplicitClose(); // if we didn't do it before
774
775     m_frame->navigationScheduler()->startTimer();
776
777     completed();
778     if (m_frame->page())
779         checkLoadComplete();
780
781     if (m_frame->view())
782         m_frame->view()->handleLoadCompleted();
783 }
784
785 void FrameLoader::checkTimerFired(Timer<FrameLoader>*)
786 {
787     RefPtr<Frame> protect(m_frame);
788
789     if (Page* page = m_frame->page()) {
790         if (page->defersLoading())
791             return;
792     }
793     if (m_shouldCallCheckCompleted)
794         checkCompleted();
795     if (m_shouldCallCheckLoadComplete)
796         checkLoadComplete();
797 }
798
799 void FrameLoader::startCheckCompleteTimer()
800 {
801     if (!(m_shouldCallCheckCompleted || m_shouldCallCheckLoadComplete))
802         return;
803     if (m_checkTimer.isActive())
804         return;
805     m_checkTimer.startOneShot(0);
806 }
807
808 void FrameLoader::scheduleCheckCompleted()
809 {
810     m_shouldCallCheckCompleted = true;
811     startCheckCompleteTimer();
812 }
813
814 void FrameLoader::scheduleCheckLoadComplete()
815 {
816     m_shouldCallCheckLoadComplete = true;
817     startCheckCompleteTimer();
818 }
819
820 void FrameLoader::checkCallImplicitClose()
821 {
822     if (m_didCallImplicitClose || m_frame->document()->parsing() || m_frame->document()->isDelayingLoadEvent())
823         return;
824
825     if (!allChildrenAreComplete())
826         return; // still got a frame running -> too early
827
828     m_didCallImplicitClose = true;
829     m_wasUnloadEventEmitted = false;
830     m_frame->document()->implicitClose();
831 }
832
833 void FrameLoader::loadURLIntoChildFrame(const KURL& url, const String& referer, Frame* childFrame)
834 {
835     ASSERT(childFrame);
836
837 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
838     RefPtr<Archive> subframeArchive = activeDocumentLoader()->popArchiveForSubframe(childFrame->tree()->uniqueName(), url);    
839     if (subframeArchive) {
840         childFrame->loader()->loadArchive(subframeArchive.release());
841         return;
842     }
843 #endif // ENABLE(WEB_ARCHIVE)
844
845     HistoryItem* parentItem = history()->currentItem();
846     // If we're moving in the back/forward list, we might want to replace the content
847     // of this child frame with whatever was there at that point.
848     if (parentItem && parentItem->children().size() && isBackForwardLoadType(loadType()) 
849         && !m_frame->document()->loadEventFinished()) {
850         HistoryItem* childItem = parentItem->childItemWithTarget(childFrame->tree()->uniqueName());
851         if (childItem) {
852             childFrame->loader()->loadDifferentDocumentItem(childItem, loadType());
853             return;
854         }
855     }
856
857     childFrame->loader()->loadURL(url, referer, "_self", false, FrameLoadTypeRedirectWithLockedBackForwardList, 0, 0);
858 }
859
860 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
861 void FrameLoader::loadArchive(PassRefPtr<Archive> archive)
862 {
863     ArchiveResource* mainResource = archive->mainResource();
864     ASSERT(mainResource);
865     if (!mainResource)
866         return;
867         
868     SubstituteData substituteData(mainResource->data(), mainResource->mimeType(), mainResource->textEncoding(), KURL());
869     
870     ResourceRequest request(mainResource->url());
871 #if PLATFORM(MAC)
872     request.applyWebArchiveHackForMail();
873 #endif
874
875     RefPtr<DocumentLoader> documentLoader = m_client->createDocumentLoader(request, substituteData);
876     documentLoader->setArchive(archive.get());
877     load(documentLoader.get());
878 }
879 #endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
880
881 ObjectContentType FrameLoader::defaultObjectContentType(const KURL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages)
882 {
883     String mimeType = mimeTypeIn;
884     String decodedPath = decodeURLEscapeSequences(url.path());
885     String extension = decodedPath.substring(decodedPath.reverseFind('.') + 1);
886
887     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
888     if (mimeType.isEmpty())
889         mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension);
890
891 #if !PLATFORM(MAC) && !PLATFORM(CHROMIUM) && !PLATFORM(EFL) // Mac has no PluginDatabase, nor does Chromium or EFL
892     if (mimeType.isEmpty())
893         mimeType = PluginDatabase::installedPlugins()->MIMETypeForExtension(extension);
894 #endif
895
896     if (mimeType.isEmpty())
897         return ObjectContentFrame; // Go ahead and hope that we can display the content.
898
899 #if !PLATFORM(MAC) && !PLATFORM(CHROMIUM) && !PLATFORM(EFL) // Mac has no PluginDatabase, nor does Chromium or EFL
900     bool plugInSupportsMIMEType = PluginDatabase::installedPlugins()->isMIMETypeRegistered(mimeType);
901 #else
902     bool plugInSupportsMIMEType = false;
903 #endif
904
905     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
906         return shouldPreferPlugInsForImages && plugInSupportsMIMEType ? WebCore::ObjectContentNetscapePlugin : WebCore::ObjectContentImage;
907
908     if (plugInSupportsMIMEType)
909         return WebCore::ObjectContentNetscapePlugin;
910
911     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
912         return WebCore::ObjectContentFrame;
913
914     return WebCore::ObjectContentNone;
915 }
916
917 String FrameLoader::outgoingReferrer() const
918 {
919     // See http://www.whatwg.org/specs/web-apps/current-work/#fetching-resources
920     // for why we walk the parent chain for srcdoc documents.
921     Frame* frame = m_frame;
922     while (frame->document()->isSrcdocDocument()) {
923         frame = frame->tree()->parent();
924         // Srcdoc documents cannot be top-level documents, by definition,
925         // because they need to be contained in iframes with the srcdoc.
926         ASSERT(frame);
927     }
928     return frame->loader()->m_outgoingReferrer;
929 }
930
931 String FrameLoader::outgoingOrigin() const
932 {
933     return m_frame->document()->securityOrigin()->toString();
934 }
935
936 bool FrameLoader::checkIfFormActionAllowedByCSP(const KURL& url) const
937 {
938     if (m_submittedFormURL.isEmpty())
939         return true;
940
941     return m_frame->document()->contentSecurityPolicy()->allowFormAction(url);
942 }
943
944 Frame* FrameLoader::opener()
945 {
946     return m_opener;
947 }
948
949 void FrameLoader::setOpener(Frame* opener)
950 {
951     if (m_opener)
952         m_opener->loader()->m_openedFrames.remove(m_frame);
953     if (opener)
954         opener->loader()->m_openedFrames.add(m_frame);
955     m_opener = opener;
956
957     if (m_frame->document())
958         m_frame->document()->initSecurityContext();
959 }
960
961 // FIXME: This does not belong in FrameLoader!
962 void FrameLoader::handleFallbackContent()
963 {
964     HTMLFrameOwnerElement* owner = m_frame->ownerElement();
965     if (!owner || !owner->hasTagName(objectTag))
966         return;
967     static_cast<HTMLObjectElement*>(owner)->renderFallbackContent();
968 }
969
970 void FrameLoader::provisionalLoadStarted()
971 {
972     if (m_stateMachine.firstLayoutDone())
973         m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
974     m_frame->navigationScheduler()->cancel(true);
975     m_client->provisionalLoadStarted();
976 }
977
978 void FrameLoader::resetMultipleFormSubmissionProtection()
979 {
980     m_submittedFormURL = KURL();
981 }
982
983 void FrameLoader::updateFirstPartyForCookies()
984 {
985     if (m_frame->tree()->parent())
986         setFirstPartyForCookies(m_frame->tree()->parent()->document()->firstPartyForCookies());
987     else
988         setFirstPartyForCookies(m_frame->document()->url());
989 }
990
991 void FrameLoader::setFirstPartyForCookies(const KURL& url)
992 {
993     for (Frame* frame = m_frame; frame; frame = frame->tree()->traverseNext(m_frame))
994         frame->document()->setFirstPartyForCookies(url);
995 }
996
997 // This does the same kind of work that didOpenURL does, except it relies on the fact
998 // that a higher level already checked that the URLs match and the scrolling is the right thing to do.
999 void FrameLoader::loadInSameDocument(const KURL& url, SerializedScriptValue* stateObject, bool isNewNavigation)
1000 {
1001     // If we have a state object, we cannot also be a new navigation.
1002     ASSERT(!stateObject || (stateObject && !isNewNavigation));
1003
1004     // Update the data source's request with the new URL to fake the URL change
1005     KURL oldURL = m_frame->document()->url();
1006     m_frame->document()->setURL(url);
1007     setOutgoingReferrer(url);
1008     documentLoader()->replaceRequestURLForSameDocumentNavigation(url);
1009     if (isNewNavigation && !shouldTreatURLAsSameAsCurrent(url) && !stateObject) {
1010         // NB: must happen after replaceRequestURLForSameDocumentNavigation(), since we add 
1011         // based on the current request. Must also happen before we openURL and displace the 
1012         // scroll position, since adding the BF item will save away scroll state.
1013         
1014         // NB2: If we were loading a long, slow doc, and the user fragment navigated before
1015         // it was done, currItem is now set the that slow doc, and prevItem is whatever was
1016         // before it.  Adding the b/f item will bump the slow doc down to prevItem, even
1017         // though its load is not yet done.  I think this all works out OK, for one because
1018         // we have already saved away the scroll and doc state for the long slow load,
1019         // but it's not an obvious case.
1020
1021         history()->updateBackForwardListForFragmentScroll();
1022     }
1023     
1024     bool hashChange = equalIgnoringFragmentIdentifier(url, oldURL) && url.fragmentIdentifier() != oldURL.fragmentIdentifier();
1025     
1026     history()->updateForSameDocumentNavigation();
1027
1028     // If we were in the autoscroll/panScroll mode we want to stop it before following the link to the anchor
1029     if (hashChange)
1030         m_frame->eventHandler()->stopAutoscrollTimer();
1031     
1032     // It's important to model this as a load that starts and immediately finishes.
1033     // Otherwise, the parent frame may think we never finished loading.
1034     started();
1035
1036     // We need to scroll to the fragment whether or not a hash change occurred, since
1037     // the user might have scrolled since the previous navigation.
1038     scrollToFragmentWithParentBoundary(url);
1039     
1040     m_isComplete = false;
1041     checkCompleted();
1042
1043     if (isNewNavigation) {
1044         // This will clear previousItem from the rest of the frame tree that didn't
1045         // doing any loading. We need to make a pass on this now, since for fragment
1046         // navigation we'll not go through a real load and reach Completed state.
1047         checkLoadComplete();
1048     }
1049
1050     m_client->dispatchDidNavigateWithinPage();
1051
1052     m_frame->document()->statePopped(stateObject ? stateObject : SerializedScriptValue::nullValue());
1053     m_client->dispatchDidPopStateWithinPage();
1054     
1055     if (hashChange) {
1056         m_frame->document()->enqueueHashchangeEvent(oldURL, url);
1057         m_client->dispatchDidChangeLocationWithinPage();
1058     }
1059     
1060     // FrameLoaderClient::didFinishLoad() tells the internal load delegate the load finished with no error
1061     m_client->didFinishLoad();
1062 }
1063
1064 bool FrameLoader::isComplete() const
1065 {
1066     return m_isComplete;
1067 }
1068
1069 void FrameLoader::completed()
1070 {
1071     RefPtr<Frame> protect(m_frame);
1072
1073     for (Frame* descendant = m_frame->tree()->traverseNext(m_frame); descendant; descendant = descendant->tree()->traverseNext(m_frame))
1074         descendant->navigationScheduler()->startTimer();
1075
1076     if (Frame* parent = m_frame->tree()->parent())
1077         parent->loader()->checkCompleted();
1078
1079     if (m_frame->view())
1080         m_frame->view()->maintainScrollPositionAtAnchor(0);
1081 }
1082
1083 void FrameLoader::started()
1084 {
1085     for (Frame* frame = m_frame; frame; frame = frame->tree()->parent())
1086         frame->loader()->m_isComplete = false;
1087 }
1088
1089 void FrameLoader::prepareForHistoryNavigation()
1090 {
1091     // If there is no currentItem, but we still want to engage in 
1092     // history navigation we need to manufacture one, and update
1093     // the state machine of this frame to impersonate having
1094     // loaded it.
1095     RefPtr<HistoryItem> currentItem = history()->currentItem();
1096     if (!currentItem) {
1097         currentItem = HistoryItem::create();
1098         currentItem->setLastVisitWasFailure(true);
1099         history()->setCurrentItem(currentItem.get());
1100         frame()->page()->backForward()->setCurrentItem(currentItem.get());
1101
1102         ASSERT(stateMachine()->isDisplayingInitialEmptyDocument());
1103         stateMachine()->advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocumentPostCommit);
1104         stateMachine()->advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
1105     }
1106 }
1107
1108 void FrameLoader::prepareForLoadStart()
1109 {
1110     m_progressTracker->progressStarted();
1111     m_client->dispatchDidStartProvisionalLoad();
1112
1113     // Notify accessibility.
1114     if (AXObjectCache::accessibilityEnabled()) {
1115         AXObjectCache::AXLoadingEvent loadingEvent = loadType() == FrameLoadTypeReload ? AXObjectCache::AXLoadingReloaded : AXObjectCache::AXLoadingStarted;
1116         m_frame->document()->axObjectCache()->frameLoadingEventNotification(m_frame, loadingEvent);
1117     }
1118 }
1119
1120 void FrameLoader::setupForReplace()
1121 {
1122     m_client->revertToProvisionalState(m_documentLoader.get());
1123     setState(FrameStateProvisional);
1124     m_provisionalDocumentLoader = m_documentLoader;
1125     m_documentLoader = 0;
1126     detachChildren();
1127 }
1128
1129 void FrameLoader::loadFrameRequest(const FrameLoadRequest& request, bool lockHistory, bool lockBackForwardList,
1130     PassRefPtr<Event> event, PassRefPtr<FormState> formState, ShouldSendReferrer shouldSendReferrer)
1131 {    
1132     // Protect frame from getting blown away inside dispatchBeforeLoadEvent in loadWithDocumentLoader.
1133     RefPtr<Frame> protect(m_frame);
1134
1135     KURL url = request.resourceRequest().url();
1136
1137     ASSERT(m_frame->document());
1138     if (!request.requester()->canDisplay(url)) {
1139         reportLocalLoadFailed(m_frame, url.string());
1140         return;
1141     }
1142
1143     String argsReferrer = request.resourceRequest().httpReferrer();
1144     if (argsReferrer.isEmpty())
1145         argsReferrer = outgoingReferrer();
1146
1147     String referrer = SecurityPolicy::generateReferrerHeader(m_frame->document()->referrerPolicy(), url, argsReferrer);
1148     if (shouldSendReferrer == NeverSendReferrer)
1149         referrer = String();
1150     
1151     FrameLoadType loadType;
1152     if (request.resourceRequest().cachePolicy() == ReloadIgnoringCacheData)
1153         loadType = FrameLoadTypeReload;
1154     else if (lockBackForwardList)
1155         loadType = FrameLoadTypeRedirectWithLockedBackForwardList;
1156     else
1157         loadType = FrameLoadTypeStandard;
1158
1159     if (request.resourceRequest().httpMethod() == "POST")
1160         loadPostRequest(request.resourceRequest(), referrer, request.frameName(), lockHistory, loadType, event, formState.get());
1161     else
1162         loadURL(request.resourceRequest().url(), referrer, request.frameName(), lockHistory, loadType, event, formState.get());
1163
1164     // FIXME: It's possible this targetFrame will not be the same frame that was targeted by the actual
1165     // load if frame names have changed.
1166     Frame* sourceFrame = formState ? formState->sourceDocument()->frame() : m_frame;
1167     if (!sourceFrame)
1168         sourceFrame = m_frame;
1169     Frame* targetFrame = sourceFrame->loader()->findFrameForNavigation(request.frameName());
1170     if (targetFrame && targetFrame != sourceFrame) {
1171         if (Page* page = targetFrame->page())
1172             page->chrome()->focus();
1173     }
1174 }
1175
1176 void FrameLoader::loadURL(const KURL& newURL, const String& referrer, const String& frameName, bool lockHistory, FrameLoadType newLoadType,
1177     PassRefPtr<Event> event, PassRefPtr<FormState> prpFormState)
1178 {
1179     if (m_inStopAllLoaders)
1180         return;
1181
1182     RefPtr<FormState> formState = prpFormState;
1183     bool isFormSubmission = formState;
1184     
1185     ResourceRequest request(newURL);
1186     if (!referrer.isEmpty()) {
1187         request.setHTTPReferrer(referrer);
1188         RefPtr<SecurityOrigin> referrerOrigin = SecurityOrigin::createFromString(referrer);
1189         addHTTPOriginIfNeeded(request, referrerOrigin->toString());
1190     }
1191     addExtraFieldsToRequest(request, newLoadType, true);
1192     if (newLoadType == FrameLoadTypeReload || newLoadType == FrameLoadTypeReloadFromOrigin)
1193         request.setCachePolicy(ReloadIgnoringCacheData);
1194
1195     ASSERT(newLoadType != FrameLoadTypeSame);
1196
1197     // The search for a target frame is done earlier in the case of form submission.
1198     Frame* targetFrame = isFormSubmission ? 0 : findFrameForNavigation(frameName);
1199     if (targetFrame && targetFrame != m_frame) {
1200         targetFrame->loader()->loadURL(newURL, referrer, "_self", lockHistory, newLoadType, event, formState.release());
1201         return;
1202     }
1203
1204     if (m_pageDismissalEventBeingDispatched != NoDismissal)
1205         return;
1206
1207     NavigationAction action(request, newLoadType, isFormSubmission, event);
1208
1209     if (!targetFrame && !frameName.isEmpty()) {
1210         policyChecker()->checkNewWindowPolicy(action, FrameLoader::callContinueLoadAfterNewWindowPolicy,
1211             request, formState.release(), frameName, this);
1212         return;
1213     }
1214
1215     RefPtr<DocumentLoader> oldDocumentLoader = m_documentLoader;
1216
1217     bool sameURL = shouldTreatURLAsSameAsCurrent(newURL);
1218     const String& httpMethod = request.httpMethod();
1219     
1220     // Make sure to do scroll to fragment processing even if the URL is
1221     // exactly the same so pages with '#' links and DHTML side effects
1222     // work properly.
1223     if (shouldPerformFragmentNavigation(isFormSubmission, httpMethod, newLoadType, newURL)) {
1224         oldDocumentLoader->setTriggeringAction(action);
1225         policyChecker()->stopCheck();
1226         policyChecker()->setLoadType(newLoadType);
1227         policyChecker()->checkNavigationPolicy(request, oldDocumentLoader.get(), formState.release(),
1228             callContinueFragmentScrollAfterNavigationPolicy, this);
1229     } else {
1230         // must grab this now, since this load may stop the previous load and clear this flag
1231         bool isRedirect = m_quickRedirectComing;
1232         loadWithNavigationAction(request, action, lockHistory, newLoadType, formState.release());
1233         if (isRedirect) {
1234             m_quickRedirectComing = false;
1235             if (m_provisionalDocumentLoader)
1236                 m_provisionalDocumentLoader->setIsClientRedirect(true);
1237         } else if (sameURL && newLoadType != FrameLoadTypeReload && newLoadType != FrameLoadTypeReloadFromOrigin)
1238             // Example of this case are sites that reload the same URL with a different cookie
1239             // driving the generated content, or a master frame with links that drive a target
1240             // frame, where the user has clicked on the same link repeatedly.
1241             m_loadType = FrameLoadTypeSame;
1242     }
1243 }
1244
1245 SubstituteData FrameLoader::defaultSubstituteDataForURL(const KURL& url)
1246 {
1247     if (!shouldTreatURLAsSrcdocDocument(url))
1248         return SubstituteData();
1249     String srcdoc = m_frame->ownerElement()->fastGetAttribute(srcdocAttr);
1250     ASSERT(!srcdoc.isNull());
1251     CString encodedSrcdoc = srcdoc.utf8();
1252     return SubstituteData(SharedBuffer::create(encodedSrcdoc.data(), encodedSrcdoc.length()), "text/html", "UTF-8", KURL());
1253 }
1254
1255 void FrameLoader::load(const FrameLoadRequest& passedRequest)
1256 {
1257     FrameLoadRequest request(passedRequest);
1258
1259     if (m_inStopAllLoaders)
1260         return;
1261
1262     if (!request.hasSubstituteData()) {
1263         if (!request.frameName().isEmpty()) {
1264             Frame* frame = findFrameForNavigation(request.frameName());
1265             if (frame && frame->loader() != this) {
1266                 frame->loader()->load(request);
1267                 return;
1268             }
1269         }
1270
1271         if (request.shouldCheckNewWindowPolicy()) {
1272             policyChecker()->checkNewWindowPolicy(NavigationAction(request.resourceRequest(), NavigationTypeOther), FrameLoader::callContinueLoadAfterNewWindowPolicy, request.resourceRequest(), 0, request.frameName(), this);
1273             return;
1274         }
1275
1276         request.setSubstituteData(defaultSubstituteDataForURL(request.resourceRequest().url()));
1277     }
1278
1279     RefPtr<DocumentLoader> loader = m_client->createDocumentLoader(request.resourceRequest(), request.substituteData());
1280     if (request.lockHistory() && m_documentLoader)
1281         loader->setClientRedirectSourceForHistory(m_documentLoader->didCreateGlobalHistoryEntry() ? m_documentLoader->urlForHistory().string() : m_documentLoader->clientRedirectSourceForHistory());
1282     load(loader.get());
1283 }
1284
1285 void FrameLoader::loadWithNavigationAction(const ResourceRequest& request, const NavigationAction& action, bool lockHistory, FrameLoadType type, PassRefPtr<FormState> formState)
1286 {
1287     RefPtr<DocumentLoader> loader = m_client->createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
1288     if (lockHistory && m_documentLoader)
1289         loader->setClientRedirectSourceForHistory(m_documentLoader->didCreateGlobalHistoryEntry() ? m_documentLoader->urlForHistory().string() : m_documentLoader->clientRedirectSourceForHistory());
1290
1291     loader->setTriggeringAction(action);
1292     if (m_documentLoader)
1293         loader->setOverrideEncoding(m_documentLoader->overrideEncoding());
1294
1295     loadWithDocumentLoader(loader.get(), type, formState);
1296 }
1297
1298 void FrameLoader::load(DocumentLoader* newDocumentLoader)
1299 {
1300     ResourceRequest& r = newDocumentLoader->request();
1301     addExtraFieldsToMainResourceRequest(r);
1302     FrameLoadType type;
1303
1304     if (shouldTreatURLAsSameAsCurrent(newDocumentLoader->originalRequest().url())) {
1305         r.setCachePolicy(ReloadIgnoringCacheData);
1306         type = FrameLoadTypeSame;
1307     } else if (shouldTreatURLAsSameAsCurrent(newDocumentLoader->unreachableURL()) && m_loadType == FrameLoadTypeReload)
1308         type = FrameLoadTypeReload;
1309     else
1310         type = FrameLoadTypeStandard;
1311
1312     if (m_documentLoader)
1313         newDocumentLoader->setOverrideEncoding(m_documentLoader->overrideEncoding());
1314     
1315     // When we loading alternate content for an unreachable URL that we're
1316     // visiting in the history list, we treat it as a reload so the history list 
1317     // is appropriately maintained.
1318     //
1319     // FIXME: This seems like a dangerous overloading of the meaning of "FrameLoadTypeReload" ...
1320     // shouldn't a more explicit type of reload be defined, that means roughly 
1321     // "load without affecting history" ? 
1322     if (shouldReloadToHandleUnreachableURL(newDocumentLoader)) {
1323         // shouldReloadToHandleUnreachableURL() returns true only when the original load type is back-forward.
1324         // In this case we should save the document state now. Otherwise the state can be lost because load type is
1325         // changed and updateForBackForwardNavigation() will not be called when loading is committed.
1326         history()->saveDocumentAndScrollState();
1327
1328         ASSERT(type == FrameLoadTypeStandard);
1329         type = FrameLoadTypeReload;
1330     }
1331
1332     loadWithDocumentLoader(newDocumentLoader, type, 0);
1333 }
1334
1335 void FrameLoader::loadWithDocumentLoader(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> prpFormState)
1336 {
1337     // Retain because dispatchBeforeLoadEvent may release the last reference to it.
1338     RefPtr<Frame> protect(m_frame);
1339
1340     ASSERT(m_client->hasWebView());
1341
1342     // Unfortunately the view must be non-nil, this is ultimately due
1343     // to parser requiring a FrameView.  We should fix this dependency.
1344
1345     ASSERT(m_frame->view());
1346
1347     if (m_pageDismissalEventBeingDispatched != NoDismissal)
1348         return;
1349
1350     if (m_frame->document())
1351         m_previousUrl = m_frame->document()->url();
1352
1353     policyChecker()->setLoadType(type);
1354     RefPtr<FormState> formState = prpFormState;
1355     bool isFormSubmission = formState;
1356
1357     const KURL& newURL = loader->request().url();
1358     const String& httpMethod = loader->request().httpMethod();
1359
1360     if (shouldPerformFragmentNavigation(isFormSubmission, httpMethod, policyChecker()->loadType(), newURL)) {
1361         RefPtr<DocumentLoader> oldDocumentLoader = m_documentLoader;
1362         NavigationAction action(loader->request(), policyChecker()->loadType(), isFormSubmission);
1363
1364         oldDocumentLoader->setTriggeringAction(action);
1365         policyChecker()->stopCheck();
1366         policyChecker()->checkNavigationPolicy(loader->request(), oldDocumentLoader.get(), formState,
1367             callContinueFragmentScrollAfterNavigationPolicy, this);
1368     } else {
1369         if (Frame* parent = m_frame->tree()->parent())
1370             loader->setOverrideEncoding(parent->loader()->documentLoader()->overrideEncoding());
1371
1372         policyChecker()->stopCheck();
1373         setPolicyDocumentLoader(loader);
1374         if (loader->triggeringAction().isEmpty())
1375             loader->setTriggeringAction(NavigationAction(loader->request(), policyChecker()->loadType(), isFormSubmission));
1376
1377         if (Element* ownerElement = m_frame->ownerElement()) {
1378             // We skip dispatching the beforeload event if we've already
1379             // committed a real document load because the event would leak
1380             // subsequent activity by the frame which the parent frame isn't
1381             // supposed to learn. For example, if the child frame navigated to
1382             // a new URL, the parent frame shouldn't learn the URL.
1383             if (!m_stateMachine.committedFirstRealDocumentLoad()
1384                 && !ownerElement->dispatchBeforeLoadEvent(loader->request().url().string())) {
1385                 continueLoadAfterNavigationPolicy(loader->request(), formState, false);
1386                 return;
1387             }
1388         }
1389
1390         policyChecker()->checkNavigationPolicy(loader->request(), loader, formState,
1391             callContinueLoadAfterNavigationPolicy, this);
1392     }
1393 }
1394
1395 void FrameLoader::reportLocalLoadFailed(Frame* frame, const String& url)
1396 {
1397     ASSERT(!url.isEmpty());
1398     if (!frame)
1399         return;
1400
1401     frame->document()->addConsoleMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, "Not allowed to load local resource: " + url);
1402 }
1403
1404 const ResourceRequest& FrameLoader::initialRequest() const
1405 {
1406     return activeDocumentLoader()->originalRequest();
1407 }
1408
1409 bool FrameLoader::willLoadMediaElementURL(KURL& url)
1410 {
1411     ResourceRequest request(url);
1412
1413     unsigned long identifier;
1414     ResourceError error;
1415     requestFromDelegate(request, identifier, error);
1416     notifier()->sendRemainingDelegateMessages(m_documentLoader.get(), identifier, ResourceResponse(url, String(), -1, String(), String()), 0, -1, -1, error);
1417
1418     url = request.url();
1419
1420     return error.isNull();
1421 }
1422
1423 bool FrameLoader::shouldReloadToHandleUnreachableURL(DocumentLoader* docLoader)
1424 {
1425     KURL unreachableURL = docLoader->unreachableURL();
1426
1427     if (unreachableURL.isEmpty())
1428         return false;
1429
1430     if (!isBackForwardLoadType(policyChecker()->loadType()))
1431         return false;
1432
1433     // We only treat unreachableURLs specially during the delegate callbacks
1434     // for provisional load errors and navigation policy decisions. The former
1435     // case handles well-formed URLs that can't be loaded, and the latter
1436     // case handles malformed URLs and unknown schemes. Loading alternate content
1437     // at other times behaves like a standard load.
1438     DocumentLoader* compareDocumentLoader = 0;
1439     if (policyChecker()->delegateIsDecidingNavigationPolicy() || policyChecker()->delegateIsHandlingUnimplementablePolicy())
1440         compareDocumentLoader = m_policyDocumentLoader.get();
1441     else if (m_delegateIsHandlingProvisionalLoadError)
1442         compareDocumentLoader = m_provisionalDocumentLoader.get();
1443
1444     return compareDocumentLoader && unreachableURL == compareDocumentLoader->request().url();
1445 }
1446
1447 void FrameLoader::reloadWithOverrideEncoding(const String& encoding)
1448 {
1449     if (!m_documentLoader)
1450         return;
1451
1452     ResourceRequest request = m_documentLoader->request();
1453     KURL unreachableURL = m_documentLoader->unreachableURL();
1454     if (!unreachableURL.isEmpty())
1455         request.setURL(unreachableURL);
1456
1457     request.setCachePolicy(ReturnCacheDataElseLoad);
1458
1459     RefPtr<DocumentLoader> loader = m_client->createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
1460     setPolicyDocumentLoader(loader.get());
1461
1462     loader->setOverrideEncoding(encoding);
1463
1464     loadWithDocumentLoader(loader.get(), FrameLoadTypeReload, 0);
1465 }
1466
1467 void FrameLoader::reloadWithOverrideURL(const KURL& overrideUrl, bool endToEndReload)
1468 {
1469     if (!m_documentLoader)
1470         return;
1471
1472     if (overrideUrl.isEmpty())
1473         return;
1474
1475     ResourceRequest request = m_documentLoader->request();
1476     request.setURL(overrideUrl);
1477     reloadWithRequest(request, endToEndReload);
1478 }
1479
1480 void FrameLoader::reload(bool endToEndReload)
1481 {
1482     if (!m_documentLoader)
1483         return;
1484
1485     // If a window is created by javascript, its main frame can have an empty but non-nil URL.
1486     // Reloading in this case will lose the current contents (see 4151001).
1487     if (m_documentLoader->request().url().isEmpty())
1488         return;
1489
1490     // Replace error-page URL with the URL we were trying to reach.
1491     ResourceRequest initialRequest = m_documentLoader->request();
1492     KURL unreachableURL = m_documentLoader->unreachableURL();
1493     if (!unreachableURL.isEmpty())
1494         initialRequest.setURL(unreachableURL);
1495
1496     reloadWithRequest(initialRequest, endToEndReload);
1497 }
1498
1499 void FrameLoader::reloadWithRequest(const ResourceRequest& initialRequest, bool endToEndReload)
1500 {
1501     ASSERT(m_documentLoader);
1502
1503     // Create a new document loader for the reload, this will become m_documentLoader eventually,
1504     // but first it has to be the "policy" document loader, and then the "provisional" document loader.
1505     RefPtr<DocumentLoader> loader = m_client->createDocumentLoader(initialRequest, defaultSubstituteDataForURL(initialRequest.url()));
1506
1507     ResourceRequest& request = loader->request();
1508
1509     // FIXME: We don't have a mechanism to revalidate the main resource without reloading at the moment.
1510     request.setCachePolicy(ReloadIgnoringCacheData);
1511
1512     // If we're about to re-post, set up action so the application can warn the user.
1513     if (request.httpMethod() == "POST")
1514         loader->setTriggeringAction(NavigationAction(request, NavigationTypeFormResubmitted));
1515
1516     loader->setOverrideEncoding(m_documentLoader->overrideEncoding());
1517     
1518     loadWithDocumentLoader(loader.get(), endToEndReload ? FrameLoadTypeReloadFromOrigin : FrameLoadTypeReload, 0);
1519 }
1520
1521 void FrameLoader::stopAllLoaders(ClearProvisionalItemPolicy clearProvisionalItemPolicy)
1522 {
1523     ASSERT(!m_frame->document() || !m_frame->document()->inPageCache());
1524     if (m_pageDismissalEventBeingDispatched != NoDismissal)
1525         return;
1526
1527     // If this method is called from within this method, infinite recursion can occur (3442218). Avoid this.
1528     if (m_inStopAllLoaders)
1529         return;
1530     
1531     // Calling stopLoading() on the provisional document loader can blow away
1532     // the frame from underneath.
1533     RefPtr<Frame> protect(m_frame);
1534
1535     m_inStopAllLoaders = true;
1536
1537     policyChecker()->stopCheck();
1538
1539     // If no new load is in progress, we should clear the provisional item from history
1540     // before we call stopLoading.
1541     if (clearProvisionalItemPolicy == ShouldClearProvisionalItem)
1542         history()->setProvisionalItem(0);
1543
1544     for (RefPtr<Frame> child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
1545         child->loader()->stopAllLoaders(clearProvisionalItemPolicy);
1546     if (m_provisionalDocumentLoader)
1547         m_provisionalDocumentLoader->stopLoading();
1548     if (m_documentLoader)
1549         m_documentLoader->stopLoading();
1550
1551     setProvisionalDocumentLoader(0);
1552
1553     m_checkTimer.stop();
1554
1555     m_inStopAllLoaders = false;    
1556 }
1557
1558 void FrameLoader::stopForUserCancel(bool deferCheckLoadComplete)
1559 {
1560     stopAllLoaders();
1561     
1562     if (deferCheckLoadComplete)
1563         scheduleCheckLoadComplete();
1564     else if (m_frame->page())
1565         checkLoadComplete();
1566 }
1567
1568 DocumentLoader* FrameLoader::activeDocumentLoader() const
1569 {
1570     if (m_state == FrameStateProvisional)
1571         return m_provisionalDocumentLoader.get();
1572     return m_documentLoader.get();
1573 }
1574
1575 bool FrameLoader::isLoading() const
1576 {
1577     DocumentLoader* docLoader = activeDocumentLoader();
1578     if (!docLoader)
1579         return false;
1580     return docLoader->isLoading();
1581 }
1582
1583 bool FrameLoader::frameHasLoaded() const
1584 {
1585     return m_stateMachine.committedFirstRealDocumentLoad() || (m_provisionalDocumentLoader && !m_stateMachine.creatingInitialEmptyDocument()); 
1586 }
1587
1588 void FrameLoader::setDocumentLoader(DocumentLoader* loader)
1589 {
1590     if (!loader && !m_documentLoader)
1591         return;
1592     
1593     ASSERT(loader != m_documentLoader);
1594     ASSERT(!loader || loader->frameLoader() == this);
1595
1596     m_client->prepareForDataSourceReplacement();
1597     detachChildren();
1598
1599     // detachChildren() can trigger this frame's unload event, and therefore
1600     // script can run and do just about anything. For example, an unload event that calls
1601     // document.write("") on its parent frame can lead to a recursive detachChildren()
1602     // invocation for this frame. In that case, we can end up at this point with a
1603     // loader that hasn't been deleted but has been detached from its frame. Such a
1604     // DocumentLoader has been sufficiently detached that we'll end up in an inconsistent
1605     // state if we try to use it.
1606     if (loader && !loader->frame())
1607         return;
1608
1609     if (m_documentLoader)
1610         m_documentLoader->detachFromFrame();
1611
1612     m_documentLoader = loader;
1613 }
1614
1615 void FrameLoader::setPolicyDocumentLoader(DocumentLoader* loader)
1616 {
1617     if (m_policyDocumentLoader == loader)
1618         return;
1619
1620     ASSERT(m_frame);
1621     if (loader)
1622         loader->setFrame(m_frame);
1623     if (m_policyDocumentLoader
1624             && m_policyDocumentLoader != m_provisionalDocumentLoader
1625             && m_policyDocumentLoader != m_documentLoader)
1626         m_policyDocumentLoader->detachFromFrame();
1627
1628     m_policyDocumentLoader = loader;
1629 }
1630
1631 void FrameLoader::setProvisionalDocumentLoader(DocumentLoader* loader)
1632 {
1633     ASSERT(!loader || !m_provisionalDocumentLoader);
1634     ASSERT(!loader || loader->frameLoader() == this);
1635
1636     if (m_provisionalDocumentLoader && m_provisionalDocumentLoader != m_documentLoader)
1637         m_provisionalDocumentLoader->detachFromFrame();
1638
1639     m_provisionalDocumentLoader = loader;
1640 }
1641
1642 double FrameLoader::timeOfLastCompletedLoad()
1643 {
1644     return storedTimeOfLastCompletedLoad;
1645 }
1646
1647 void FrameLoader::setState(FrameState newState)
1648 {    
1649     m_state = newState;
1650     
1651     if (newState == FrameStateProvisional)
1652         provisionalLoadStarted();
1653     else if (newState == FrameStateComplete) {
1654         frameLoadCompleted();
1655         storedTimeOfLastCompletedLoad = currentTime();
1656         if (m_documentLoader)
1657             m_documentLoader->stopRecordingResponses();
1658     }
1659 }
1660
1661 void FrameLoader::clearProvisionalLoad()
1662 {
1663     setProvisionalDocumentLoader(0);
1664     m_progressTracker->progressCompleted();
1665     setState(FrameStateComplete);
1666 }
1667
1668 void FrameLoader::commitProvisionalLoad()
1669 {
1670     RefPtr<CachedPage> cachedPage = m_loadingFromCachedPage ? pageCache()->get(history()->provisionalItem()) : 0;
1671     RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
1672     RefPtr<Frame> protect(m_frame);
1673
1674     LOG(PageCache, "WebCoreLoading %s: About to commit provisional load from previous URL '%s' to new URL '%s'", m_frame->tree()->uniqueName().string().utf8().data(),
1675         m_frame->document() ? m_frame->document()->url().string().utf8().data() : "", 
1676         pdl ? pdl->url().string().utf8().data() : "<no provisional DocumentLoader>");
1677
1678     // Check to see if we need to cache the page we are navigating away from into the back/forward cache.
1679     // We are doing this here because we know for sure that a new page is about to be loaded.
1680     HistoryItem* item = history()->currentItem();
1681     if (!m_frame->tree()->parent() && pageCache()->canCache(m_frame->page()) && !item->isInPageCache())
1682         pageCache()->add(item, m_frame->page());
1683
1684     if (m_loadType != FrameLoadTypeReplace)
1685         closeOldDataSources();
1686
1687     if (!cachedPage && !m_stateMachine.creatingInitialEmptyDocument())
1688         m_client->makeRepresentation(pdl.get());
1689
1690     transitionToCommitted(cachedPage);
1691
1692     if (pdl && m_documentLoader) {
1693         // Check if the destination page is allowed to access the previous page's timing information.
1694         RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::create(pdl->request().url());
1695         m_documentLoader->timing()->setHasSameOriginAsPreviousDocument(securityOrigin->canRequest(m_previousUrl));
1696     }
1697
1698     // Call clientRedirectCancelledOrFinished() here so that the frame load delegate is notified that the redirect's
1699     // status has changed, if there was a redirect.  The frame load delegate may have saved some state about
1700     // the redirect in its -webView:willPerformClientRedirectToURL:delay:fireDate:forFrame:.  Since we are
1701     // just about to commit a new page, there cannot possibly be a pending redirect at this point.
1702     if (m_sentRedirectNotification)
1703         clientRedirectCancelledOrFinished(false);
1704     
1705     if (cachedPage && cachedPage->document()) {
1706         prepareForCachedPageRestore();
1707         cachedPage->restore(m_frame->page());
1708
1709         // The page should be removed from the cache immediately after a restoration in order for the PageCache to be consistent.
1710         pageCache()->remove(history()->currentItem());
1711
1712         dispatchDidCommitLoad();
1713
1714         // If we have a title let the WebView know about it. 
1715         StringWithDirection title = m_documentLoader->title();
1716         if (!title.isNull())
1717             m_client->dispatchDidReceiveTitle(title);
1718
1719         checkCompleted();
1720     } else {
1721         if (cachedPage)
1722             pageCache()->remove(history()->currentItem());
1723         didOpenURL();
1724     }
1725
1726     LOG(Loading, "WebCoreLoading %s: Finished committing provisional load to URL %s", m_frame->tree()->uniqueName().string().utf8().data(),
1727         m_frame->document() ? m_frame->document()->url().string().utf8().data() : "");
1728
1729     if (m_loadType == FrameLoadTypeStandard && m_documentLoader->isClientRedirect())
1730         history()->updateForClientRedirect();
1731
1732     if (m_loadingFromCachedPage) {
1733         m_frame->document()->documentDidResumeFromPageCache();
1734         
1735         // Force a layout to update view size and thereby update scrollbars.
1736         m_frame->view()->forceLayout();
1737
1738         const ResponseVector& responses = m_documentLoader->responses();
1739         size_t count = responses.size();
1740         for (size_t i = 0; i < count; i++) {
1741             const ResourceResponse& response = responses[i];
1742             // FIXME: If the WebKit client changes or cancels the request, this is not respected.
1743             ResourceError error;
1744             unsigned long identifier;
1745             ResourceRequest request(response.url());
1746             requestFromDelegate(request, identifier, error);
1747             // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
1748             // However, with today's computers and networking speeds, this won't happen in practice.
1749             // Could be an issue with a giant local file.
1750             notifier()->sendRemainingDelegateMessages(m_documentLoader.get(), identifier, response, 0, static_cast<int>(response.expectedContentLength()), 0, error);
1751         }
1752
1753         // FIXME: Why only this frame and not parent frames?
1754         checkLoadCompleteForThisFrame();
1755     }
1756 }
1757
1758 void FrameLoader::transitionToCommitted(PassRefPtr<CachedPage> cachedPage)
1759 {
1760     ASSERT(m_client->hasWebView());
1761     ASSERT(m_state == FrameStateProvisional);
1762
1763     if (m_state != FrameStateProvisional)
1764         return;
1765
1766     if (FrameView* view = m_frame->view()) {
1767         if (ScrollAnimator* scrollAnimator = view->existingScrollAnimator())
1768             scrollAnimator->cancelAnimations();
1769     }
1770
1771     m_client->setCopiesOnScroll();
1772     history()->updateForCommit();
1773
1774     // The call to closeURL() invokes the unload event handler, which can execute arbitrary
1775     // JavaScript. If the script initiates a new load, we need to abandon the current load,
1776     // or the two will stomp each other.
1777     DocumentLoader* pdl = m_provisionalDocumentLoader.get();
1778     if (m_documentLoader)
1779         closeURL();
1780     if (pdl != m_provisionalDocumentLoader)
1781         return;
1782
1783     // Nothing else can interupt this commit - set the Provisional->Committed transition in stone
1784     if (m_documentLoader)
1785         m_documentLoader->stopLoadingSubresources();
1786     if (m_documentLoader)
1787         m_documentLoader->stopLoadingPlugIns();
1788
1789     setDocumentLoader(m_provisionalDocumentLoader.get());
1790     setProvisionalDocumentLoader(0);
1791
1792     if (pdl != m_documentLoader) {
1793         ASSERT(m_state == FrameStateComplete);
1794         return;
1795     }
1796
1797     setState(FrameStateCommittedPage);
1798
1799 #if ENABLE(TOUCH_EVENTS)
1800     if (isLoadingMainFrame())
1801         m_frame->page()->chrome()->client()->needTouchEvents(false);
1802 #endif
1803
1804     // Handle adding the URL to the back/forward list.
1805     DocumentLoader* dl = m_documentLoader.get();
1806
1807     switch (m_loadType) {
1808         case FrameLoadTypeForward:
1809         case FrameLoadTypeBack:
1810         case FrameLoadTypeIndexedBackForward:
1811             if (m_frame->page()) {
1812                 // If the first load within a frame is a navigation within a back/forward list that was attached
1813                 // without any of the items being loaded then we need to update the history in a similar manner as
1814                 // for a standard load with the exception of updating the back/forward list (<rdar://problem/8091103>).
1815                 if (!m_stateMachine.committedFirstRealDocumentLoad() && isLoadingMainFrame())
1816                     history()->updateForStandardLoad(HistoryController::UpdateAllExceptBackForwardList);
1817
1818                 history()->updateForBackForwardNavigation();
1819
1820                 // For cached pages, CachedFrame::restore will take care of firing the popstate event with the history item's state object
1821                 if (history()->currentItem() && !cachedPage)
1822                     m_pendingStateObject = history()->currentItem()->stateObject();
1823
1824                 // Create a document view for this document, or used the cached view.
1825                 if (cachedPage) {
1826                     DocumentLoader* cachedDocumentLoader = cachedPage->documentLoader();
1827                     ASSERT(cachedDocumentLoader);
1828                     cachedDocumentLoader->setFrame(m_frame);
1829                     m_client->transitionToCommittedFromCachedFrame(cachedPage->cachedMainFrame());
1830
1831                 } else
1832                     m_client->transitionToCommittedForNewPage();
1833             }
1834             break;
1835
1836         case FrameLoadTypeReload:
1837         case FrameLoadTypeReloadFromOrigin:
1838         case FrameLoadTypeSame:
1839         case FrameLoadTypeReplace:
1840             history()->updateForReload();
1841             m_client->transitionToCommittedForNewPage();
1842             break;
1843
1844         case FrameLoadTypeStandard:
1845             history()->updateForStandardLoad();
1846             if (m_frame->view())
1847                 m_frame->view()->setScrollbarsSuppressed(true);
1848             m_client->transitionToCommittedForNewPage();
1849             break;
1850
1851         case FrameLoadTypeRedirectWithLockedBackForwardList:
1852             history()->updateForRedirectWithLockedBackForwardList();
1853             m_client->transitionToCommittedForNewPage();
1854             break;
1855
1856         // FIXME Remove this check when dummy ds is removed (whatever "dummy ds" is).
1857         // An exception should be thrown if we're in the FrameLoadTypeUninitialized state.
1858         default:
1859             ASSERT_NOT_REACHED();
1860     }
1861
1862     m_documentLoader->writer()->setMIMEType(dl->responseMIMEType());
1863
1864     // Tell the client we've committed this URL.
1865     ASSERT(m_frame->view());
1866
1867     if (m_stateMachine.creatingInitialEmptyDocument())
1868         return;
1869
1870     if (!m_stateMachine.committedFirstRealDocumentLoad())
1871         m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocumentPostCommit);
1872 }
1873
1874 void FrameLoader::clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress)
1875 {
1876     // Note that -webView:didCancelClientRedirectForFrame: is called on the frame load delegate even if
1877     // the redirect succeeded.  We should either rename this API, or add a new method, like
1878     // -webView:didFinishClientRedirectForFrame:
1879     m_client->dispatchDidCancelClientRedirect();
1880
1881     if (!cancelWithLoadInProgress)
1882         m_quickRedirectComing = false;
1883
1884     m_sentRedirectNotification = false;
1885 }
1886
1887 void FrameLoader::clientRedirected(const KURL& url, double seconds, double fireDate, bool lockBackForwardList)
1888 {
1889     m_client->dispatchWillPerformClientRedirect(url, seconds, fireDate);
1890     
1891     // Remember that we sent a redirect notification to the frame load delegate so that when we commit
1892     // the next provisional load, we can send a corresponding -webView:didCancelClientRedirectForFrame:
1893     m_sentRedirectNotification = true;
1894     
1895     // If a "quick" redirect comes in, we set a special mode so we treat the next
1896     // load as part of the original navigation. If we don't have a document loader, we have
1897     // no "original" load on which to base a redirect, so we treat the redirect as a normal load.
1898     // Loads triggered by JavaScript form submissions never count as quick redirects.
1899     m_quickRedirectComing = (lockBackForwardList || history()->currentItemShouldBeReplaced()) && m_documentLoader && !m_isExecutingJavaScriptFormAction;
1900 }
1901
1902 bool FrameLoader::shouldReload(const KURL& currentURL, const KURL& destinationURL)
1903 {
1904     // This function implements the rule: "Don't reload if navigating by fragment within
1905     // the same URL, but do reload if going to a new URL or to the same URL with no
1906     // fragment identifier at all."
1907     if (!destinationURL.hasFragmentIdentifier())
1908         return true;
1909     return !equalIgnoringFragmentIdentifier(currentURL, destinationURL);
1910 }
1911
1912 void FrameLoader::closeOldDataSources()
1913 {
1914     // FIXME: Is it important for this traversal to be postorder instead of preorder?
1915     // If so, add helpers for postorder traversal, and use them. If not, then lets not
1916     // use a recursive algorithm here.
1917     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
1918         child->loader()->closeOldDataSources();
1919     
1920     if (m_documentLoader)
1921         m_client->dispatchWillClose();
1922
1923     m_client->setMainFrameDocumentReady(false); // stop giving out the actual DOMDocument to observers
1924 }
1925
1926 void FrameLoader::prepareForCachedPageRestore()
1927 {
1928     ASSERT(!m_frame->tree()->parent());
1929     ASSERT(m_frame->page());
1930     ASSERT(m_frame->page()->mainFrame() == m_frame);
1931
1932     m_frame->navigationScheduler()->cancel();
1933
1934     // We still have to close the previous part page.
1935     closeURL();
1936     
1937     // Delete old status bar messages (if it _was_ activated on last URL).
1938     if (m_frame->script()->canExecuteScripts(NotAboutToExecuteScript)) {
1939         DOMWindow* window = m_frame->document()->domWindow();
1940         window->setStatus(String());
1941         window->setDefaultStatus(String());
1942     }
1943 }
1944
1945 void FrameLoader::open(CachedFrameBase& cachedFrame)
1946 {
1947     m_isComplete = false;
1948     
1949     // Don't re-emit the load event.
1950     m_didCallImplicitClose = true;
1951
1952     KURL url = cachedFrame.url();
1953
1954     // FIXME: I suspect this block of code doesn't do anything.
1955     if (url.protocolIsInHTTPFamily() && !url.host().isEmpty() && url.path().isEmpty())
1956         url.setPath("/");
1957
1958     started();
1959     Document* document = cachedFrame.document();
1960     ASSERT(document);
1961     ASSERT(document->domWindow());
1962
1963     clear(document, true, true, cachedFrame.isMainFrame());
1964
1965     document->setInPageCache(false);
1966
1967     m_needsClear = true;
1968     m_isComplete = false;
1969     m_didCallImplicitClose = false;
1970     m_outgoingReferrer = url.string();
1971
1972     FrameView* view = cachedFrame.view();
1973     
1974     // When navigating to a CachedFrame its FrameView should never be null.  If it is we'll crash in creative ways downstream.
1975     ASSERT(view);
1976     view->setWasScrolledByUser(false);
1977
1978     // Use the current ScrollView's frame rect.
1979     if (m_frame->view())
1980         view->setFrameRect(m_frame->view()->frameRect());
1981     m_frame->setView(view);
1982     
1983     m_frame->setDocument(document);
1984     document->domWindow()->resumeFromPageCache();
1985
1986     updateFirstPartyForCookies();
1987
1988     cachedFrame.restore();
1989 }
1990
1991 bool FrameLoader::isHostedByObjectElement() const
1992 {
1993     HTMLFrameOwnerElement* owner = m_frame->ownerElement();
1994     return owner && owner->hasTagName(objectTag);
1995 }
1996
1997 bool FrameLoader::isLoadingMainFrame() const
1998 {
1999     Page* page = m_frame->page();
2000     return page && m_frame == page->mainFrame();
2001 }
2002
2003 bool FrameLoader::isReplacing() const
2004 {
2005     return m_loadType == FrameLoadTypeReplace;
2006 }
2007
2008 void FrameLoader::setReplacing()
2009 {
2010     m_loadType = FrameLoadTypeReplace;
2011 }
2012
2013 bool FrameLoader::subframeIsLoading() const
2014 {
2015     // It's most likely that the last added frame is the last to load so we walk backwards.
2016     for (Frame* child = m_frame->tree()->lastChild(); child; child = child->tree()->previousSibling()) {
2017         FrameLoader* childLoader = child->loader();
2018         DocumentLoader* documentLoader = childLoader->documentLoader();
2019         if (documentLoader && documentLoader->isLoadingInAPISense())
2020             return true;
2021         documentLoader = childLoader->provisionalDocumentLoader();
2022         if (documentLoader && documentLoader->isLoadingInAPISense())
2023             return true;
2024         documentLoader = childLoader->policyDocumentLoader();
2025         if (documentLoader)
2026             return true;
2027     }
2028     return false;
2029 }
2030
2031 void FrameLoader::willChangeTitle(DocumentLoader* loader)
2032 {
2033     m_client->willChangeTitle(loader);
2034 }
2035
2036 FrameLoadType FrameLoader::loadType() const
2037 {
2038     return m_loadType;
2039 }
2040     
2041 CachePolicy FrameLoader::subresourceCachePolicy() const
2042 {
2043     if (m_isComplete)
2044         return CachePolicyVerify;
2045
2046     if (m_loadType == FrameLoadTypeReloadFromOrigin)
2047         return CachePolicyReload;
2048
2049     if (Frame* parentFrame = m_frame->tree()->parent()) {
2050         CachePolicy parentCachePolicy = parentFrame->loader()->subresourceCachePolicy();
2051         if (parentCachePolicy != CachePolicyVerify)
2052             return parentCachePolicy;
2053     }
2054     
2055     if (m_loadType == FrameLoadTypeReload)
2056         return CachePolicyRevalidate;
2057
2058     const ResourceRequest& request(documentLoader()->request());
2059 #if PLATFORM(MAC)
2060     if (request.cachePolicy() == ReloadIgnoringCacheData && !equalIgnoringCase(request.httpMethod(), "post") && ResourceRequest::useQuickLookResourceCachingQuirks())
2061         return CachePolicyRevalidate;
2062 #endif
2063
2064     if (request.cachePolicy() == ReturnCacheDataElseLoad)
2065         return CachePolicyHistoryBuffer;
2066
2067     return CachePolicyVerify;
2068 }
2069
2070 void FrameLoader::checkLoadCompleteForThisFrame()
2071 {
2072     ASSERT(m_client->hasWebView());
2073
2074     Settings* settings = m_frame->settings();
2075
2076     switch (m_state) {
2077         case FrameStateProvisional: {
2078             if (m_delegateIsHandlingProvisionalLoadError)
2079                 return;
2080
2081             RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
2082             if (!pdl)
2083                 return;
2084                 
2085             // If we've received any errors we may be stuck in the provisional state and actually complete.
2086             const ResourceError& error = pdl->mainDocumentError();
2087             if (error.isNull())
2088                 return;
2089
2090             // Check all children first.
2091             RefPtr<HistoryItem> item;
2092             if (Page* page = m_frame->page())
2093                 if (isBackForwardLoadType(loadType()))
2094                     // Reset the back forward list to the last committed history item at the top level.
2095                     item = page->mainFrame()->loader()->history()->currentItem();
2096                 
2097             // Only reset if we aren't already going to a new provisional item.
2098             bool shouldReset = !history()->provisionalItem();
2099             if (!pdl->isLoadingInAPISense() || pdl->isStopping()) {
2100                 m_delegateIsHandlingProvisionalLoadError = true;
2101                 m_client->dispatchDidFailProvisionalLoad(error);
2102                 m_delegateIsHandlingProvisionalLoadError = false;
2103
2104                 ASSERT(!pdl->isLoading());
2105
2106                 // If we're in the middle of loading multipart data, we need to restore the document loader.
2107                 if (isReplacing() && !m_documentLoader.get())
2108                     setDocumentLoader(m_provisionalDocumentLoader.get());
2109
2110                 // Finish resetting the load state, but only if another load hasn't been started by the
2111                 // delegate callback.
2112                 if (pdl == m_provisionalDocumentLoader)
2113                     clearProvisionalLoad();
2114                 else if (activeDocumentLoader()) {
2115                     KURL unreachableURL = activeDocumentLoader()->unreachableURL();
2116                     if (!unreachableURL.isEmpty() && unreachableURL == pdl->request().url())
2117                         shouldReset = false;
2118                 }
2119             }
2120             if (shouldReset && item)
2121                 if (Page* page = m_frame->page()) {
2122                     page->backForward()->setCurrentItem(item.get());
2123                     m_frame->loader()->client()->updateGlobalHistoryItemForPage();
2124                 }
2125             return;
2126         }
2127         
2128         case FrameStateCommittedPage: {
2129             DocumentLoader* dl = m_documentLoader.get();            
2130             if (!dl || (dl->isLoadingInAPISense() && !dl->isStopping()))
2131                 return;
2132
2133             setState(FrameStateComplete);
2134
2135             // FIXME: Is this subsequent work important if we already navigated away?
2136             // Maybe there are bugs because of that, or extra work we can skip because
2137             // the new page is ready.
2138
2139             m_client->forceLayoutForNonHTML();
2140              
2141             // If the user had a scroll point, scroll to it, overriding the anchor point if any.
2142             if (m_frame->page()) {
2143                 if (isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadFromOrigin)
2144                     history()->restoreScrollPositionAndViewState();
2145             }
2146
2147             if (m_stateMachine.creatingInitialEmptyDocument() || !m_stateMachine.committedFirstRealDocumentLoad())
2148                 return;
2149
2150             if (!settings->needsDidFinishLoadOrderQuirk()) {
2151                 m_progressTracker->progressCompleted();
2152                 if (Page* page = m_frame->page()) {
2153                     if (m_frame == page->mainFrame())
2154                         page->resetRelevantPaintedObjectCounter();
2155                 }
2156             }
2157
2158             const ResourceError& error = dl->mainDocumentError();
2159
2160             AXObjectCache::AXLoadingEvent loadingEvent;
2161             if (!error.isNull()) {
2162                 m_client->dispatchDidFailLoad(error);
2163                 loadingEvent = AXObjectCache::AXLoadingFailed;
2164             } else {
2165                 m_client->dispatchDidFinishLoad();
2166                 loadingEvent = AXObjectCache::AXLoadingFinished;
2167             }
2168
2169             if (settings->needsDidFinishLoadOrderQuirk()) {
2170                 m_progressTracker->progressCompleted();
2171                 if (Page* page = m_frame->page()) {
2172                     if (m_frame == page->mainFrame())
2173                         page->resetRelevantPaintedObjectCounter();
2174                 }
2175             }
2176
2177             // Notify accessibility.
2178             if (AXObjectCache::accessibilityEnabled())
2179                 m_frame->document()->axObjectCache()->frameLoadingEventNotification(m_frame, loadingEvent);
2180
2181             return;
2182         }
2183         
2184         case FrameStateComplete:
2185             m_loadType = FrameLoadTypeStandard;
2186             frameLoadCompleted();
2187             return;
2188     }
2189
2190     ASSERT_NOT_REACHED();
2191 }
2192
2193 void FrameLoader::continueLoadAfterWillSubmitForm()
2194 {
2195     if (!m_provisionalDocumentLoader)
2196         return;
2197
2198     prepareForLoadStart();
2199     
2200     // The load might be cancelled inside of prepareForLoadStart(), nulling out the m_provisionalDocumentLoader, 
2201     // so we need to null check it again.
2202     if (!m_provisionalDocumentLoader)
2203         return;
2204
2205     DocumentLoader* activeDocLoader = activeDocumentLoader();
2206     if (activeDocLoader && activeDocLoader->isLoadingMainResource())
2207         return;
2208
2209     m_loadingFromCachedPage = false;
2210     m_provisionalDocumentLoader->startLoadingMainResource();
2211 }
2212
2213 static KURL originatingURLFromBackForwardList(Page* page)
2214 {
2215     // FIXME: Can this logic be replaced with m_frame->document()->firstPartyForCookies()?
2216     // It has the same meaning of "page a user thinks is the current one".
2217
2218     KURL originalURL;
2219     int backCount = page->backForward()->backCount();
2220     for (int backIndex = 0; backIndex <= backCount; backIndex++) {
2221         // FIXME: At one point we had code here to check a "was user gesture" flag.
2222         // Do we need to restore that logic?
2223         HistoryItem* historyItem = page->backForward()->itemAtIndex(-backIndex);
2224         if (!historyItem)
2225             continue;
2226
2227         originalURL = historyItem->originalURL(); 
2228         if (!originalURL.isNull()) 
2229             return originalURL;
2230     }
2231
2232     return KURL();
2233 }
2234
2235 void FrameLoader::setOriginalURLForDownloadRequest(ResourceRequest& request)
2236 {
2237     KURL originalURL;
2238     
2239     // If there is no referrer, assume that the download was initiated directly, so current document is
2240     // completely unrelated to it. See <rdar://problem/5294691>.
2241     // FIXME: Referrer is not sent in many other cases, so we will often miss this important information.
2242     // Find a better way to decide whether the download was unrelated to current document.
2243     if (!request.httpReferrer().isNull()) {
2244         // find the first item in the history that was originated by the user
2245         originalURL = originatingURLFromBackForwardList(m_frame->page());
2246     }
2247
2248     if (originalURL.isNull())
2249         originalURL = request.url();
2250
2251     if (!originalURL.protocol().isEmpty() && !originalURL.host().isEmpty()) {
2252         unsigned port = originalURL.port();
2253
2254         // Original URL is needed to show the user where a file was downloaded from. We should make a URL that won't result in downloading the file again.
2255         // FIXME: Using host-only URL is a very heavy-handed approach. We should attempt to provide the actual page where the download was initiated from, as a reminder to the user.
2256         String hostOnlyURLString;
2257         if (port)
2258             hostOnlyURLString = makeString(originalURL.protocol(), "://", originalURL.host(), ":", String::number(port));
2259         else
2260             hostOnlyURLString = makeString(originalURL.protocol(), "://", originalURL.host());
2261
2262         // FIXME: Rename firstPartyForCookies back to mainDocumentURL. It was a mistake to think that it was only used for cookies.
2263         request.setFirstPartyForCookies(KURL(KURL(), hostOnlyURLString));
2264     }
2265 }
2266
2267 void FrameLoader::didLayout(LayoutMilestones milestones)
2268 {
2269     m_client->dispatchDidLayout(milestones);
2270 }
2271
2272 void FrameLoader::didFirstLayout()
2273 {
2274     if (m_frame->page() && isBackForwardLoadType(m_loadType))
2275         history()->restoreScrollPositionAndViewState();
2276
2277     if (m_stateMachine.committedFirstRealDocumentLoad() && !m_stateMachine.isDisplayingInitialEmptyDocument() && !m_stateMachine.firstLayoutDone())
2278         m_stateMachine.advanceTo(FrameLoaderStateMachine::FirstLayoutDone);
2279 }
2280
2281 void FrameLoader::frameLoadCompleted()
2282 {
2283     // Note: Can be called multiple times.
2284
2285     m_client->frameLoadCompleted();
2286
2287     history()->updateForFrameLoadCompleted();
2288
2289     // After a canceled provisional load, firstLayoutDone is false.
2290     // Reset it to true if we're displaying a page.
2291     if (m_documentLoader && m_stateMachine.committedFirstRealDocumentLoad() && !m_stateMachine.isDisplayingInitialEmptyDocument() && !m_stateMachine.firstLayoutDone())
2292         m_stateMachine.advanceTo(FrameLoaderStateMachine::FirstLayoutDone);
2293 }
2294
2295 void FrameLoader::detachChildren()
2296 {
2297     typedef Vector<RefPtr<Frame> > FrameVector;
2298     FrameVector childrenToDetach;
2299     childrenToDetach.reserveCapacity(m_frame->tree()->childCount());
2300     for (Frame* child = m_frame->tree()->lastChild(); child; child = child->tree()->previousSibling())
2301         childrenToDetach.append(child);
2302     FrameVector::iterator end = childrenToDetach.end();
2303     for (FrameVector::iterator it = childrenToDetach.begin(); it != end; it++)
2304         (*it)->loader()->detachFromParent();
2305 }
2306
2307 void FrameLoader::closeAndRemoveChild(Frame* child)
2308 {
2309     child->tree()->detachFromParent();
2310
2311     child->setView(0);
2312     if (child->ownerElement() && child->page())
2313         child->page()->decrementSubframeCount();
2314     child->willDetachPage();
2315     child->detachFromPage();
2316
2317     m_frame->tree()->removeChild(child);
2318 }
2319
2320 // Called every time a resource is completely loaded or an error is received.
2321 void FrameLoader::checkLoadComplete()
2322 {
2323     ASSERT(m_client->hasWebView());
2324     
2325     m_shouldCallCheckLoadComplete = false;
2326
2327     // FIXME: Always traversing the entire frame tree is a bit inefficient, but 
2328     // is currently needed in order to null out the previous history item for all frames.
2329     if (Page* page = m_frame->page()) {
2330         Vector<RefPtr<Frame>, 10> frames;
2331         for (RefPtr<Frame> frame = page->mainFrame(); frame; frame = frame->tree()->traverseNext())
2332             frames.append(frame);
2333         // To process children before their parents, iterate the vector backwards.
2334         for (size_t i = frames.size(); i; --i)
2335             frames[i - 1]->loader()->checkLoadCompleteForThisFrame();
2336     }
2337 }
2338
2339 int FrameLoader::numPendingOrLoadingRequests(bool recurse) const
2340 {
2341     if (!recurse)
2342         return m_frame->document()->cachedResourceLoader()->requestCount();
2343
2344     int count = 0;
2345     for (Frame* frame = m_frame; frame; frame = frame->tree()->traverseNext(m_frame))
2346         count += frame->document()->cachedResourceLoader()->requestCount();
2347     return count;
2348 }
2349
2350 String FrameLoader::userAgent(const KURL& url) const
2351 {
2352     String userAgent = m_client->userAgent(url);
2353     InspectorInstrumentation::applyUserAgentOverride(m_frame, &userAgent);
2354     return userAgent;
2355 }
2356
2357 void FrameLoader::handledOnloadEvents()
2358 {
2359     m_client->dispatchDidHandleOnloadEvents();
2360
2361     if (documentLoader())
2362         documentLoader()->handledOnloadEvents();
2363 }
2364
2365 void FrameLoader::frameDetached()
2366 {
2367     stopAllLoaders();
2368     m_frame->document()->stopActiveDOMObjects();
2369     detachFromParent();
2370 }
2371
2372 void FrameLoader::detachFromParent()
2373 {
2374     RefPtr<Frame> protect(m_frame);
2375
2376     closeURL();
2377     history()->saveScrollPositionAndViewStateToItem(history()->currentItem());
2378     detachChildren();
2379     // stopAllLoaders() needs to be called after detachChildren(), because detachedChildren()
2380     // will trigger the unload event handlers of any child frames, and those event
2381     // handlers might start a new subresource load in this frame.
2382     stopAllLoaders();
2383
2384     InspectorInstrumentation::frameDetachedFromParent(m_frame);
2385
2386     detachViewsAndDocumentLoader();
2387
2388     m_progressTracker.clear();
2389
2390     if (Frame* parent = m_frame->tree()->parent()) {
2391         parent->loader()->closeAndRemoveChild(m_frame);
2392         parent->loader()->scheduleCheckCompleted();
2393     } else {
2394         m_frame->setView(0);
2395         m_frame->willDetachPage();
2396         m_frame->detachFromPage();
2397     }
2398 }
2399
2400 void FrameLoader::detachViewsAndDocumentLoader()
2401 {
2402     m_client->detachedFromParent2();
2403     setDocumentLoader(0);
2404     m_client->detachedFromParent3();
2405 }
2406     
2407 void FrameLoader::addExtraFieldsToSubresourceRequest(ResourceRequest& request)
2408 {
2409     addExtraFieldsToRequest(request, m_loadType, false);
2410 }
2411
2412 void FrameLoader::addExtraFieldsToMainResourceRequest(ResourceRequest& request)
2413 {
2414     addExtraFieldsToRequest(request, m_loadType, true);
2415 }
2416
2417 void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadType loadType, bool mainResource)
2418 {
2419     // Don't set the cookie policy URL if it's already been set.
2420     // But make sure to set it on all requests, as it has significance beyond the cookie policy for all protocols (<rdar://problem/6616664>).
2421     if (request.firstPartyForCookies().isEmpty()) {
2422         if (mainResource && isLoadingMainFrame())
2423             request.setFirstPartyForCookies(request.url());
2424         else if (Document* document = m_frame->document())
2425             request.setFirstPartyForCookies(document->firstPartyForCookies());
2426     }
2427
2428     // The remaining modifications are only necessary for HTTP and HTTPS.
2429     if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
2430         return;
2431
2432     applyUserAgent(request);
2433     
2434     // If we inherit cache policy from a main resource, we use the DocumentLoader's 
2435     // original request cache policy for two reasons:
2436     // 1. For POST requests, we mutate the cache policy for the main resource,
2437     //    but we do not want this to apply to subresources
2438     // 2. Delegates that modify the cache policy using willSendRequest: should
2439     //    not affect any other resources. Such changes need to be done
2440     //    per request.
2441     if (!mainResource) {
2442         if (request.isConditional())
2443             request.setCachePolicy(ReloadIgnoringCacheData);
2444         else if (documentLoader()->isLoadingInAPISense())
2445             request.setCachePolicy(documentLoader()->originalRequest().cachePolicy());
2446         else
2447             request.setCachePolicy(UseProtocolCachePolicy);
2448     } else if (loadType == FrameLoadTypeReload || loadType == FrameLoadTypeReloadFromOrigin || request.isConditional())
2449         request.setCachePolicy(ReloadIgnoringCacheData);
2450     else if (isBackForwardLoadType(loadType) && m_stateMachine.committedFirstRealDocumentLoad())
2451         request.setCachePolicy(ReturnCacheDataElseLoad);
2452         
2453     if (request.cachePolicy() == ReloadIgnoringCacheData) {
2454         if (loadType == FrameLoadTypeReload)
2455             request.setHTTPHeaderField("Cache-Control", "max-age=0");
2456         else if (loadType == FrameLoadTypeReloadFromOrigin) {
2457             request.setHTTPHeaderField("Cache-Control", "no-cache");
2458             request.setHTTPHeaderField("Pragma", "no-cache");
2459         }
2460     }
2461     
2462     if (mainResource)
2463         request.setHTTPAccept(defaultAcceptHeader);
2464
2465     // Make sure we send the Origin header.
2466     addHTTPOriginIfNeeded(request, String());
2467
2468     // Always try UTF-8. If that fails, try frame encoding (if any) and then the default.
2469     Settings* settings = m_frame->settings();
2470     request.setResponseContentDispositionEncodingFallbackArray("UTF-8", m_frame->document()->encoding(), settings ? settings->defaultTextEncodingName() : String());
2471 }
2472
2473 void FrameLoader::addHTTPOriginIfNeeded(ResourceRequest& request, const String& origin)
2474 {
2475     if (!request.httpOrigin().isEmpty())
2476         return;  // Request already has an Origin header.
2477
2478     // Don't send an Origin header for GET or HEAD to avoid privacy issues.
2479     // For example, if an intranet page has a hyperlink to an external web
2480     // site, we don't want to include the Origin of the request because it
2481     // will leak the internal host name. Similar privacy concerns have lead
2482     // to the widespread suppression of the Referer header at the network
2483     // layer.
2484     if (request.httpMethod() == "GET" || request.httpMethod() == "HEAD")
2485         return;
2486
2487     // For non-GET and non-HEAD methods, always send an Origin header so the
2488     // server knows we support this feature.
2489
2490     if (origin.isEmpty()) {
2491         // If we don't know what origin header to attach, we attach the value
2492         // for an empty origin.
2493         request.setHTTPOrigin(SecurityOrigin::createUnique()->toString());
2494         return;
2495     }
2496
2497     request.setHTTPOrigin(origin);
2498 }
2499
2500 void FrameLoader::loadPostRequest(const ResourceRequest& inRequest, const String& referrer, const String& frameName, bool lockHistory, FrameLoadType loadType, PassRefPtr<Event> event, PassRefPtr<FormState> prpFormState)
2501 {
2502     RefPtr<FormState> formState = prpFormState;
2503
2504     // Previously when this method was reached, the original FrameLoadRequest had been deconstructed to build a 
2505     // bunch of parameters that would come in here and then be built back up to a ResourceRequest.  In case
2506     // any caller depends on the immutability of the original ResourceRequest, I'm rebuilding a ResourceRequest
2507     // from scratch as it did all along.
2508     const KURL& url = inRequest.url();
2509     RefPtr<FormData> formData = inRequest.httpBody();
2510     const String& contentType = inRequest.httpContentType();
2511     String origin = inRequest.httpOrigin();
2512
2513     ResourceRequest workingResourceRequest(url);    
2514
2515     if (!referrer.isEmpty())
2516         workingResourceRequest.setHTTPReferrer(referrer);
2517     workingResourceRequest.setHTTPOrigin(origin);
2518     workingResourceRequest.setHTTPMethod("POST");
2519     workingResourceRequest.setHTTPBody(formData);
2520     workingResourceRequest.setHTTPContentType(contentType);
2521     addExtraFieldsToRequest(workingResourceRequest, loadType, true);
2522
2523     NavigationAction action(workingResourceRequest, loadType, true, event);
2524
2525     if (!frameName.isEmpty()) {
2526         // The search for a target frame is done earlier in the case of form submission.
2527         if (Frame* targetFrame = formState ? 0 : findFrameForNavigation(frameName))
2528             targetFrame->loader()->loadWithNavigationAction(workingResourceRequest, action, lockHistory, loadType, formState.release());
2529         else
2530             policyChecker()->checkNewWindowPolicy(action, FrameLoader::callContinueLoadAfterNewWindowPolicy, workingResourceRequest, formState.release(), frameName, this);
2531     } else {
2532         // must grab this now, since this load may stop the previous load and clear this flag
2533         bool isRedirect = m_quickRedirectComing;
2534         loadWithNavigationAction(workingResourceRequest, action, lockHistory, loadType, formState.release());    
2535         if (isRedirect) {
2536             m_quickRedirectComing = false;
2537             if (m_provisionalDocumentLoader)
2538                 m_provisionalDocumentLoader->setIsClientRedirect(true);
2539         }
2540     }
2541 }
2542
2543 unsigned long FrameLoader::loadResourceSynchronously(const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
2544 {
2545     ASSERT(m_frame->document());
2546     String referrer = SecurityPolicy::generateReferrerHeader(m_frame->document()->referrerPolicy(), request.url(), outgoingReferrer());
2547     
2548     ResourceRequest initialRequest = request;
2549     initialRequest.setTimeoutInterval(10);
2550     
2551     if (!referrer.isEmpty())
2552         initialRequest.setHTTPReferrer(referrer);
2553     addHTTPOriginIfNeeded(initialRequest, outgoingOrigin());
2554
2555     if (Page* page = m_frame->page())
2556         initialRequest.setFirstPartyForCookies(page->mainFrame()->loader()->documentLoader()->request().url());
2557     
2558     addExtraFieldsToSubresourceRequest(initialRequest);
2559
2560     unsigned long identifier = 0;    
2561     ResourceRequest newRequest(initialRequest);
2562     requestFromDelegate(newRequest, identifier, error);
2563
2564     if (error.isNull()) {
2565         ASSERT(!newRequest.isNull());
2566         
2567         if (!documentLoader()->applicationCacheHost()->maybeLoadSynchronously(newRequest, error, response, data)) {
2568             ResourceHandle::loadResourceSynchronously(networkingContext(), newRequest, storedCredentials, error, response, data);
2569             documentLoader()->applicationCacheHost()->maybeLoadFallbackSynchronously(newRequest, error, response, data);
2570         }
2571     }
2572     int encodedDataLength = response.resourceLoadInfo() ? static_cast<int>(response.resourceLoadInfo()->encodedDataLength) : -1;
2573     notifier()->sendRemainingDelegateMessages(m_documentLoader.get(), identifier, response, data.data(), data.size(), encodedDataLength, error);
2574     return identifier;
2575 }
2576
2577 const ResourceRequest& FrameLoader::originalRequest() const
2578 {
2579     return activeDocumentLoader()->originalRequestCopy();
2580 }
2581
2582 void FrameLoader::receivedMainResourceError(const ResourceError& error)
2583 {
2584     // Retain because the stop may release the last reference to it.
2585     RefPtr<Frame> protect(m_frame);
2586
2587     RefPtr<DocumentLoader> loader = activeDocumentLoader();
2588     // FIXME: Don't want to do this if an entirely new load is going, so should check
2589     // that both data sources on the frame are either this or nil.
2590     stop();
2591     if (m_client->shouldFallBack(error))
2592         handleFallbackContent();
2593
2594     if (m_state == FrameStateProvisional && m_provisionalDocumentLoader) {
2595         if (m_submittedFormURL == m_provisionalDocumentLoader->originalRequestCopy().url())
2596             m_submittedFormURL = KURL();
2597             
2598         // We might have made a page cache item, but now we're bailing out due to an error before we ever
2599         // transitioned to the new page (before WebFrameState == commit).  The goal here is to restore any state
2600         // so that the existing view (that wenever got far enough to replace) can continue being used.
2601         history()->invalidateCurrentItemCachedPage();
2602         
2603         // Call clientRedirectCancelledOrFinished here so that the frame load delegate is notified that the redirect's
2604         // status has changed, if there was a redirect. The frame load delegate may have saved some state about
2605         // the redirect in its -webView:willPerformClientRedirectToURL:delay:fireDate:forFrame:. Since we are definitely
2606         // not going to use this provisional resource, as it was cancelled, notify the frame load delegate that the redirect
2607         // has ended.
2608         if (m_sentRedirectNotification)
2609             clientRedirectCancelledOrFinished(false);
2610     }
2611
2612     checkCompleted();
2613     if (m_frame->page())
2614         checkLoadComplete();
2615 }
2616
2617 void FrameLoader::callContinueFragmentScrollAfterNavigationPolicy(void* argument,
2618     const ResourceRequest& request, PassRefPtr<FormState>, bool shouldContinue)
2619 {
2620     FrameLoader* loader = static_cast<FrameLoader*>(argument);
2621     loader->continueFragmentScrollAfterNavigationPolicy(request, shouldContinue);
2622 }
2623
2624 void FrameLoader::continueFragmentScrollAfterNavigationPolicy(const ResourceRequest& request, bool shouldContinue)
2625 {
2626     m_quickRedirectComing = false;
2627
2628     if (!shouldContinue)
2629         return;
2630
2631     // If we have a provisional request for a different document, a fragment scroll should cancel it.
2632     if (m_provisionalDocumentLoader && !equalIgnoringFragmentIdentifier(m_provisionalDocumentLoader->request().url(), request.url())) {
2633         m_provisionalDocumentLoader->stopLoading();
2634         setProvisionalDocumentLoader(0);
2635     }
2636
2637     bool isRedirect = m_quickRedirectComing || policyChecker()->loadType() == FrameLoadTypeRedirectWithLockedBackForwardList;    
2638     loadInSameDocument(request.url(), 0, !isRedirect);
2639 }
2640
2641 bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType loadType, const KURL& url)
2642 {
2643     // We don't do this if we are submitting a form with method other than "GET", explicitly reloading,
2644     // currently displaying a frameset, or if the URL does not have a fragment.
2645     // These rules were originally based on what KHTML was doing in KHTMLPart::openURL.
2646
2647     // FIXME: What about load types other than Standard and Reload?
2648
2649     return (!isFormSubmission || equalIgnoringCase(httpMethod, "GET"))
2650         && loadType != FrameLoadTypeReload
2651         && loadType != FrameLoadTypeReloadFromOrigin
2652         && loadType != FrameLoadTypeSame
2653         && !shouldReload(m_frame->document()->url(), url)
2654         // We don't want to just scroll if a link from within a
2655         // frameset is trying to reload the frameset into _top.
2656         && !m_frame->document()->isFrameSet();
2657 }
2658
2659 void FrameLoader::scrollToFragmentWithParentBoundary(const KURL& url)
2660 {
2661     FrameView* view = m_frame->view();
2662     if (!view)
2663         return;
2664
2665     // Leaking scroll position to a cross-origin ancestor would permit the so-called "framesniffing" attack.
2666     RefPtr<Frame> boundaryFrame(url.hasFragmentIdentifier() ? m_frame->document()->findUnsafeParentScrollPropagationBoundary() : 0);
2667
2668     if (boundaryFrame)
2669         boundaryFrame->view()->setSafeToPropagateScrollToParent(false);
2670
2671     view->scrollToFragment(url);
2672
2673     if (boundaryFrame)
2674         boundaryFrame->view()->setSafeToPropagateScrollToParent(true);
2675 }
2676
2677 void FrameLoader::callContinueLoadAfterNavigationPolicy(void* argument,
2678     const ResourceRequest& request, PassRefPtr<FormState> formState, bool shouldContinue)
2679 {
2680     FrameLoader* loader = static_cast<FrameLoader*>(argument);
2681     loader->continueLoadAfterNavigationPolicy(request, formState, shouldContinue);
2682 }
2683
2684 bool FrameLoader::shouldClose()
2685 {
2686     Page* page = m_frame->page();
2687     Chrome* chrome = page ? page->chrome() : 0;
2688     if (!chrome || !chrome->canRunBeforeUnloadConfirmPanel())
2689         return true;
2690
2691     // Store all references to each subframe in advance since beforeunload's event handler may modify frame
2692     Vector<RefPtr<Frame> > targetFrames;
2693     targetFrames.append(m_frame);
2694     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->traverseNext(m_frame))
2695         targetFrames.append(child);
2696
2697     bool shouldClose = false;
2698     {
2699         NavigationDisablerForBeforeUnload navigationDisabler;
2700         size_t i;
2701
2702         for (i = 0; i < targetFrames.size(); i++) {
2703             if (!targetFrames[i]->tree()->isDescendantOf(m_frame))
2704                 continue;
2705             if (!targetFrames[i]->loader()->fireBeforeUnloadEvent(chrome))
2706                 break;
2707         }
2708
2709         if (i == targetFrames.size())
2710             shouldClose = true;
2711     }
2712
2713     if (!shouldClose)
2714         m_submittedFormURL = KURL();
2715
2716     return shouldClose;
2717 }
2718
2719 bool FrameLoader::fireBeforeUnloadEvent(Chrome* chrome)
2720 {
2721     DOMWindow* domWindow = m_frame->document()->domWindow();
2722     if (!domWindow)
2723         return true;
2724
2725     RefPtr<Document> document = m_frame->document();
2726     if (!document->body())
2727         return true;
2728
2729     RefPtr<BeforeUnloadEvent> beforeUnloadEvent = BeforeUnloadEvent::create();
2730     m_pageDismissalEventBeingDispatched = BeforeUnloadDismissal;
2731     domWindow->dispatchEvent(beforeUnloadEvent.get(), domWindow->document());
2732     m_pageDismissalEventBeingDispatched = NoDismissal;
2733
2734     if (!beforeUnloadEvent->defaultPrevented())
2735         document->defaultEventHandler(beforeUnloadEvent.get());
2736     if (beforeUnloadEvent->result().isNull())
2737         return true;
2738
2739     String text = document->displayStringModifiedByEncoding(beforeUnloadEvent->result());
2740     return chrome->runBeforeUnloadConfirmPanel(text, m_frame);
2741 }
2742
2743 void FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState> formState, bool shouldContinue)
2744 {
2745     // If we loaded an alternate page to replace an unreachableURL, we'll get in here with a
2746     // nil policyDataSource because loading the alternate page will have passed
2747     // through this method already, nested; otherwise, policyDataSource should still be set.
2748     ASSERT(m_policyDocumentLoader || !m_provisionalDocumentLoader->unreachableURL().isEmpty());
2749
2750     bool isTargetItem = history()->provisionalItem() ? history()->provisionalItem()->isTargetItem() : false;
2751
2752     // Two reasons we can't continue:
2753     //    1) Navigation policy delegate said we can't so request is nil. A primary case of this 
2754     //       is the user responding Cancel to the form repost nag sheet.
2755     //    2) User responded Cancel to an alert popped up by the before unload event handler.
2756     bool canContinue = shouldContinue && shouldClose();
2757
2758     if (!canContinue) {
2759         // If we were waiting for a quick redirect, but the policy delegate decided to ignore it, then we 
2760         // need to report that the client redirect was cancelled.
2761         if (m_quickRedirectComing)
2762             clientRedirectCancelledOrFinished(false);
2763
2764         setPolicyDocumentLoader(0);
2765
2766         // If the navigation request came from the back/forward menu, and we punt on it, we have the 
2767         // problem that we have optimistically moved the b/f cursor already, so move it back.  For sanity, 
2768         // we only do this when punting a navigation for the target frame or top-level frame.  
2769         if ((isTargetItem || isLoadingMainFrame()) && isBackForwardLoadType(policyChecker()->loadType())) {
2770             if (Page* page = m_frame->page()) {
2771                 Frame* mainFrame = page->mainFrame();
2772                 if (HistoryItem* resetItem = mainFrame->loader()->history()->currentItem()) {
2773                     page->backForward()->setCurrentItem(resetItem);
2774                     m_frame->loader()->client()->updateGlobalHistoryItemForPage();
2775                 }
2776             }
2777         }
2778         return;
2779     }
2780
2781     FrameLoadType type = policyChecker()->loadType();
2782     // A new navigation is in progress, so don't clear the history's provisional item.
2783     stopAllLoaders(ShouldNotClearProvisionalItem);
2784     
2785     // <rdar://problem/6250856> - In certain circumstances on pages with multiple frames, stopAllLoaders()
2786     // might detach the current FrameLoader, in which case we should bail on this newly defunct load. 
2787     if (!m_frame->page())
2788         return;
2789
2790 #if ENABLE(JAVASCRIPT_DEBUGGER) && ENABLE(INSPECTOR)
2791     if (Page* page = m_frame->page()) {
2792         if (page->mainFrame() == m_frame)
2793             m_frame->page()->inspectorController()->resume();
2794     }
2795 #endif
2796
2797     setProvisionalDocumentLoader(m_policyDocumentLoader.get());
2798     m_loadType = type;
2799     setState(FrameStateProvisional);
2800
2801     setPolicyDocumentLoader(0);
2802
2803     if (isBackForwardLoadType(type) && history()->provisionalItem()->isInPageCache()) {
2804         loadProvisionalItemFromCachedPage();
2805         return;
2806     }
2807
2808     if (formState)
2809         m_client->dispatchWillSubmitForm(&PolicyChecker::continueLoadAfterWillSubmitForm, formState);
2810     else
2811         continueLoadAfterWillSubmitForm();
2812 }
2813
2814 void FrameLoader::callContinueLoadAfterNewWindowPolicy(void* argument,
2815     const ResourceRequest& request, PassRefPtr<FormState> formState, const String& frameName, const NavigationAction& action, bool shouldContinue)
2816 {
2817     FrameLoader* loader = static_cast<FrameLoader*>(argument);
2818     loader->continueLoadAfterNewWindowPolicy(request, formState, frameName, action, shouldContinue);
2819 }
2820
2821 void FrameLoader::continueLoadAfterNewWindowPolicy(const ResourceRequest& request,
2822     PassRefPtr<FormState> formState, const String& frameName, const NavigationAction& action, bool shouldContinue)
2823 {
2824     if (!shouldContinue)
2825         return;
2826
2827     RefPtr<Frame> frame = m_frame;
2828     RefPtr<Frame> mainFrame = m_client->dispatchCreatePage(action);
2829     if (!mainFrame)
2830         return;
2831
2832     if (frameName != "_blank")
2833         mainFrame->tree()->setName(frameName);
2834
2835     mainFrame->page()->setOpenedByDOM();
2836     mainFrame->loader()->m_client->dispatchShow();
2837     if (!m_suppressOpenerInNewFrame) {
2838         mainFrame->loader()->setOpener(frame.get());
2839         mainFrame->document()->setReferrerPolicy(frame->document()->referrerPolicy());
2840     }
2841     mainFrame->loader()->loadWithNavigationAction(request, NavigationAction(request), false, FrameLoadTypeStandard, formState);
2842 }
2843
2844 void FrameLoader::requestFromDelegate(ResourceRequest& request, unsigned long& identifier, ResourceError& error)
2845 {
2846     ASSERT(!request.isNull());
2847
2848     identifier = 0;
2849     if (Page* page = m_frame->page()) {
2850         identifier = page->progress()->createUniqueIdentifier();
2851         notifier()->assignIdentifierToInitialRequest(identifier, m_documentLoader.get(), request);
2852     }
2853
2854     ResourceRequest newRequest(request);
2855     notifier()->dispatchWillSendRequest(m_documentLoader.get(), identifier, newRequest, ResourceResponse());
2856
2857     if (newRequest.isNull())
2858         error = cancelledError(request);
2859     else
2860         error = ResourceError();
2861
2862     request = newRequest;
2863 }
2864
2865 void FrameLoader::loadedResourceFromMemoryCache(CachedResource* resource)
2866 {
2867     Page* page = m_frame->page();
2868     if (!page)
2869         return;
2870
2871     if (!resource->shouldSendResourceLoadCallbacks() || m_documentLoader->haveToldClientAboutLoad(resource->url()))
2872         return;
2873
2874     if (!page->areMemoryCacheClientCallsEnabled()) {
2875         InspectorInstrumentation::didLoadResourceFromMemoryCache(page, m_documentLoader.get(), resource);
2876         m_documentLoader->recordMemoryCacheLoadForFutureClientNotification(resource->url());
2877         m_documentLoader->didTellClientAboutLoad(resource->url());
2878         return;
2879     }
2880
2881     ResourceRequest request(resource->url());
2882     if (m_client->dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), request, resource->response(), resource->encodedSize())) {
2883         InspectorInstrumentation::didLoadResourceFromMemoryCache(page, m_documentLoader.get(), resource);
2884         m_documentLoader->didTellClientAboutLoad(resource->url());
2885         return;
2886     }
2887
2888     unsigned long identifier;
2889     ResourceError error;
2890     requestFromDelegate(request, identifier, error);
2891     InspectorInstrumentation::markResourceAsCached(page, identifier);
2892     notifier()->sendRemainingDelegateMessages(m_documentLoader.get(), identifier, resource->response(), 0, resource->encodedSize(), 0, error);
2893 }
2894
2895 void FrameLoader::applyUserAgent(ResourceRequest& request)
2896 {
2897     String userAgent = this->userAgent(request.url());
2898     ASSERT(!userAgent.isNull());
2899     request.setHTTPUserAgent(userAgent);
2900 }
2901
2902 bool FrameLoader::shouldInterruptLoadForXFrameOptions(const String& content, const KURL& url, unsigned long requestIdentifier)
2903 {
2904     Frame* topFrame = m_frame->tree()->top();
2905     if (m_frame == topFrame)
2906         return false;
2907
2908     if (equalIgnoringCase(content, "deny"))
2909         return true;
2910     else if (equalIgnoringCase(content, "sameorigin")) {
2911         RefPtr<SecurityOrigin> origin = SecurityOrigin::create(url);
2912         if (!origin->isSameSchemeHostPort(topFrame->document()->securityOrigin()))
2913             return true;
2914     } else {
2915         String message = "Invalid 'X-Frame-Options' header encountered when loading '" + url.string() + "': '" + content + "' is not a recognized directive. The header will be ignored.";
2916         m_frame->document()->addConsoleMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, message, url.string(), 0, 0, requestIdentifier);
2917     }
2918
2919     return false;
2920 }
2921
2922 void FrameLoader::loadProvisionalItemFromCachedPage()
2923 {
2924     DocumentLoader* provisionalLoader = provisionalDocumentLoader();
2925     LOG(PageCache, "WebCorePageCache: Loading provisional DocumentLoader %p with URL '%s' from CachedPage", provisionalDocumentLoader(), provisionalDocumentLoader()->url().string().utf8().data());
2926
2927     prepareForLoadStart();
2928
2929     m_loadingFromCachedPage = true;
2930
2931     // Should have timing data from previous time(s) the page was shown.
2932     ASSERT(provisionalLoader->timing()->navigationStart());
2933     provisionalLoader->resetTiming();
2934     provisionalLoader->timing()->markNavigationStart();
2935
2936     provisionalLoader->setCommitted(true);
2937     commitProvisionalLoad();
2938 }
2939
2940 bool FrameLoader::shouldTreatURLAsSameAsCurrent(const KURL& url) const
2941 {
2942     if (!history()->currentItem())
2943         return false;
2944     return url == history()->currentItem()->url() || url == history()->currentItem()->originalURL();
2945 }
2946
2947 bool FrameLoader::shouldTreatURLAsSrcdocDocument(const KURL& url) const
2948 {
2949     if (!equalIgnoringCase(url.string(), "about:srcdoc"))
2950         return false;
2951     HTMLFrameOwnerElement* ownerElement = m_frame->ownerElement();
2952     if (!ownerElement)
2953         return false;
2954     if (!ownerElement->hasTagName(iframeTag))
2955         return false;
2956     return ownerElement->fastHasAttribute(srcdocAttr);
2957 }
2958
2959 void FrameLoader::checkDidPerformFirstNavigation()
2960 {
2961     Page* page = m_frame->page();
2962     if (!page)
2963         return;
2964
2965     if (!m_didPerformFirstNavigation && page->backForward()->currentItem() && !page->backForward()->backItem() && !page->backForward()->forwardItem()) {
2966         m_didPerformFirstNavigation = true;
2967         m_client->didPerformFirstNavigation();
2968     }
2969 }
2970
2971 Frame* FrameLoader::findFrameForNavigation(const AtomicString& name, Document* activeDocument)
2972 {
2973     Frame* frame = m_frame->tree()->find(name);
2974
2975     // From http://www.whatwg.org/specs/web-apps/current-work/#seamlessLinks:
2976     //
2977     // If the source browsing context is the same as the browsing context
2978     // being navigated, and this browsing context has its seamless browsing
2979     // context flag set, and the browsing context being navigated was not
2980     // chosen using an explicit self-navigation override, then find the
2981     // nearest ancestor browsing context that does not have its seamless
2982     // browsing context flag set, and continue these steps as if that
2983     // browsing context was the one that was going to be navigated instead.
2984     if (frame == m_frame && name != "_self" && m_frame->document()->shouldDisplaySeamlesslyWithParent()) {
2985         for (Frame* ancestor = m_frame; ancestor; ancestor = ancestor->tree()->parent()) {
2986             if (!ancestor->document()->shouldDisplaySeamlesslyWithParent()) {
2987                 frame = ancestor;
2988                 break;
2989             }
2990         }
2991         ASSERT(frame != m_frame);
2992     }
2993
2994     if (activeDocument) {
2995         if (!activeDocument->canNavigate(frame))
2996             return 0;
2997     } else {
2998         // FIXME: Eventually all callers should supply the actual activeDocument
2999         // so we can call canNavigate with the right document.
3000         if (!m_frame->document()->canNavigate(frame))
3001             return 0;
3002     }
3003
3004     return frame;
3005 }
3006
3007 void FrameLoader::loadSameDocumentItem(HistoryItem* item)
3008 {
3009     ASSERT(item->documentSequenceNumber() == history()->currentItem()->documentSequenceNumber());
3010
3011     // Save user view state to the current history item here since we don't do a normal load.
3012     // FIXME: Does form state need to be saved here too?
3013     history()->saveScrollPositionAndViewStateToItem(history()->currentItem());
3014     if (FrameView* view = m_frame->view())
3015         view->setWasScrolledByUser(false);
3016
3017     history()->setCurrentItem(item);
3018         
3019     // loadInSameDocument() actually changes the URL and notifies load delegates of a "fake" load
3020     loadInSameDocument(item->url(), item->stateObject(), false);
3021
3022     // Restore user view state from the current history item here since we don't do a normal load.
3023     history()->restoreScrollPositionAndViewState();
3024 }
3025
3026 // FIXME: This function should really be split into a couple pieces, some of
3027 // which should be methods of HistoryController and some of which should be
3028 // methods of FrameLoader.
3029 void FrameLoader::loadDifferentDocumentItem(HistoryItem* item, FrameLoadType loadType)
3030 {
3031     // Remember this item so we can traverse any child items as child frames load
3032     history()->setProvisionalItem(item);
3033
3034     if (CachedPage* cachedPage = pageCache()->get(item)) {
3035         loadWithDocumentLoader(cachedPage->documentLoader(), loadType, 0);   
3036         return;
3037     }
3038
3039     KURL itemURL = item->url();
3040     KURL itemOriginalURL = item->originalURL();
3041     KURL currentURL;
3042     if (documentLoader())
3043         currentURL = documentLoader()->url();
3044     RefPtr<FormData> formData = item->formData();
3045
3046     ResourceRequest request(itemURL);
3047
3048     if (!item->referrer().isNull())
3049         request.setHTTPReferrer(item->referrer());
3050     
3051     // If this was a repost that failed the page cache, we might try to repost the form.
3052     NavigationAction action;
3053     if (formData) {
3054         formData->generateFiles(m_frame->document());
3055
3056         request.setHTTPMethod("POST");
3057         request.setHTTPBody(formData);
3058         request.setHTTPContentType(item->formContentType());
3059         RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item->referrer());
3060         addHTTPOriginIfNeeded(request, securityOrigin->toString());
3061
3062         // Make sure to add extra fields to the request after the Origin header is added for the FormData case.
3063         // See https://bugs.webkit.org/show_bug.cgi?id=22194 for more discussion.
3064         addExtraFieldsToRequest(request, m_loadType, true);
3065         
3066         // FIXME: Slight hack to test if the NSURL cache contains the page we're going to.
3067         // We want to know this before talking to the policy delegate, since it affects whether 
3068         // we show the DoYouReallyWantToRepost nag.
3069         //
3070         // This trick has a small bug (3123893) where we might find a cache hit, but then
3071         // have the item vanish when we try to use it in the ensuing nav.  This should be
3072         // extremely rare, but in that case the user will get an error on the navigation.
3073         
3074         if (ResourceHandle::willLoadFromCache(request, m_frame))
3075             action = NavigationAction(request, loadType, false);
3076         else {
3077             request.setCachePolicy(ReloadIgnoringCacheData);
3078             action = NavigationAction(request, NavigationTypeFormResubmitted);
3079         }
3080     } else {
3081         switch (loadType) {
3082             case FrameLoadTypeReload:
3083             case FrameLoadTypeReloadFromOrigin:
3084                 request.setCachePolicy(ReloadIgnoringCacheData);
3085                 break;
3086             case FrameLoadTypeBack:
3087             case FrameLoadTypeForward:
3088             case FrameLoadTypeIndexedBackForward:
3089                 // If the first load within a frame is a navigation within a back/forward list that was attached 
3090                 // without any of the items being loaded then we should use the default caching policy (<rdar://problem/8131355>).
3091                 if (m_stateMachine.committedFirstRealDocumentLoad() && !itemURL.protocolIs("https"))
3092                     request.setCachePolicy(ReturnCacheDataElseLoad);
3093                 break;
3094             case FrameLoadTypeStandard:
3095             case FrameLoadTypeRedirectWithLockedBackForwardList:
3096                 break;
3097             case FrameLoadTypeSame:
3098             default:
3099                 ASSERT_NOT_REACHED();
3100         }
3101
3102         addExtraFieldsToRequest(request, m_loadType, true);
3103
3104         ResourceRequest requestForOriginalURL(request);
3105         requestForOriginalURL.setURL(itemOriginalURL);
3106         action = NavigationAction(requestForOriginalURL, loadType, false);
3107     }
3108
3109     loadWithNavigationAction(request, action, false, loadType, 0);
3110 }
3111
3112 // Loads content into this frame, as specified by history item
3113 void FrameLoader::loadItem(HistoryItem* item, FrameLoadType loadType)
3114 {
3115     m_requestedHistoryItem = item;
3116     HistoryItem* currentItem = history()->currentItem();
3117     bool sameDocumentNavigation = currentItem && item->shouldDoSameDocumentNavigationTo(currentItem);
3118
3119     if (sameDocumentNavigation)
3120         loadSameDocumentItem(item);
3121     else
3122         loadDifferentDocumentItem(item, loadType);
3123 }
3124
3125 ResourceError FrameLoader::cancelledError(const ResourceRequest& request) const
3126 {
3127     ResourceError error = m_client->cancelledError(request);
3128     error.setIsCancellation(true);
3129     return error;
3130 }
3131
3132 void FrameLoader::setTitle(const StringWithDirection& title)
3133 {
3134     documentLoader()->setTitle(title);
3135 }
3136
3137 String FrameLoader::referrer() const
3138 {
3139     return m_documentLoader ? m_documentLoader->request().httpReferrer() : "";
3140 }
3141
3142 void FrameLoader::dispatchDocumentElementAvailable()
3143 {
3144     m_frame->injectUserScripts(InjectAtDocumentStart);
3145     m_client->documentElementAvailable();
3146 }
3147
3148 void FrameLoader::dispatchDidClearWindowObjectsInAllWorlds()
3149 {
3150     if (!m_frame->script()->canExecuteScripts(NotAboutToExecuteScript))
3151         return;
3152
3153     Vector<RefPtr<DOMWrapperWorld> > worlds;
3154     ScriptController::getAllWorlds(worlds);
3155     for (size_t i = 0; i < worlds.size(); ++i)
3156         dispatchDidClearWindowObjectInWorld(worlds[i].get());
3157 }
3158
3159 void FrameLoader::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
3160 {
3161     if (!m_frame->script()->canExecuteScripts(NotAboutToExecuteScript) || !m_frame->script()->existingWindowShell(world))
3162         return;
3163
3164     m_client->dispatchDidClearWindowObjectInWorld(world);
3165
3166 #if ENABLE(INSPECTOR)
3167     if (Page* page = m_frame->page())
3168         page->inspectorController()->didClearWindowObjectInWorld(m_frame, world);
3169 #endif
3170
3171     InspectorInstrumentation::didClearWindowObjectInWorld(m_frame, world);
3172 }
3173
3174 void FrameLoader::dispatchGlobalObjectAvailableInAllWorlds()
3175 {
3176     Vector<RefPtr<DOMWrapperWorld> > worlds;
3177     ScriptController::getAllWorlds(worlds);
3178     for (size_t i = 0; i < worlds.size(); ++i)
3179         m_client->dispatchGlobalObjectAvailable(worlds[i].get());
3180 }
3181
3182 SandboxFlags FrameLoader::effectiveSandboxFlags() const
3183 {
3184     SandboxFlags flags = m_forcedSandboxFlags;
3185     if (Frame* parentFrame = m_frame->tree()->parent())
3186         flags |= parentFrame->document()->sandboxFlags();
3187     if (HTMLFrameOwnerElement* ownerElement = m_frame->ownerElement())
3188         flags |= ownerElement->sandboxFlags();
3189     return flags;
3190 }
3191
3192 void FrameLoader::didChangeTitle(DocumentLoader* loader)
3193 {
3194     m_client->didChangeTitle(loader);
3195
3196     if (loader == m_documentLoader) {
3197         // Must update the entries in the back-forward list too.
3198         history()->setCurrentItemTitle(loader->title());
3199         // This must go through the WebFrame because it has the right notion of the current b/f item.
3200         m_client->setTitle(loader->title(), loader->urlForHistory());
3201         m_client->setMainFrameDocumentReady(true); // update observers with new DOMDocument
3202         m_client->dispatchDidReceiveTitle(loader->title());
3203     }
3204 }
3205
3206 void FrameLoader::didChangeIcons(IconType type)
3207 {
3208     m_client->dispatchDidChangeIcons(type);
3209 }
3210
3211 void FrameLoader::dispatchDidCommitLoad()
3212 {
3213     if (m_stateMachine.creatingInitialEmptyDocument())
3214         return;
3215
3216     m_client->dispatchDidCommitLoad();
3217
3218     if (isLoadingMainFrame()) {
3219         m_frame->page()->resetSeenPlugins();
3220         m_frame->page()->resetSeenMediaEngines();
3221     }
3222
3223     InspectorInstrumentation::didCommitLoad(m_frame, m_documentLoader.get());
3224 }
3225
3226 void FrameLoader::tellClientAboutPastMemoryCacheLoads()
3227 {
3228     ASSERT(m_frame->page());
3229     ASSERT(m_frame->page()->areMemoryCacheClientCallsEnabled());
3230
3231     if (!m_documentLoader)
3232         return;
3233
3234     Vector<String> pastLoads;
3235     m_documentLoader->takeMemoryCacheLoadsForClientNotification(pastLoads);
3236
3237     size_t size = pastLoads.size();
3238     for (size_t i = 0; i < size; ++i) {
3239         CachedResource* resource = memoryCache()->resourceForURL(KURL(ParsedURLString, pastLoads[i]));
3240
3241         // FIXME: These loads, loaded from cache, but now gone from the cache by the time
3242         // Page::setMemoryCacheClientCallsEnabled(true) is called, will not be seen by the client.
3243         // Consider if there's some efficient way of remembering enough to deliver this client call.
3244         // We have the URL, but not the rest of the response or the length.
3245         if (!resource)
3246             continue;
3247
3248         ResourceRequest request(resource->url());
3249         m_client->dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), request, resource->response(), resource->encodedSize());
3250     }
3251 }
3252
3253 NetworkingContext* FrameLoader::networkingContext() const
3254 {
3255     return m_networkingContext.get();
3256 }
3257
3258 void FrameLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
3259 {
3260     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::Loader);
3261     info.addMember(m_documentLoader);
3262     info.addMember(m_provisionalDocumentLoader);
3263     info.addMember(m_policyDocumentLoader);
3264     info.addMember(m_outgoingReferrer);
3265     info.addMember(m_openedFrames);
3266 }
3267
3268 bool FrameLoaderClient::hasHTMLView() const
3269 {
3270     return true;
3271 }
3272
3273 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest& request, const WindowFeatures& features, bool& created)
3274 {
3275     ASSERT(!features.dialog || request.frameName().isEmpty());
3276
3277     if (!request.frameName().isEmpty() && request.frameName() != "_blank") {
3278         if (Frame* frame = lookupFrame->loader()->findFrameForNavigation(request.frameName(), openerFrame->document())) {
3279             if (Page* page = frame->page())
3280                 page->chrome()->focus();
3281             created = false;
3282             return frame;
3283         }
3284     }
3285
3286     // Sandboxed frames cannot open new auxiliary browsing contexts.
3287     if (isDocumentSandboxed(openerFrame, SandboxPopups))
3288         return 0;
3289
3290     // FIXME: Setting the referrer should be the caller's responsibility.
3291     FrameLoadRequest requestWithReferrer = request;
3292     requestWithReferrer.resourceRequest().setHTTPReferrer(openerFrame->loader()->outgoingReferrer());
3293     FrameLoader::addHTTPOriginIfNeeded(requestWithReferrer.resourceRequest(), openerFrame->loader()->outgoingOrigin());
3294
3295     if (openerFrame->settings() && !openerFrame->settings()->supportsMultipleWindows()) {
3296         created = false;
3297         return openerFrame;
3298     }
3299
3300     Page* oldPage = openerFrame->page();
3301     if (!oldPage)
3302         return 0;
3303
3304     NavigationAction action(requestWithReferrer.resourceRequest());
3305     Page* page = oldPage->chrome()->createWindow(openerFrame, requestWithReferrer, features, action);
3306     if (!page)
3307         return 0;
3308
3309     Frame* frame = page->mainFrame();
3310
3311     frame->loader()->forceSandboxFlags(openerFrame->document()->sandboxFlags());
3312
3313     if (request.frameName() != "_blank")
3314         frame->tree()->setName(request.frameName());
3315
3316     page->chrome()->setToolbarsVisible(features.toolBarVisible || features.locationBarVisible);
3317     page->chrome()->setStatusbarVisible(features.statusBarVisible);
3318     page->chrome()->setScrollbarsVisible(features.scrollbarsVisible);
3319     page->chrome()->setMenubarVisible(features.menuBarVisible);
3320     page->chrome()->setResizable(features.resizable);
3321
3322     // 'x' and 'y' specify the location of the window, while 'width' and 'height'
3323     // specify the size of the viewport. We can only resize the window, so adjust
3324     // for the difference between the window size and the viewport size.
3325
3326     FloatRect windowRect = page->chrome()->windowRect();
3327     FloatSize viewportSize = page->chrome()->pageRect().size();
3328
3329     if (features.xSet)
3330         windowRect.setX(features.x);
3331     if (features.ySet)
3332         windowRect.setY(features.y);
3333     if (features.widthSet)
3334         windowRect.setWidth(features.width + (windowRect.width() - viewportSize.width()));
3335     if (features.heightSet)
3336         windowRect.setHeight(features.height + (windowRect.height() - viewportSize.height()));
3337
3338     // Ensure non-NaN values, minimum size as well as being within valid screen area.
3339     FloatRect newWindowRect = DOMWindow::adjustWindowRect(page, windowRect);
3340
3341     page->chrome()->setWindowRect(newWindowRect);
3342     page->chrome()->show();
3343
3344     created = true;
3345     return frame;
3346 }
3347
3348 } // namespace WebCore