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