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