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