Holger Hans Peter Freyther <holger.freyther@trolltech.com>
[WebKit-https.git] / WebKit / qt / 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-2008 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 "CSSComputedStyleDeclaration.h"
32 #include "CSSPropertyNames.h"
33 #include "FrameLoaderClientQt.h"
34 #include "FrameTree.h"
35 #include "FrameView.h"
36 #include "DocumentLoader.h"
37 #include "MIMETypeRegistry.h"
38 #include "ResourceResponse.h"
39 #include "Page.h"
40 #include "PluginData.h"
41 #include "ProgressTracker.h"
42 #include "RenderPart.h"
43 #include "ResourceRequest.h"
44 #include "HistoryItem.h"
45 #include "HTMLFormElement.h"
46 #include "NotImplemented.h"
47 #include "QNetworkReplyHandler.h"
48 #include "ResourceHandleInternal.h"
49 #include "ResourceHandle.h"
50
51 #include "qwebpage.h"
52 #include "qwebframe.h"
53 #include "qwebframe_p.h"
54 #include "qwebhistoryinterface.h"
55 #include "qwebpluginfactory.h"
56
57 #include <qfileinfo.h>
58
59 #include <QCoreApplication>
60 #include <QDebug>
61 #if QT_VERSION >= 0x040400
62 #include <QNetworkRequest>
63 #include <QNetworkReply>
64 #else
65 #include "qwebnetworkinterface_p.h"
66 #endif
67
68 static bool dumpFrameLoaderCallbacks = false;
69
70 void QWEBKIT_EXPORT qt_dump_frame_loader(bool b)
71 {
72     dumpFrameLoaderCallbacks = b;
73 }
74
75 // Compare with WebKitTools/DumpRenderTree/mac/FrameLoadDelegate.mm
76 static QString drtDescriptionSuitableForTestResult(WebCore::Frame* _frame)
77 {
78     QWebFrame* frame = QWebFramePrivate::kit(_frame);
79     QString name = frame->name();
80
81     bool isMainFrame = frame == frame->page()->mainFrame();  
82     if (isMainFrame) {
83         if (!name.isEmpty())
84             return QString::fromLatin1("main frame \"%1\"").arg(name);
85         return QLatin1String("main frame");
86     } else {
87         if (!name.isEmpty())
88             return QString::fromLatin1("frame \"%1\"").arg(name);
89         return QLatin1String("frame (anonymous)");
90     }
91 }
92
93 static QString drtDescriptionSuitableForTestResult(const WebCore::KURL& _url)
94 {
95     QUrl url = _url;
96     return url.toString();
97 }
98
99
100 namespace WebCore
101 {
102
103 FrameLoaderClientQt::FrameLoaderClientQt()
104     : m_frame(0)
105     , m_webFrame(0)
106     , m_firstData(false)
107     , m_policyFunction(0)
108 {
109     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
110 }
111
112
113 FrameLoaderClientQt::~FrameLoaderClientQt()
114 {
115 }
116
117 void FrameLoaderClientQt::setFrame(QWebFrame* webFrame, Frame* frame)
118 {
119     m_webFrame = webFrame;
120     m_frame = frame;
121     if (!m_webFrame || !m_webFrame->page()) {
122         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
123         return;
124     }
125
126     connect(this, SIGNAL(loadStarted()),
127             m_webFrame, SIGNAL(loadStarted()));
128     connect(this, SIGNAL(loadProgressChanged(int)),
129             m_webFrame->page(), SIGNAL(loadProgressChanged(int)));
130     connect(this, SIGNAL(loadFinished()),
131             m_webFrame, SIGNAL(loadFinished()));
132     connect(this, SIGNAL(titleChanged(const QString&)),
133             m_webFrame, SIGNAL(titleChanged(const QString&)));
134 }
135
136 QWebFrame* FrameLoaderClientQt::webFrame() const
137 {
138     return m_webFrame;
139 }
140
141 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
142 {
143     ASSERT(!m_policyFunction);
144     ASSERT(function);
145
146     m_policyFunction = function;
147     emit sigCallPolicyFunction(action);
148 }
149
150 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
151 {
152     if (!m_frame || !m_policyFunction)
153         return;
154     FramePolicyFunction function = m_policyFunction;
155     m_policyFunction = 0;
156     (m_frame->loader()->*function)(WebCore::PolicyAction(action));
157 }
158
159 bool FrameLoaderClientQt::hasWebView() const
160 {
161     //notImplemented();
162     return true;
163 }
164
165
166 bool FrameLoaderClientQt::hasFrameView() const
167 {
168     //notImplemented();
169     return true;
170 }
171
172 void FrameLoaderClientQt::savePlatformDataToCachedPage(CachedPage*) 
173 {
174     notImplemented();
175 }
176
177 void FrameLoaderClientQt::transitionToCommittedFromCachedPage(CachedPage*)
178
179 }
180
181 void FrameLoaderClientQt::transitionToCommittedForNewPage() 
182
183     ASSERT(m_frame);
184     ASSERT(m_webFrame);
185
186     Page* page = m_frame->page();
187     ASSERT(page);
188
189     bool isMainFrame = m_frame == page->mainFrame();
190
191     m_frame->setView(0);
192
193     FrameView* frameView;
194     if (isMainFrame)
195         frameView = new FrameView(m_frame, m_webFrame->page()->viewportSize());
196     else
197         frameView = new FrameView(m_frame);
198
199     if (!m_webFrame->d->allowsScrolling)
200         frameView->setScrollbarsMode(ScrollbarAlwaysOff);
201     if (m_webFrame->d->marginWidth != -1)
202         frameView->setMarginWidth(m_webFrame->d->marginWidth);
203     if (m_webFrame->d->marginHeight != -1)
204         frameView->setMarginHeight(m_webFrame->d->marginHeight);
205     if (m_webFrame->d->horizontalScrollBarPolicy != Qt::ScrollBarAsNeeded)
206         frameView->setHScrollbarMode((ScrollbarMode)m_webFrame->d->horizontalScrollBarPolicy);
207     if (m_webFrame->d->verticalScrollBarPolicy != Qt::ScrollBarAsNeeded)
208         frameView->setVScrollbarMode((ScrollbarMode)m_webFrame->d->verticalScrollBarPolicy);
209
210     m_frame->setView(frameView);
211     // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
212     frameView->deref();
213
214     if (m_frame->ownerRenderer())
215         m_frame->ownerRenderer()->setWidget(frameView);
216 }
217
218
219 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
220 {
221     // don't need this for now I think.
222 }
223
224
225 void FrameLoaderClientQt::forceLayout()
226 {
227     m_frame->forceLayout(true);
228 }
229
230
231 void FrameLoaderClientQt::forceLayoutForNonHTML()
232 {
233 }
234
235
236 void FrameLoaderClientQt::setCopiesOnScroll()
237 {
238     // apparently mac specific
239 }
240
241
242 void FrameLoaderClientQt::detachedFromParent2()
243 {
244 }
245
246
247 void FrameLoaderClientQt::detachedFromParent3()
248 {
249 }
250
251
252 void FrameLoaderClientQt::detachedFromParent4()
253 {
254 }
255
256 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
257 {
258     // don't need this one
259     if (dumpFrameLoaderCallbacks)
260         printf("%s - didHandleOnloadEventsForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
261
262 }
263
264
265 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
266 {
267     if (dumpFrameLoaderCallbacks)
268         printf("%s - didReceiveServerRedirectForProvisionalLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
269
270     notImplemented();
271 }
272
273
274 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
275 {
276     if (dumpFrameLoaderCallbacks)
277         printf("%s - didCancelClientRedirectForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
278
279     notImplemented();
280 }
281
282
283 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL& url,
284                                                             double interval,
285                                                             double fireDate)
286 {
287     if (dumpFrameLoaderCallbacks)
288         printf("%s - willPerformClientRedirectToURL: %s \n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)), qPrintable(drtDescriptionSuitableForTestResult(url)));
289
290     notImplemented();
291 }
292
293
294 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
295 {
296     if (dumpFrameLoaderCallbacks)
297         printf("%s - didChangeLocationWithinPageForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
298
299     notImplemented();
300 }
301
302
303 void FrameLoaderClientQt::dispatchWillClose()
304 {
305     if (dumpFrameLoaderCallbacks)
306         printf("%s - willCloseFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
307 }
308
309
310 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
311 {
312     if (dumpFrameLoaderCallbacks)
313         printf("%s - didStartProvisionalLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
314
315     if (m_webFrame)
316         emit m_webFrame->provisionalLoad();
317 }
318
319
320 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
321 {
322     if (dumpFrameLoaderCallbacks)
323         printf("%s - didReceiveTitle: %s\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)), qPrintable(QString(title)));
324
325     if (!m_webFrame)
326         return;
327
328
329
330     // ### hack
331     emit m_webFrame->urlChanged(m_webFrame->url());
332     emit titleChanged(title);
333 }
334
335
336 void FrameLoaderClientQt::dispatchDidCommitLoad()
337 {
338     if (dumpFrameLoaderCallbacks)
339         printf("%s - didCommitLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
340
341     if (m_frame->tree()->parent() || !m_webFrame)
342         return;
343
344     m_webFrame->page()->d->updateNavigationActions();
345 }
346
347
348 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
349 {
350     if (dumpFrameLoaderCallbacks)
351         printf("%s - didFinishDocumentLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
352
353     if (m_frame->tree()->parent() || !m_webFrame)
354         return;
355         
356     m_webFrame->page()->d->updateNavigationActions();
357 }
358
359
360 void FrameLoaderClientQt::dispatchDidFinishLoad()
361 {
362     if (dumpFrameLoaderCallbacks)
363         printf("%s - didFinishLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
364
365     if (m_webFrame)
366         emit m_webFrame->loadDone(true);
367     if (m_frame->tree()->parent() || !m_webFrame)
368         return;
369     m_webFrame->page()->d->updateNavigationActions();
370 }
371
372
373 void FrameLoaderClientQt::dispatchDidFirstLayout()
374 {
375     if (m_webFrame)
376         emit m_webFrame->initialLayoutComplete();
377 }
378
379
380 void FrameLoaderClientQt::dispatchShow()
381 {
382     notImplemented();
383 }
384
385
386 void FrameLoaderClientQt::cancelPolicyCheck()
387 {
388 //    qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
389     m_policyFunction = 0;
390 }
391
392
393 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
394                                                  PassRefPtr<FormState>)
395 {
396     notImplemented();
397     Q_ASSERT(!m_policyFunction);
398     // FIXME: This is surely too simple
399     callPolicyFunction(function, PolicyUse);
400 }
401
402
403 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
404 {
405 }
406
407
408 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
409 {
410     notImplemented();
411 }
412
413
414 void FrameLoaderClientQt::postProgressStartedNotification()
415 {
416     if (m_webFrame && m_frame->page())
417         emit loadStarted();
418     if (m_frame->tree()->parent() || !m_webFrame)
419         return;
420     m_webFrame->page()->d->updateNavigationActions();
421 }
422
423 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
424 {
425     if (m_webFrame && m_frame->page())
426         emit loadProgressChanged(qRound(m_frame->page()->progress()->estimatedProgress() * 100));
427 }
428
429 void FrameLoaderClientQt::postProgressFinishedNotification()
430 {
431     if (m_webFrame && m_frame->page())
432         emit loadFinished();
433 }
434
435 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
436 {
437     // this is only interesting once we provide an external API for the DOM
438 }
439
440
441 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
442 {
443     // no need for, dispatchDidReceiveTitle is the right callback
444 }
445
446
447 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *)
448 {
449     // no need for, dispatchDidReceiveTitle is the right callback
450 }
451
452
453 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
454 {
455     if (m_firstData) {
456         FrameLoader *fl = loader->frameLoader();
457         fl->setEncoding(m_response.textEncodingName(), false);
458         m_firstData = false;
459     }
460 }
461
462
463 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
464 {
465     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
466         return true;
467
468     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
469         return true;
470
471     return false;
472 }
473
474 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
475 {
476     return false;
477 }
478
479
480 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
481 {
482     notImplemented();
483     return String();
484 }
485
486
487 void FrameLoaderClientQt::frameLoadCompleted()
488 {
489     // Note: Can be called multiple times.
490     // Even if already complete, we might have set a previous item on a frame that
491     // didn't do any data loading on the past transaction. Make sure to clear these out.
492     m_frame->loader()->setPreviousHistoryItem(0);
493 }
494
495
496 void FrameLoaderClientQt::restoreViewState()
497 {
498     notImplemented();
499 }
500
501
502 void FrameLoaderClientQt::provisionalLoadStarted()
503 {
504     // don't need to do anything here
505 }
506
507
508 void FrameLoaderClientQt::didFinishLoad()
509 {
510 //     notImplemented();
511 }
512
513
514 void FrameLoaderClientQt::prepareForDataSourceReplacement()
515 {
516     m_frame->loader()->detachChildren();
517 }
518
519 void FrameLoaderClientQt::setTitle(const String&, const KURL&)
520 {
521     // no need for, dispatchDidReceiveTitle is the right callback
522 }
523
524
525 String FrameLoaderClientQt::userAgent(const KURL& url)
526 {
527     if (m_webFrame) {
528         return m_webFrame->page()->userAgentFor(QUrl((QString)url.string()));
529     }
530     return String();
531 }
532
533 void FrameLoaderClientQt::dispatchDidReceiveIcon()
534 {
535     if (dumpFrameLoaderCallbacks)
536         printf("%s - didReceiveIconForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
537
538     if (m_webFrame) {
539         emit m_webFrame->iconLoaded();
540     }
541 }
542
543 void FrameLoaderClientQt::frameLoaderDestroyed()
544 {
545     delete m_webFrame;
546     m_frame = 0;
547     m_webFrame = 0;
548
549     delete this;
550 }
551
552 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
553 {
554     return true;
555 }
556
557 void FrameLoaderClientQt::windowObjectCleared()
558 {
559     if (dumpFrameLoaderCallbacks)
560         printf("%s - didClearWindowObjectForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
561
562     if (m_webFrame)
563         emit m_webFrame->cleared();
564 }
565
566 void FrameLoaderClientQt::didPerformFirstNavigation() const
567 {
568     if (m_frame->tree()->parent() || !m_webFrame)
569         return;
570     m_webFrame->page()->d->updateNavigationActions();
571 }
572
573 void FrameLoaderClientQt::registerForIconNotification(bool)
574 {
575     notImplemented();
576 }
577
578 void FrameLoaderClientQt::updateGlobalHistory(const WebCore::KURL& url)
579 {
580     QWebHistoryInterface *history = QWebHistoryInterface::defaultInterface();
581     if (history)
582         history->addHistoryEntry(url.prettyURL());
583 }
584
585 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
586 {
587     return true;
588 }
589
590 void FrameLoaderClientQt::saveViewStateToItem(WebCore::HistoryItem*)
591 {
592 }
593
594 bool FrameLoaderClientQt::canCachePage() const
595 {
596     return true;
597 }
598
599 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError& error)
600 {
601     if (m_firstData) {
602         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
603         m_firstData = false;
604     }
605 }
606
607 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
608 {
609     if (!m_frame)
610         return;
611     FrameLoader *fl = loader->frameLoader();
612     if (m_firstData) {
613         fl->setEncoding(m_response.textEncodingName(), false);
614         m_firstData = false;
615     }
616     fl->addData(data, length);
617 }
618
619 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest& request)
620 {
621     return ResourceError("Error", -999, request.url().prettyURL(),
622             QCoreApplication::translate("QWebFrame", "Request cancelled", 0, QCoreApplication::UnicodeUTF8));
623 }
624
625 // copied from WebKit/Misc/WebKitErrors[Private].h
626 enum {
627     WebKitErrorCannotShowMIMEType =                             100,
628     WebKitErrorCannotShowURL =                                  101,
629     WebKitErrorFrameLoadInterruptedByPolicyChange =             102,
630     WebKitErrorCannotUseRestrictedPort = 103, 
631     WebKitErrorCannotFindPlugIn =                               200,
632     WebKitErrorCannotLoadPlugIn =                               201,
633     WebKitErrorJavaUnavailable =                                202,
634 };
635     
636 WebCore::ResourceError FrameLoaderClientQt::blockedError(const WebCore::ResourceRequest& request)
637 {
638     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().prettyURL(),
639             QCoreApplication::translate("QWebFrame", "Request blocked", 0, QCoreApplication::UnicodeUTF8));
640 }
641
642
643 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest& request)
644 {
645     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
646             QCoreApplication::translate("QWebFrame", "Cannot show URL", 0, QCoreApplication::UnicodeUTF8));
647 }
648
649 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
650 {
651     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(),
652             QCoreApplication::translate("QWebFrame", "Frame load interruped by policy change", 0, QCoreApplication::UnicodeUTF8));
653 }
654
655 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
656 {
657     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
658             QCoreApplication::translate("QWebFrame", "Cannot show mimetype", 0, QCoreApplication::UnicodeUTF8));
659 }
660
661 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse& response)
662 {
663     return ResourceError("Error", -998 /* ### */, response.url().string(),
664             QCoreApplication::translate("QWebFrame", "File does not exist", 0, QCoreApplication::UnicodeUTF8));
665 }
666
667 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
668 {
669     notImplemented();
670     return false;
671 }
672
673 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
674 {
675     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
676     return loader.release();
677 }
678
679 void FrameLoaderClientQt::download(WebCore::ResourceHandle* handle, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
680 {
681 #if QT_VERSION >= 0x040400
682     if (!m_webFrame)
683         return;
684
685     QNetworkReplyHandler* handler = handle->getInternal()->m_job;
686     QNetworkReply* reply = handler->release();
687     if (reply) {
688         QWebPage *page = m_webFrame->page();
689         if (page->receivers(SIGNAL(handleUnsupportedContent(QNetworkReply *))))
690             emit m_webFrame->page()->handleUnsupportedContent(reply);
691         else
692             reply->abort();
693     }
694 #endif
695 }
696
697 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
698 {
699 }
700
701 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
702 {
703     // seems like the Mac code doesn't do anything here by default neither
704     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().string`();
705 }
706
707 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
708 {
709     notImplemented();
710 }
711
712 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
713 {
714     notImplemented();
715 }
716
717 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
718 {
719
720     m_response = response;
721     m_firstData = true;
722     //qDebug() << "    got response from" << response.url().string();
723 }
724
725 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
726 {
727 }
728
729 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
730 {
731 }
732
733 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
734 {
735     if (m_firstData) {
736         FrameLoader *fl = loader->frameLoader();
737         fl->setEncoding(m_response.textEncodingName(), false);
738         m_firstData = false;
739     }
740 }
741
742 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
743 {
744     notImplemented();
745     return false;
746 }
747
748 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
749 {
750     if (dumpFrameLoaderCallbacks)
751         printf("%s - didFailProvisionalLoadWithError\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
752
753     if (m_webFrame)
754         emit m_webFrame->loadDone(false);
755 }
756
757 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
758 {
759     if (dumpFrameLoaderCallbacks)
760         printf("%s - didFailLoadWithError\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
761
762     if (m_webFrame)
763         emit m_webFrame->loadDone(false);
764 }
765
766 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
767 {
768     if (!m_webFrame)
769         return 0;
770     QWebPage *newPage = m_webFrame->page()->createWindow();
771     if (!newPage)
772         return 0;
773     return newPage->mainFrame()->d->frame;
774 }
775
776 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String& MIMEType, const WebCore::ResourceRequest&)
777 {
778     // we need to call directly here
779     Q_ASSERT(!m_policyFunction);
780     m_policyFunction = function;
781     if (canShowMIMEType(MIMEType))
782         slotCallPolicyFunction(PolicyUse);
783     else
784         slotCallPolicyFunction(PolicyDownload);
785 }
786
787 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
788 {
789     Q_ASSERT(!m_policyFunction);
790     m_policyFunction = function;
791     slotCallPolicyFunction(PolicyUse);
792 }
793
794 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request)
795 {
796     Q_ASSERT(!m_policyFunction);
797     m_policyFunction = function;
798     if (m_webFrame) {
799 #if QT_VERSION < 0x040400
800         QWebNetworkRequest r(request);
801 #else
802         QNetworkRequest r(request.toNetworkRequest());
803 #endif
804         QWebPage *page = m_webFrame->page();
805
806         if (page->d->navigationRequested(m_webFrame, r, QWebPage::NavigationType(action.type())) ==
807             QWebPage::IgnoreNavigationRequest) {
808             slotCallPolicyFunction(PolicyIgnore);
809             return;
810         }
811     }
812     slotCallPolicyFunction(PolicyUse);
813     return;
814 }
815
816 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
817 {
818     notImplemented();
819 }
820
821 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest& request)
822 {
823 #if QT_VERSION >= 0x040400
824     if (!m_webFrame)
825         return;
826
827     QWebPage *page = m_webFrame->page();
828     emit m_webFrame->page()->download(request.toNetworkRequest());
829 #endif
830 }
831
832 PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
833                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
834 {
835     if (!m_webFrame)
836         return 0;
837
838     QWebFrameData frameData;
839     frameData.url = url;
840     frameData.name = name;
841     frameData.ownerElement = ownerElement;
842     frameData.referrer = referrer;
843     frameData.allowsScrolling = allowsScrolling;
844     frameData.marginWidth = marginWidth;
845     frameData.marginHeight = marginHeight;
846
847     QWebFrame* webFrame = new QWebFrame(m_webFrame, &frameData);
848     emit m_webFrame->page()->frameCreated(webFrame);
849
850     RefPtr<Frame> childFrame = adoptRef(webFrame->d->frame);
851
852     // FIXME: All of the below should probably be moved over into WebCore
853     childFrame->tree()->setName(name);
854     m_frame->tree()->appendChild(childFrame);
855     // ### set override encoding if we have one
856
857     FrameLoadType loadType = m_frame->loader()->loadType();
858     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;
859
860     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
861                              String(), 0, 0);
862
863     // The frame's onload handler may have removed it from the document.
864     if (!childFrame->tree()->parent())
865         return 0;
866
867     return childFrame.release();
868 }
869
870 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& _mimeType)
871 {
872 //    qDebug()<<" ++++++++++++++++ url is "<<url.prettyURL()<<", mime = "<<_mimeType;
873     if (_mimeType == "application/x-qt-plugin" || _mimeType == "application/x-qt-styled-widget")
874         return ObjectContentOtherPlugin;
875
876     if (url.isEmpty())
877         return ObjectContentNone;
878
879     String mimeType = _mimeType;
880     if (!mimeType.length()) {
881         QFileInfo fi(url.path());
882         mimeType = MIMETypeRegistry::getMIMETypeForExtension(fi.suffix());
883     }
884
885     if (!mimeType.length())
886         return ObjectContentFrame;
887
888     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
889         return ObjectContentImage;
890
891     if (m_frame->page() && m_frame->page()->pluginData()->supportsMimeType(mimeType))
892         return ObjectContentOtherPlugin;
893
894     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
895         return ObjectContentFrame;
896
897     if (url.protocol() == "about")
898         return ObjectContentFrame;
899
900     return ObjectContentNone;
901 }
902
903 static const CSSPropertyID qstyleSheetProperties[] = {
904     CSSPropertyColor,
905     CSSPropertyFontFamily,
906     CSSPropertyFontSize,
907     CSSPropertyFontStyle,
908     CSSPropertyFontWeight
909 };
910
911 const unsigned numqStyleSheetProperties = sizeof(qstyleSheetProperties) / sizeof(qstyleSheetProperties[0]);
912
913 Widget* FrameLoaderClientQt::createPlugin(const IntSize&, Element* element, const KURL& url, const Vector<String>& paramNames,
914                                           const Vector<String>& paramValues, const String& mimeType, bool loadManually)
915 {
916 //     qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
917 //     qDebug()<<"------\t url = "<<url.prettyURL();
918
919     if (!m_webFrame)
920         return 0;
921
922     QStringList params;
923     QStringList values;
924     for (int i = 0; i < paramNames.size(); ++i)
925         params.append(paramNames[i]);
926     for (int i = 0; i < paramValues.size(); ++i)
927         values.append(paramValues[i]);
928
929     QString urlStr(url.string());
930     QUrl qurl = urlStr;
931
932     QObject *object = 0;
933
934     if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
935         object = m_webFrame->page()->createPlugin(element->getAttribute("classid"), qurl, params, values);
936         QWidget *widget = qobject_cast<QWidget *>(object);
937         if (widget && mimeType == "application/x-qt-styled-widget") {
938             CSSComputedStyleDeclaration cssDecl(element);
939
940             QString styleSheet = element->getAttribute("style");
941             if (!styleSheet.isEmpty())
942                 styleSheet += QLatin1Char(';');
943
944             for (int i = 0; i < numqStyleSheetProperties; ++i) {
945                 CSSPropertyID property = qstyleSheetProperties[i];
946
947                 styleSheet += ::getPropertyName(property);
948                 styleSheet += QLatin1Char(':');
949                 styleSheet += cssDecl.getPropertyValue(property);
950                 styleSheet += QLatin1Char(';');
951             }
952
953             widget->setStyleSheet(styleSheet);
954         }
955     }
956
957 #if QT_VERSION >= 0x040400
958     if (!object) {
959         QWebPluginFactory* factory = m_webFrame->page()->pluginFactory();
960         if (factory)
961             object = factory->create(mimeType, qurl, params, values);
962     }
963 #endif
964
965     if (object) {
966         QWidget *widget = qobject_cast<QWidget *>(object);
967         QWidget *view = m_webFrame->page()->view();
968         if (widget && view) {
969             widget->setParent(view);
970             Widget* w= new Widget();
971             w->setNativeWidget(widget);
972             return w;
973         }
974         // FIXME: make things work for widgetless plugins as well
975         delete object;
976     }
977
978     return 0;
979 }
980
981 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
982 {
983     notImplemented();
984     return;
985 }
986
987 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
988                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
989 {
990     notImplemented();
991     return 0;
992 }
993
994 String FrameLoaderClientQt::overrideMediaType() const
995 {
996     return String();
997 }
998
999 QString FrameLoaderClientQt::chooseFile(const QString& oldFile)
1000 {
1001     return webFrame()->page()->chooseFile(webFrame(), oldFile);
1002 }
1003
1004
1005 }
1006
1007 #include "moc_FrameLoaderClientQt.cpp"