d2ca3fe92aa2533e8149625c128c5efb43d39926
[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  *
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28  
29 #include "config.h"
30 #include "FrameLoaderClientQt.h"
31 #include "DocumentLoader.h"
32 #include "ResourceResponse.h"
33 #include "Page.h"
34 #include "ProgressTracker.h"
35
36 #include "qwebpage.h"
37 #include "qwebframe.h"
38
39 #include "qdebug.h"
40
41 #define notImplemented() qDebug("FIXME: UNIMPLEMENTED: %s:%d (%s)", __FILE__, __LINE__, __FUNCTION__)
42
43 namespace WebCore
44 {
45
46 FrameLoaderClientQt::FrameLoaderClientQt()
47     : m_frame(0)
48     , m_webFrame(0)
49     , m_firstData(false)
50     , m_policyFunction(0)
51 {
52     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
53 }
54
55
56 FrameLoaderClientQt::~FrameLoaderClientQt()
57 {
58 }
59
60 void FrameLoaderClientQt::setFrame(QWebFrame *webFrame, FrameQt *frame)
61 {
62     m_webFrame = webFrame;
63     m_frame = frame;
64     if (!m_webFrame || !m_webFrame->page()) {
65         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
66         return;
67     }
68
69     connect(this, SIGNAL(loadStarted(QWebFrame*)),
70             m_webFrame->page(), SIGNAL(loadStarted(QWebFrame *)));
71     connect(this, SIGNAL(loadProgressChanged(double)),
72             m_webFrame->page(), SIGNAL(loadProgressChanged(double)));
73     connect(this, SIGNAL(loadFinished(QWebFrame*)),
74             m_webFrame->page(), SIGNAL(loadFinished(QWebFrame *)));
75 }
76
77 void FrameLoaderClientQt::detachFrameLoader()
78 {
79     disconnect(this, SIGNAL(loadStarted(QWebFrame*)));
80     disconnect(this, SIGNAL(loadProgressChanged(double)));
81     disconnect(this, SIGNAL(loadFinished(QWebFrame*)));
82     m_webFrame = 0;
83     m_frame = 0;
84 }
85
86 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
87 {
88     qDebug() << "FrameLoaderClientQt::callPolicyFunction";
89     ASSERT(!m_policyFunction);
90
91     m_policyFunction = function;
92     emit sigCallPolicyFunction(action);
93 }
94
95 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
96 {
97     qDebug() << "FrameLoaderClientQt::slotCallPolicyFunction";
98     if (!m_frame || !m_policyFunction)
99         return;
100     (m_frame->loader()->*m_policyFunction)(WebCore::PolicyAction(action));
101     m_policyFunction = 0;
102 }
103
104 bool FrameLoaderClientQt::hasWebView() const
105 {
106     //notImplemented();
107     return true;
108 }
109
110
111 bool FrameLoaderClientQt::hasFrameView() const
112 {
113     //notImplemented();
114     return true;
115 }
116
117
118 bool FrameLoaderClientQt::hasBackForwardList() const
119 {
120     notImplemented();
121     return false;
122 }
123
124
125 void FrameLoaderClientQt::resetBackForwardList()
126 {
127     notImplemented();
128 }
129
130
131 bool FrameLoaderClientQt::provisionalItemIsTarget() const
132 {
133     notImplemented();
134     return false;
135 }
136
137
138 bool FrameLoaderClientQt::loadProvisionalItemFromPageCache()
139 {
140     notImplemented();
141     return false;
142 }
143
144
145 void FrameLoaderClientQt::invalidateCurrentItemPageCache()
146 {
147     notImplemented();
148 }
149
150
151 bool FrameLoaderClientQt::privateBrowsingEnabled() const
152 {
153     notImplemented();
154     return false;
155 }
156
157
158 void FrameLoaderClientQt::makeDocumentView()
159 {
160     qDebug() << "FrameLoaderClientQt::makeDocumentView" << m_frame->document();
161     
162 //     if (!m_frame->document()) 
163 //         m_frame->loader()->createEmptyDocument();
164 }
165
166
167 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
168 {
169     // don't need this for now I think.
170 }
171
172
173 void FrameLoaderClientQt::forceLayout()
174 {
175     notImplemented();
176 }
177
178
179 void FrameLoaderClientQt::forceLayoutForNonHTML()
180 {
181     notImplemented();
182 }
183
184
185 void FrameLoaderClientQt::updateHistoryForCommit()
186 {
187     notImplemented();
188 }
189
190
191 void FrameLoaderClientQt::updateHistoryForBackForwardNavigation()
192 {
193     notImplemented();
194 }
195
196
197 void FrameLoaderClientQt::updateHistoryForReload()
198 {
199     notImplemented();
200 }
201
202
203 void FrameLoaderClientQt::updateHistoryForStandardLoad()
204 {
205     notImplemented();
206 }
207
208
209 void FrameLoaderClientQt::updateHistoryForInternalLoad()
210 {
211     notImplemented();
212 }
213
214
215 void FrameLoaderClientQt::updateHistoryAfterClientRedirect()
216 {
217     notImplemented();
218 }
219
220
221 void FrameLoaderClientQt::setCopiesOnScroll()
222 {
223     // apparently mac specific 
224 }
225
226
227 LoadErrorResetToken* FrameLoaderClientQt::tokenForLoadErrorReset()
228 {
229     notImplemented();
230     return 0;
231 }
232
233
234 void FrameLoaderClientQt::resetAfterLoadError(LoadErrorResetToken*)
235 {
236     notImplemented();
237 }
238
239
240 void FrameLoaderClientQt::doNotResetAfterLoadError(LoadErrorResetToken*)
241 {
242     notImplemented();
243 }
244
245
246 void FrameLoaderClientQt::willCloseDocument()
247 {
248     notImplemented();
249 }
250
251
252 void FrameLoaderClientQt::detachedFromParent1()
253 {
254     notImplemented();
255 }
256
257
258 void FrameLoaderClientQt::detachedFromParent2()
259 {
260     notImplemented();
261 }
262
263
264 void FrameLoaderClientQt::detachedFromParent3()
265 {
266     notImplemented();
267 }
268
269
270 void FrameLoaderClientQt::detachedFromParent4()
271 {
272     notImplemented();
273 }
274
275
276 void FrameLoaderClientQt::loadedFromPageCache()
277 {
278     notImplemented();
279 }
280
281
282 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
283 {
284     emit m_webFrame->loadDone();
285 }
286
287
288 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
289 {
290     notImplemented();
291 }
292
293
294 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
295 {
296     notImplemented();
297 }
298
299
300 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL&,
301                                                             double interval,
302                                                             double fireDate)
303 {
304     notImplemented();
305 }
306
307
308 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
309 {
310     notImplemented();
311 }
312
313
314 void FrameLoaderClientQt::dispatchWillClose()
315 {
316     notImplemented();
317 }
318
319
320 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
321 {
322     // we're not interested in this neither I think
323 }
324
325
326 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
327 {
328     notImplemented();
329 }
330
331
332 void FrameLoaderClientQt::dispatchDidCommitLoad()
333 {
334     notImplemented();
335 }
336
337
338 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
339 {
340     notImplemented();
341 }
342
343
344 void FrameLoaderClientQt::dispatchDidFinishLoad()
345 {
346     notImplemented();
347 }
348
349
350 void FrameLoaderClientQt::dispatchDidFirstLayout()
351 {
352     //notImplemented();
353 }
354
355
356 void FrameLoaderClientQt::dispatchShow()
357 {
358     notImplemented();
359 }
360
361
362 void FrameLoaderClientQt::cancelPolicyCheck()
363 {
364     m_policyFunction = 0;
365 }
366
367
368 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
369                                                  PassRefPtr<FormState>)
370 {
371     notImplemented();
372     // FIXME: This is surely too simple
373     callPolicyFunction(function, PolicyUse);
374 }
375
376
377 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
378 {
379     notImplemented();
380 }
381
382
383 void FrameLoaderClientQt::clearLoadingFromPageCache(DocumentLoader*)
384 {
385     notImplemented();
386 }
387
388
389 bool FrameLoaderClientQt::isLoadingFromPageCache(DocumentLoader*)
390 {
391     notImplemented();
392     return false;
393 }
394
395
396 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
397 {
398     notImplemented();
399 }
400
401
402 void FrameLoaderClientQt::clearUnarchivingState(DocumentLoader*)
403 {
404     notImplemented();
405 }
406
407
408 void FrameLoaderClientQt::postProgressStartedNotification()
409 {
410     emit loadStarted(m_webFrame);
411 }
412
413 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
414 {
415     emit loadProgressChanged(m_frame->page()->progress()->estimatedProgress());
416 }
417
418 void FrameLoaderClientQt::postProgressFinishedNotification()
419 {
420     emit loadFinished(m_webFrame);
421 }
422
423 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
424 {
425     // this is only interesting once we provide an external API for the DOM
426 }
427
428
429 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
430 {
431     notImplemented();
432 }
433
434
435 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *l)
436 {
437     setTitle(l->title(), l->URL());
438 }
439
440
441 void FrameLoaderClientQt::finishedLoading(DocumentLoader*)
442 {
443     notImplemented();
444 }
445
446
447 void FrameLoaderClientQt::finalSetupForReplace(DocumentLoader*)
448 {
449     notImplemented();
450 }
451
452
453 void FrameLoaderClientQt::setDefersLoading(bool)
454 {
455     notImplemented();
456 }
457
458
459 bool FrameLoaderClientQt::isArchiveLoadPending(ResourceLoader*) const
460 {
461     notImplemented();
462     return false;
463 }
464
465
466 void FrameLoaderClientQt::cancelPendingArchiveLoad(ResourceLoader*)
467 {
468     notImplemented();
469 }
470
471
472 void FrameLoaderClientQt::clearArchivedResources()
473 {
474     // don't think we need to do anything here currently
475 }
476
477
478 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
479 {
480     // FIXME: This is not good enough in the general case
481     qDebug() << "FrameLoaderClientQt::canShowMIMEType" << MIMEType;
482     return true;
483 }
484
485
486 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
487 {
488     notImplemented();
489     qDebug() << "    scheme is" << URLScheme;
490     return false;
491 }
492
493
494 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
495 {
496     notImplemented();
497     return String();
498 }
499
500
501 void FrameLoaderClientQt::frameLoadCompleted()
502 {
503     notImplemented();
504 }
505
506
507 void FrameLoaderClientQt::restoreScrollPositionAndViewState()
508 {
509     notImplemented();
510 }
511
512
513 void FrameLoaderClientQt::provisionalLoadStarted()
514 {
515     // don't need to do anything here
516 }
517
518
519 bool FrameLoaderClientQt::shouldTreatURLAsSameAsCurrent(const KURL&) const
520 {
521     notImplemented();
522     return false;
523 }
524
525
526 void FrameLoaderClientQt::addHistoryItemForFragmentScroll()
527 {
528     notImplemented();
529 }
530
531
532 void FrameLoaderClientQt::didFinishLoad()
533 {
534     notImplemented();
535 }
536
537
538 void FrameLoaderClientQt::prepareForDataSourceReplacement()
539 {
540     m_frame->loader()->detachChildren();
541 }
542
543
544 void FrameLoaderClientQt::setTitle(const String& title, const KURL&)
545 {
546     //notImplemented();
547 }
548
549
550 String FrameLoaderClientQt::userAgent()
551 {
552     return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3 Qt";
553 }
554
555 void FrameLoaderClientQt::dispatchDidReceiveIcon()
556 {
557     notImplemented();
558 }
559
560 void FrameLoaderClientQt::frameLoaderDestroyed()
561 {
562     m_frame = 0;
563     delete this;
564 }
565
566 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
567 {
568     return true;
569 }
570
571 void FrameLoaderClientQt::partClearedInBegin()
572 {
573     emit m_webFrame->cleared();
574 }
575
576 void FrameLoaderClientQt::setDocumentViewFromPageCache(WebCore::PageCache*)
577 {
578     notImplemented();
579 }
580
581 void FrameLoaderClientQt::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
582 {
583     notImplemented();
584 }
585
586 void FrameLoaderClientQt::updateGlobalHistoryForReload(const WebCore::KURL&)
587 {
588     notImplemented();
589 }
590
591 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem*) const
592 {
593     notImplemented();
594     return false;
595 }
596
597 void FrameLoaderClientQt::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
598 {
599     notImplemented();
600 }
601
602 void FrameLoaderClientQt::saveDocumentViewToPageCache(WebCore::PageCache*)
603 {
604     notImplemented();
605 }
606
607 bool FrameLoaderClientQt::canCachePage() const
608 {
609     // don't do any caching for now
610     return false;
611 }
612
613 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
614 {
615     notImplemented();
616 }
617
618 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
619 {
620     qDebug() << "FrameLoaderClientQt::committedLoad" << length;
621     if (!m_frame)
622         return;
623     FrameLoader *fl = loader->frameLoader();
624     fl->setEncoding(m_response.textEncodingName(), false);
625     fl->addData(data, length);
626 }
627
628 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest&)
629 {
630     notImplemented();
631     return ResourceError();
632 }
633
634 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest&)
635 {
636     notImplemented();
637     return ResourceError();
638 }
639
640 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
641 {
642     notImplemented();
643     return ResourceError();
644 }
645
646 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
647 {
648     notImplemented();
649     return ResourceError();
650 }
651
652 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse&)
653 {
654     notImplemented();
655     return ResourceError();
656 }
657
658 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
659 {
660     notImplemented();
661     return false;
662 }
663
664 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request)
665 {
666     RefPtr<DocumentLoader> loader = new DocumentLoader(request);
667     return loader.release();
668 }
669
670 void FrameLoaderClientQt::download(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
671 {
672     notImplemented();
673 }
674
675 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
676 {
677     notImplemented();   
678 }
679
680 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
681 {
682     // seems like the Mac code doesn't do anything here by default neither
683     qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().url();
684 }
685
686 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
687 {
688     notImplemented();
689 }
690
691 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
692 {
693     notImplemented();
694 }
695
696 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
697 {
698
699     m_response = response;
700     m_firstData = true;
701     qDebug() << "    got response from" << response.url().url();
702 }
703
704 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
705 {
706     notImplemented();
707 }
708
709 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader*, unsigned long)
710 {
711     notImplemented();
712 }
713
714 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceError&)
715 {
716     notImplemented();
717 }
718
719 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
720 {
721     notImplemented();
722 }
723
724 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
725 {
726     notImplemented();
727 }
728
729 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
730 {
731     notImplemented();
732 }
733
734 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
735 {
736     notImplemented();
737 }
738
739 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&)
740 {
741     // we need to call directly here
742     m_policyFunction = function;
743     slotCallPolicyFunction(PolicyUse);
744 }
745
746 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
747 {
748     notImplemented();
749     callPolicyFunction(function, PolicyIgnore);
750 }
751
752 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&)
753 {
754     notImplemented();
755     callPolicyFunction(function, PolicyUse);
756 }
757
758 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
759 {
760     notImplemented();
761 }
762
763 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest&)
764 {
765     notImplemented();
766 }
767
768 bool FrameLoaderClientQt::willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL&) const
769 {
770     notImplemented();
771     return false;
772 }
773
774 }
775
776 #include "FrameLoaderClientQt.moc"