WebCore:
[WebKit-https.git] / WebKit / wx / WebKitSupport / FrameLoaderClientWx.cpp
1 /*
2  * Copyright (C) 2007 Kevin Ollivier <kevino@theolliviers.com>
3  *
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27  
28 #include "config.h"
29 #include "FrameLoaderClientWx.h"
30
31 #include "DocumentLoader.h"
32 #include "Frame.h"
33 #include "FrameLoaderTypes.h"
34 #include "FrameView.h"
35 #include "FrameTree.h"
36 #include "HTMLFormElement.h"
37 #include "NotImplemented.h"
38 #include "Page.h"
39 #include "PlatformString.h"
40 #include "ProgressTracker.h"
41 #include "ResourceError.h"
42 #include "ResourceResponse.h"
43
44 #include <stdio.h>
45
46 #include "WebView.h"
47 #include "WebViewPrivate.h"
48
49 namespace WebCore {
50
51 inline int wxNavTypeFromWebNavType(NavigationType type){
52     if (type == NavigationTypeLinkClicked)
53         return wxWEBVIEW_NAV_LINK_CLICKED;
54     
55     if (type == NavigationTypeFormSubmitted)
56         return wxWEBVIEW_NAV_FORM_SUBMITTED;
57         
58     if (type == NavigationTypeBackForward)
59         return wxWEBVIEW_NAV_BACK_NEXT;
60         
61     if (type == NavigationTypeReload)
62         return wxWEBVIEW_NAV_RELOAD;
63         
64     if (type == NavigationTypeFormResubmitted)
65         return wxWEBVIEW_NAV_FORM_RESUBMITTED;
66         
67     return wxWEBVIEW_NAV_OTHER;
68 }
69
70 FrameLoaderClientWx::FrameLoaderClientWx()
71     : m_frame(0)
72 {
73 }
74
75
76 FrameLoaderClientWx::~FrameLoaderClientWx()
77 {
78 }
79
80 void FrameLoaderClientWx::setFrame(Frame *frame)
81 {
82     m_frame = frame;
83 }
84
85 void FrameLoaderClientWx::detachFrameLoader()
86 {
87     m_frame = 0;
88 }
89
90 void FrameLoaderClientWx::ref()
91 {
92     RefCounted<FrameLoaderClientWx>::ref();
93 }
94
95 void FrameLoaderClientWx::deref()
96 {
97     RefCounted<FrameLoaderClientWx>::deref();
98 }
99
100 bool FrameLoaderClientWx::hasWebView() const
101 {
102     notImplemented();
103     return true;
104 }
105
106
107 bool FrameLoaderClientWx::hasFrameView() const
108 {
109     notImplemented();
110     return true;
111 }
112
113
114 bool FrameLoaderClientWx::hasBackForwardList() const
115 {
116     notImplemented();
117     return true;
118 }
119
120
121 void FrameLoaderClientWx::resetBackForwardList()
122 {
123     notImplemented();
124 }
125
126
127 bool FrameLoaderClientWx::provisionalItemIsTarget() const
128 {
129     notImplemented();
130     return false;
131 }
132
133
134 void FrameLoaderClientWx::makeDocumentView()
135 {
136     notImplemented();
137 }
138
139
140 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
141 {
142     notImplemented();
143 }
144
145
146 void FrameLoaderClientWx::forceLayout()
147 {
148     notImplemented();
149 }
150
151
152 void FrameLoaderClientWx::forceLayoutForNonHTML()
153 {
154     notImplemented();
155 }
156
157
158 void FrameLoaderClientWx::updateHistoryForCommit()
159 {
160     notImplemented();
161 }
162
163
164 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
165 {
166     notImplemented();
167 }
168
169
170 void FrameLoaderClientWx::updateHistoryForReload()
171 {
172     notImplemented();
173 }
174
175
176 void FrameLoaderClientWx::updateHistoryForStandardLoad()
177 {
178     notImplemented();
179 }
180
181
182 void FrameLoaderClientWx::updateHistoryForInternalLoad()
183 {
184     notImplemented();
185 }
186
187
188 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
189 {
190     notImplemented();
191 }
192
193
194 void FrameLoaderClientWx::setCopiesOnScroll()
195 {
196     // apparently mac specific
197     notImplemented();
198 }
199
200
201 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
202 {
203     notImplemented();
204     return 0;
205 }
206
207
208 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
209 {
210     notImplemented();
211 }
212
213
214 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
215 {
216     notImplemented();
217 }
218
219
220 void FrameLoaderClientWx::willCloseDocument()
221 {
222     notImplemented();
223 }
224
225
226 void FrameLoaderClientWx::detachedFromParent1()
227 {
228     notImplemented();
229 }
230
231
232 void FrameLoaderClientWx::detachedFromParent2()
233 {
234     notImplemented();
235 }
236
237
238 void FrameLoaderClientWx::detachedFromParent3()
239 {
240     notImplemented();
241 }
242
243
244 void FrameLoaderClientWx::detachedFromParent4()
245 {
246     notImplemented();
247 }
248
249
250 void FrameLoaderClientWx::loadedFromCachedPage()
251 {
252     notImplemented();
253 }
254
255
256 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
257 {
258     notImplemented();
259 }
260
261
262 void FrameLoaderClientWx::dispatchDidReceiveServerRedirectForProvisionalLoad()
263 {
264     notImplemented();
265 }
266
267
268 void FrameLoaderClientWx::dispatchDidCancelClientRedirect()
269 {
270     notImplemented();
271 }
272
273
274 void FrameLoaderClientWx::dispatchWillPerformClientRedirect(const KURL&,
275                                                             double interval,
276                                                             double fireDate)
277 {
278     notImplemented();
279 }
280
281
282 void FrameLoaderClientWx::dispatchDidChangeLocationWithinPage()
283 {
284     notImplemented();
285 }
286
287
288 void FrameLoaderClientWx::dispatchWillClose()
289 {
290     notImplemented();
291 }
292
293
294 void FrameLoaderClientWx::dispatchDidStartProvisionalLoad()
295 {
296     wxWindow* target = m_frame->view()->nativeWindow();
297     if (target) {
298         wxWebViewStateChangedEvent wkEvent(target);
299         wkEvent.SetState(wxWEBVIEW_STATE_NEGOTIATING);
300         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().string());
301         target->GetEventHandler()->ProcessEvent(wkEvent);
302     }
303 }
304
305
306 void FrameLoaderClientWx::dispatchDidReceiveTitle(const String& title)
307 {
308     wxWebView* target = static_cast<wxWebView*>(m_frame->view()->nativeWindow());
309     if (target)
310         target->SetPageTitle(title);
311 }
312
313
314 void FrameLoaderClientWx::dispatchDidCommitLoad()
315 {
316     wxWindow* target = m_frame->view()->nativeWindow();
317     if (target) {
318         wxWebViewStateChangedEvent wkEvent(target);
319         wkEvent.SetState(wxWEBVIEW_STATE_TRANSFERRING);
320         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
321         target->GetEventHandler()->ProcessEvent(wkEvent);
322     }
323 }
324
325 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
326 {
327     wxWindow* target = m_frame->view()->nativeWindow();
328     if (target) {
329         wxWebViewStateChangedEvent wkEvent(target);
330         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
331         wkEvent.SetURL(m_frame->loader()->url().string());
332         target->GetEventHandler()->ProcessEvent(wkEvent);
333     }
334 }
335
336 void FrameLoaderClientWx::dispatchDidFinishLoad()
337 {
338     notImplemented();
339 }
340
341
342 void FrameLoaderClientWx::dispatchDidFirstLayout()
343 {
344     notImplemented();
345 }
346
347
348 void FrameLoaderClientWx::dispatchShow()
349 {
350     notImplemented();
351 }
352
353
354 void FrameLoaderClientWx::cancelPolicyCheck()
355 {
356     notImplemented();
357 }
358
359
360 void FrameLoaderClientWx::dispatchWillSubmitForm(FramePolicyFunction function,
361                                                  PassRefPtr<FormState>)
362 {
363     // FIXME: Send an event to allow for alerts and cancellation
364     if (!m_frame)
365         return;
366     (m_frame->loader()->*function)(PolicyUse);
367 }
368
369
370 void FrameLoaderClientWx::dispatchDidLoadMainResource(DocumentLoader*)
371 {
372     notImplemented();
373 }
374
375
376 void FrameLoaderClientWx::revertToProvisionalState(DocumentLoader*)
377 {
378     notImplemented();
379 }
380
381
382 void FrameLoaderClientWx::clearUnarchivingState(DocumentLoader*)
383 {
384     notImplemented();
385 }
386
387 void FrameLoaderClientWx::postProgressStartedNotification()
388 {
389     notImplemented();
390 }
391
392 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
393 {
394     notImplemented();
395 }
396
397 void FrameLoaderClientWx::postProgressFinishedNotification()
398 {
399     wxWindow* target = m_frame->view()->nativeWindow();
400     if (target) {
401         wxWebViewStateChangedEvent wkEvent(target);
402         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
403         wkEvent.SetURL(m_frame->loader()->url().string());
404         target->GetEventHandler()->ProcessEvent(wkEvent);
405     }
406 }
407
408 void FrameLoaderClientWx::progressStarted()
409 {
410     notImplemented();
411 }
412
413
414 void FrameLoaderClientWx::progressCompleted()
415 {
416     notImplemented();
417 }
418
419
420 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
421 {
422     notImplemented();
423     // this is only interesting once we provide an external API for the DOM
424 }
425
426
427 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
428 {
429     notImplemented();
430 }
431
432
433 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
434 {
435     setTitle(l->title(), l->url());
436 }
437
438
439 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
440 {
441     notImplemented();
442 }
443
444
445 void FrameLoaderClientWx::finalSetupForReplace(DocumentLoader*)
446 {
447     notImplemented();
448 }
449
450
451 void FrameLoaderClientWx::setDefersLoading(bool)
452 {
453     notImplemented();
454 }
455
456
457 bool FrameLoaderClientWx::isArchiveLoadPending(ResourceLoader*) const
458 {
459     notImplemented();
460     return false;
461 }
462
463
464 void FrameLoaderClientWx::cancelPendingArchiveLoad(ResourceLoader*)
465 {
466     notImplemented();
467 }
468
469
470 void FrameLoaderClientWx::clearArchivedResources()
471 {
472     notImplemented();
473 }
474
475
476 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
477 {
478     notImplemented();
479     return true;
480 }
481
482
483 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
484 {
485     notImplemented();
486     return false;
487 }
488
489
490 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
491 {
492     notImplemented();
493     return String();
494 }
495
496
497 void FrameLoaderClientWx::frameLoadCompleted()
498 {
499     notImplemented();
500 }
501
502 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
503 {
504     notImplemented();
505 }
506
507 void FrameLoaderClientWx::restoreViewState()
508 {
509     notImplemented();
510 }
511         
512 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
513 {
514     notImplemented();
515 }
516
517
518 void FrameLoaderClientWx::provisionalLoadStarted()
519 {
520     notImplemented();
521 }
522
523
524 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
525 {
526     notImplemented();
527     return false;
528 }
529
530
531 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
532 {
533     notImplemented();
534 }
535
536
537 void FrameLoaderClientWx::didFinishLoad()
538 {
539     notImplemented();
540 }
541
542
543 void FrameLoaderClientWx::prepareForDataSourceReplacement()
544 {
545     if (m_frame && m_frame->loader())
546         m_frame->loader()->detachChildren();
547 }
548
549
550 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
551 {
552     notImplemented();
553 }
554
555
556 String FrameLoaderClientWx::userAgent(const KURL&)
557 {
558     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
559     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
560 }
561
562 void FrameLoaderClientWx::dispatchDidReceiveIcon()
563 {
564     notImplemented();
565 }
566
567 void FrameLoaderClientWx::frameLoaderDestroyed()
568 {
569     m_frame = 0;
570     delete this;
571 }
572
573 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
574 {
575     notImplemented();
576     return true;
577 }
578
579 void FrameLoaderClientWx::partClearedInBegin()
580 {
581     notImplemented();
582 }
583
584 void FrameLoaderClientWx::setDocumentViewFromCachedPage(WebCore::CachedPage*)
585 {
586     notImplemented();
587 }
588
589 void FrameLoaderClientWx::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
590 {
591     notImplemented();
592 }
593
594 void FrameLoaderClientWx::updateGlobalHistoryForReload(const WebCore::KURL&)
595 {
596     notImplemented();
597 }
598
599 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
600 {
601     notImplemented();
602     return true;
603 }
604
605 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
606 {
607     notImplemented();
608 }
609
610 void FrameLoaderClientWx::saveDocumentViewToCachedPage(WebCore::CachedPage*)
611 {
612     notImplemented();
613 }
614
615 bool FrameLoaderClientWx::canCachePage() const
616 {
617     return false;
618 }
619
620 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
621 {
622     notImplemented();
623 }
624
625 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
626 {
627     if (!m_frame)
628         return;
629     FrameLoader* fl = loader->frameLoader();
630     fl->setEncoding(m_response.textEncodingName(), false);
631     fl->addData(data, length);
632 }
633
634 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
635 {
636     notImplemented();
637     return ResourceError();
638 }
639
640 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
641 {
642     notImplemented();
643     return ResourceError();
644 }
645
646 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
647 {
648     notImplemented();
649     return ResourceError();
650 }
651
652 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
653 {
654     notImplemented();
655     return ResourceError();
656 }
657
658 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
659 {
660     notImplemented();
661     return ResourceError();
662 }
663
664 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
665 {
666     notImplemented();
667     return ResourceError();
668 }
669
670 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
671 {
672     notImplemented();
673     return false;
674 }
675
676 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
677 {
678     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
679     return loader.release();
680 }
681
682 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
683 {
684     notImplemented();
685 }
686
687 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
688 {
689     notImplemented();   
690 }
691
692 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
693 {
694     notImplemented();
695 }
696
697 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
698 {
699     notImplemented();
700 }
701
702 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
703 {
704     notImplemented();
705 }
706
707 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
708 {
709     notImplemented();
710     m_response = response;
711     m_firstData = true;
712 }
713
714 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
715 {
716     notImplemented();
717 }
718
719 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
720 {
721     notImplemented();
722 }
723
724 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
725 {
726     notImplemented();
727 }
728
729 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
730 {
731     notImplemented();
732     return false;
733 }
734
735 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
736 {
737     notImplemented();
738 }
739
740 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
741 {
742     notImplemented();
743 }
744
745 Frame* FrameLoaderClientWx::dispatchCreatePage()
746 {
747     notImplemented();
748     return false;
749 }
750
751 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
752 {
753     if (!m_frame)
754         return;
755     
756     notImplemented();
757     (m_frame->loader()->*function)(PolicyUse);
758 }
759
760 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
761 {
762     if (!m_frame)
763         return;
764
765     notImplemented();
766     (m_frame->loader()->*function)(PolicyUse);
767 }
768
769 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
770 {
771     if (!m_frame)
772         return;
773         
774     wxWindow* target = m_frame->view()->nativeWindow();
775     if (target) {
776         wxWebViewBeforeLoadEvent wkEvent(target);
777         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
778         wkEvent.SetURL(request.url().string());
779         
780         target->GetEventHandler()->ProcessEvent(wkEvent);
781         if (wkEvent.IsCancelled())
782             (m_frame->loader()->*function)(PolicyIgnore);
783         else
784             (m_frame->loader()->*function)(PolicyUse);
785         
786     }
787 }
788
789 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
790 {
791     notImplemented();
792 }
793
794 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
795 {
796     notImplemented();
797 }
798
799 bool FrameLoaderClientWx::willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const
800 {
801     notImplemented();
802     return false;
803 }
804
805 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
806                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
807 {
808 /*
809     FIXME: Temporarily disabling code for loading subframes. While most 
810     (i)frames load and are destroyed properly, the iframe created by
811     google.com in its new homepage does not get destroyed when 
812     document()->detach() is called, as other (i)frames do. It is destroyed on 
813     app shutdown, but until that point, this 'in limbo' frame will do things
814     like steal keyboard focus and crash when clicked on. (On some platforms,
815     it is actually a visible object, even though it's not in a valid state.)
816     
817     Since just about every user is probably going to test against Google at 
818     some point, I'm disabling this functionality until I have time to track down
819     why it is not being destroyed.
820 */
821
822 /*
823     wxWindow* parent = m_frame->view()->nativeWindow();
824
825     WebViewFrameData* data = new WebViewFrameData();
826     data->name = name;
827     data->ownerElement = ownerElement;
828     data->url = url;
829     data->referrer = referrer;
830     data->marginWidth = marginWidth;
831     data->marginHeight = marginHeight;
832
833     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
834
835     RefPtr<Frame> childFrame = newWin->m_impl->frame;
836
837     // FIXME: All of the below should probably be moved over into WebCore
838     childFrame->tree()->setName(name);
839     m_frame->tree()->appendChild(childFrame);
840     // ### set override encoding if we have one
841
842     FrameLoadType loadType = m_frame->loader()->loadType();
843     FrameLoadType childLoadType = FrameLoadTypeInternal;
844
845     childFrame->loader()->load(url, referrer, childLoadType,
846                             String(), 0, 0);
847     
848     // The frame's onload handler may have removed it from the document.
849     if (!childFrame->tree()->parent())
850         return 0;
851     
852     delete data;
853     
854     return childFrame.get();
855 */
856     notImplemented();
857     return 0;
858 }
859
860 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
861 {
862     notImplemented();
863     return ObjectContentType();
864 }
865
866 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
867 {
868     notImplemented();
869     return 0;
870 }
871
872 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
873 {
874     notImplemented();
875     return;
876 }
877
878 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
879                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
880 {
881     notImplemented();
882     return 0;
883 }
884
885 String FrameLoaderClientWx::overrideMediaType() const
886 {
887     notImplemented();
888     return String();
889 }
890
891 void FrameLoaderClientWx::windowObjectCleared()
892 {
893     notImplemented();
894 }
895
896 void FrameLoaderClientWx::didPerformFirstNavigation() const
897 {
898     notImplemented();
899 }
900
901 void FrameLoaderClientWx::registerForIconNotification(bool listen)
902 {
903     notImplemented();
904 }
905
906 }