fix a crash on exit
[WebKit-https.git] / WebKitQt / WebCoreSupport / FrameLoaderClientQt.cpp
1 /*
2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
3  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
4  * Copyright (C) 2007 Trolltech ASA
5  *
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "FrameLoaderClientQt.h"
32 #include "FrameTree.h"
33 #include "FrameView.h"
34 #include "DocumentLoader.h"
35 #include "ResourceResponse.h"
36 #include "Page.h"
37 #include "ProgressTracker.h"
38 #include "ResourceRequest.h"
39
40 #include "qwebpage.h"
41 #include "qwebframe.h"
42 #include "qwebframe_p.h"
43
44 #include "qdebug.h"
45
46 #define notImplemented() qDebug("FIXME: UNIMPLEMENTED: %s:%d (%s)", __FILE__, __LINE__, __FUNCTION__)
47 #define methodDebug() qDebug("FrameLoaderClientQt: %s loader=%p", __FUNCTION__, (m_frame ? m_frame->loader() : 0))
48
49 namespace WebCore
50 {
51
52 FrameLoaderClientQt::FrameLoaderClientQt()
53     : m_frame(0)
54     , m_webFrame(0)
55     , m_firstData(false)
56     , m_policyFunction(0)
57 {
58     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
59 }
60
61
62 FrameLoaderClientQt::~FrameLoaderClientQt()
63 {
64 }
65
66 void FrameLoaderClientQt::setFrame(QWebFrame *webFrame, FrameQt *frame)
67 {
68     m_webFrame = webFrame;
69     m_frame = frame;
70     if (!m_webFrame || !m_webFrame->page()) {
71         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
72         return;
73     }
74
75     connect(this, SIGNAL(loadStarted(QWebFrame*)),
76             m_webFrame->page(), SIGNAL(loadStarted(QWebFrame *)));
77     connect(this, SIGNAL(loadProgressChanged(double)),
78             m_webFrame->page(), SIGNAL(loadProgressChanged(double)));
79     connect(this, SIGNAL(loadFinished(QWebFrame*)),
80             m_webFrame->page(), SIGNAL(loadFinished(QWebFrame *)));
81     connect(this, SIGNAL(titleChanged(const QString&)),
82             m_webFrame, SIGNAL(titleChanged(const QString&)));
83 }
84
85 QWebFrame *FrameLoaderClientQt::webFrame() const
86 {
87     return m_webFrame;
88 }
89
90 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
91 {
92     qDebug() << "FrameLoaderClientQt::callPolicyFunction";
93     ASSERT(!m_policyFunction);
94
95     m_policyFunction = function;
96     emit sigCallPolicyFunction(action);
97 }
98
99 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
100 {
101     qDebug() << "FrameLoaderClientQt::slotCallPolicyFunction";
102     if (!m_frame || !m_policyFunction)
103         return;
104     (m_frame->loader()->*m_policyFunction)(WebCore::PolicyAction(action));
105     m_policyFunction = 0;
106 }
107
108 bool FrameLoaderClientQt::hasWebView() const
109 {
110     //notImplemented();
111     return true;
112 }
113
114
115 bool FrameLoaderClientQt::hasFrameView() const
116 {
117     //notImplemented();
118     return true;
119 }
120
121
122 bool FrameLoaderClientQt::hasBackForwardList() const
123 {
124     notImplemented();
125     return false;
126 }
127
128
129 void FrameLoaderClientQt::resetBackForwardList()
130 {
131     notImplemented();
132 }
133
134
135 bool FrameLoaderClientQt::provisionalItemIsTarget() const
136 {
137     notImplemented();
138     return false;
139 }
140
141
142 bool FrameLoaderClientQt::loadProvisionalItemFromPageCache()
143 {
144     notImplemented();
145     return false;
146 }
147
148
149 void FrameLoaderClientQt::invalidateCurrentItemPageCache()
150 {
151     notImplemented();
152 }
153
154
155 bool FrameLoaderClientQt::privateBrowsingEnabled() const
156 {
157     notImplemented();
158     return false;
159 }
160
161
162 void FrameLoaderClientQt::makeDocumentView()
163 {
164     qDebug() << "FrameLoaderClientQt::makeDocumentView" << m_frame->document();
165     
166 //     if (!m_frame->document()) 
167 //         m_frame->loader()->createEmptyDocument();
168 }
169
170
171 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
172 {
173     // don't need this for now I think.
174 }
175
176
177 void FrameLoaderClientQt::forceLayout()
178 {
179     notImplemented();
180 }
181
182
183 void FrameLoaderClientQt::forceLayoutForNonHTML()
184 {
185     notImplemented();
186 }
187
188
189 void FrameLoaderClientQt::updateHistoryForCommit()
190 {
191     notImplemented();
192 }
193
194
195 void FrameLoaderClientQt::updateHistoryForBackForwardNavigation()
196 {
197     notImplemented();
198 }
199
200
201 void FrameLoaderClientQt::updateHistoryForReload()
202 {
203     notImplemented();
204 }
205
206
207 void FrameLoaderClientQt::updateHistoryForStandardLoad()
208 {
209     notImplemented();
210 }
211
212
213 void FrameLoaderClientQt::updateHistoryForInternalLoad()
214 {
215     notImplemented();
216 }
217
218
219 void FrameLoaderClientQt::updateHistoryAfterClientRedirect()
220 {
221     notImplemented();
222 }
223
224
225 void FrameLoaderClientQt::setCopiesOnScroll()
226 {
227     // apparently mac specific 
228 }
229
230
231 LoadErrorResetToken* FrameLoaderClientQt::tokenForLoadErrorReset()
232 {
233     notImplemented();
234     return 0;
235 }
236
237
238 void FrameLoaderClientQt::resetAfterLoadError(LoadErrorResetToken*)
239 {
240     notImplemented();
241 }
242
243
244 void FrameLoaderClientQt::doNotResetAfterLoadError(LoadErrorResetToken*)
245 {
246     notImplemented();
247 }
248
249
250 void FrameLoaderClientQt::willCloseDocument()
251 {
252     notImplemented();
253 }
254
255 void FrameLoaderClientQt::detachedFromParent2()
256 {
257     notImplemented();
258 }
259
260
261 void FrameLoaderClientQt::detachedFromParent3()
262 {
263 }
264
265
266 void FrameLoaderClientQt::detachedFromParent4()
267 {
268     if (!m_webFrame)
269         return;
270     m_webFrame->d->frame = 0;
271     m_webFrame->d->frameView = 0;
272     m_webFrame = 0;
273     m_frame = 0;
274 }
275
276
277 void FrameLoaderClientQt::loadedFromPageCache()
278 {
279     notImplemented();
280 }
281
282
283 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
284 {
285     if (m_webFrame)
286         emit m_webFrame->loadDone(true);
287 }
288
289
290 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
291 {
292     notImplemented();
293 }
294
295
296 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
297 {
298     notImplemented();
299 }
300
301
302 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL&,
303                                                             double interval,
304                                                             double fireDate)
305 {
306     notImplemented();
307 }
308
309
310 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
311 {
312     notImplemented();
313 }
314
315
316 void FrameLoaderClientQt::dispatchWillClose()
317 {
318     notImplemented();
319 }
320
321
322 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
323 {
324     // we're not interested in this neither I think
325 }
326
327
328 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
329 {
330     setTitle(title);
331 }
332
333
334 void FrameLoaderClientQt::dispatchDidCommitLoad()
335 {
336     notImplemented();
337 }
338
339
340 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
341 {
342     notImplemented();
343 }
344
345
346 void FrameLoaderClientQt::dispatchDidFinishLoad()
347 {
348 }
349
350
351 void FrameLoaderClientQt::dispatchDidFirstLayout()
352 {
353     //notImplemented();
354 }
355
356
357 void FrameLoaderClientQt::dispatchShow()
358 {
359     notImplemented();
360 }
361
362
363 void FrameLoaderClientQt::cancelPolicyCheck()
364 {
365     qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
366     m_policyFunction = 0;
367 }
368
369
370 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
371                                                  PassRefPtr<FormState>)
372 {
373     notImplemented();
374     // FIXME: This is surely too simple
375     callPolicyFunction(function, PolicyUse);
376 }
377
378
379 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
380 {
381     notImplemented();
382 }
383
384
385 void FrameLoaderClientQt::clearLoadingFromPageCache(DocumentLoader*)
386 {
387     notImplemented();
388 }
389
390
391 bool FrameLoaderClientQt::isLoadingFromPageCache(DocumentLoader*)
392 {
393     notImplemented();
394     return false;
395 }
396
397
398 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
399 {
400     notImplemented();
401 }
402
403
404 void FrameLoaderClientQt::clearUnarchivingState(DocumentLoader*)
405 {
406     notImplemented();
407 }
408
409
410 void FrameLoaderClientQt::postProgressStartedNotification()
411 {
412     if (m_webFrame && m_frame->page())
413         emit loadStarted(m_webFrame);
414 }
415
416 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
417 {
418     if (m_webFrame && m_frame->page())
419         emit loadProgressChanged(m_frame->page()->progress()->estimatedProgress());
420 }
421
422 void FrameLoaderClientQt::postProgressFinishedNotification()
423 {
424     if (m_webFrame && m_frame->page())
425         emit loadFinished(m_webFrame);
426 }
427
428 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
429 {
430     // this is only interesting once we provide an external API for the DOM
431 }
432
433
434 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
435 {
436     notImplemented();
437 }
438
439
440 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *l)
441 {
442     setTitle(l->title());
443 }
444
445
446 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
447 {
448     if (m_firstData) {
449         FrameLoader *fl = loader->frameLoader();
450         fl->setEncoding(m_response.textEncodingName(), false);
451         m_firstData = false;
452     }
453 }
454
455
456 void FrameLoaderClientQt::finalSetupForReplace(DocumentLoader*)
457 {
458     notImplemented();
459 }
460
461
462 void FrameLoaderClientQt::setDefersLoading(bool)
463 {
464     notImplemented();
465 }
466
467
468 bool FrameLoaderClientQt::isArchiveLoadPending(ResourceLoader*) const
469 {
470     notImplemented();
471     return false;
472 }
473
474
475 void FrameLoaderClientQt::cancelPendingArchiveLoad(ResourceLoader*)
476 {
477     notImplemented();
478 }
479
480
481 void FrameLoaderClientQt::clearArchivedResources()
482 {
483     // don't think we need to do anything here currently
484 }
485
486
487 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
488 {
489     // FIXME: This is not good enough in the general case
490     qDebug() << "FrameLoaderClientQt::canShowMIMEType" << MIMEType;
491     return true;
492 }
493
494
495 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
496 {
497     notImplemented();
498     qDebug() << "    scheme is" << URLScheme;
499     return false;
500 }
501
502
503 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
504 {
505     notImplemented();
506     return String();
507 }
508
509
510 void FrameLoaderClientQt::frameLoadCompleted()
511 {
512     notImplemented();
513 }
514
515
516 void FrameLoaderClientQt::restoreScrollPositionAndViewState()
517 {
518     notImplemented();
519 }
520
521
522 void FrameLoaderClientQt::provisionalLoadStarted()
523 {
524     // don't need to do anything here
525 }
526
527
528 bool FrameLoaderClientQt::shouldTreatURLAsSameAsCurrent(const KURL&) const
529 {
530     notImplemented();
531     return false;
532 }
533
534
535 void FrameLoaderClientQt::addHistoryItemForFragmentScroll()
536 {
537     notImplemented();
538 }
539
540
541 void FrameLoaderClientQt::didFinishLoad()
542 {
543     notImplemented();
544 }
545
546
547 void FrameLoaderClientQt::prepareForDataSourceReplacement()
548 {
549     m_frame->loader()->detachChildren();
550 }
551
552
553 void FrameLoaderClientQt::setTitle(const String& title)
554 {
555     QString t = title;
556     emit titleChanged(t);
557 }
558
559
560 void FrameLoaderClientQt::setTitle(const String& title, const KURL& url)
561 {
562     Q_UNUSED(url)
563     setTitle(title);
564 }
565
566
567 String FrameLoaderClientQt::userAgent()
568 {
569     return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3 Qt";
570 }
571
572 void FrameLoaderClientQt::dispatchDidReceiveIcon()
573 {
574     notImplemented();
575 }
576
577 void FrameLoaderClientQt::frameLoaderDestroyed()
578 {
579     Q_ASSERT(m_webFrame == 0);
580     Q_ASSERT(m_frame == 0);
581     delete this;
582 }
583
584 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
585 {
586     return true;
587 }
588
589 void FrameLoaderClientQt::windowObjectCleared() const
590 {
591     if (m_webFrame)
592         emit m_webFrame->cleared();
593 }
594
595 void FrameLoaderClientQt::setDocumentViewFromPageCache(WebCore::PageCache*)
596 {
597     notImplemented();
598 }
599
600 void FrameLoaderClientQt::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
601 {
602     notImplemented();
603 }
604
605 void FrameLoaderClientQt::updateGlobalHistoryForReload(const WebCore::KURL&)
606 {
607     notImplemented();
608 }
609
610 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
611 {
612     if (item) {
613         return true;
614     }
615     return false;
616 }
617
618 void FrameLoaderClientQt::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
619 {
620     notImplemented();
621 }
622
623 void FrameLoaderClientQt::saveDocumentViewToPageCache(WebCore::PageCache*)
624 {
625     notImplemented();
626 }
627
628 bool FrameLoaderClientQt::canCachePage() const
629 {
630     // don't do any caching for now
631     return false;
632 }
633
634 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError&)
635 {
636     if (m_firstData) {
637         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
638         m_firstData = false;
639     }
640     if (m_webFrame)
641         emit m_webFrame->loadDone(false);
642 }
643
644 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
645 {
646     qDebug() << "FrameLoaderClientQt::committedLoad" << length;
647     if (!m_frame)
648         return;
649     FrameLoader *fl = loader->frameLoader();
650     if (m_firstData) {
651         fl->setEncoding(m_response.textEncodingName(), false);
652         m_firstData = false;
653     }
654     fl->addData(data, length);
655 }
656
657 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest&)
658 {
659     notImplemented();
660     return ResourceError();
661 }
662
663 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest&)
664 {
665     notImplemented();
666     return ResourceError();
667 }
668
669 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
670 {
671     notImplemented();
672     return ResourceError();
673 }
674
675 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
676 {
677     notImplemented();
678     return ResourceError();
679 }
680
681 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse&)
682 {
683     notImplemented();
684     return ResourceError();
685 }
686
687 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
688 {
689     notImplemented();
690     return false;
691 }
692
693 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
694 {
695     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
696     return loader.release();
697 }
698
699 void FrameLoaderClientQt::download(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
700 {
701     notImplemented();
702 }
703
704 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
705 {
706     notImplemented();   
707 }
708
709 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
710 {
711     // seems like the Mac code doesn't do anything here by default neither
712     qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().url();
713 }
714
715 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
716 {
717     notImplemented();
718 }
719
720 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
721 {
722     notImplemented();
723 }
724
725 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
726 {
727
728     m_response = response;
729     m_firstData = true;
730     qDebug() << "    got response from" << response.url().url();
731 }
732
733 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
734 {
735     notImplemented();
736 }
737
738 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
739 {
740 }
741
742 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
743 {
744     if (m_firstData) {
745         FrameLoader *fl = loader->frameLoader();
746         fl->setEncoding(m_response.textEncodingName(), false);
747         m_firstData = false;
748     }
749 }
750
751 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
752 {
753     notImplemented();
754 }
755
756 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
757 {
758     notImplemented();
759 }
760
761 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
762 {
763     notImplemented();
764 }
765
766 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
767 {
768     notImplemented();
769 }
770
771 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&)
772 {
773     // we need to call directly here
774     m_policyFunction = function;
775     slotCallPolicyFunction(PolicyUse);
776 }
777
778 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
779 {
780     notImplemented();
781     callPolicyFunction(function, PolicyIgnore);
782 }
783
784 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest& request)
785 {
786
787     KURL url = request.url();
788     if (url.isEmpty() || url.protocol() == "about") {
789         m_policyFunction = function;
790         slotCallPolicyFunction(PolicyUse);
791         return;
792     }
793     callPolicyFunction(function, PolicyUse);
794 }
795
796 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
797 {
798     notImplemented();
799 }
800
801 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest&)
802 {
803     notImplemented();
804 }
805
806 bool FrameLoaderClientQt::willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL&) const
807 {
808     notImplemented();
809     return false;
810 }
811
812 Frame* FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
813                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
814 {
815     QWebFrameData frameData;
816     frameData.url = url;
817     frameData.name = name;
818     frameData.ownerElement = ownerElement;
819     frameData.referrer = referrer;
820     frameData.allowsScrolling = allowsScrolling;
821     frameData.marginWidth = marginWidth;
822     frameData.marginHeight = marginHeight;
823         
824
825     QWebFrame* webFrame = m_webFrame->page()->createFrame(m_webFrame, &frameData);
826
827     RefPtr<Frame> childFrame = webFrame->d->frame;
828
829     // FIXME: All of the below should probably be moved over into WebCore
830     childFrame->tree()->setName(name);
831     m_frame->tree()->appendChild(childFrame);
832     // ### set override encoding if we have one
833
834     FrameLoadType loadType = m_frame->loader()->loadType();
835     FrameLoadType childLoadType = FrameLoadTypeInternal;
836
837     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
838                              String(), 0, 0, WTF::HashMap<String, String>());
839     
840     // The frame's onload handler may have removed it from the document.
841     if (!childFrame->tree()->parent())
842         return 0;
843     
844     return childFrame.get();
845 }
846
847 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& mimeType)
848 {
849     notImplemented();
850     return ObjectContentType();
851 }
852
853 Widget* FrameLoaderClientQt::createPlugin(Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
854 {
855     notImplemented();
856     return 0;
857 }
858
859 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
860 {
861     notImplemented();
862     return;
863 }
864
865 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
866                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
867 {
868     notImplemented();
869     return 0;
870 }
871
872 String FrameLoaderClientQt::overrideMediaType() const
873 {
874     notImplemented();
875     return String();
876 }
877
878 }
879
880 #include "FrameLoaderClientQt.moc"