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