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