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