1ab80fd4906ff8f9a201a63433bbfc829efb3c11
[WebKit.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 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
134 {
135     notImplemented();
136 }
137
138
139 void FrameLoaderClientWx::forceLayout()
140 {
141     notImplemented();
142 }
143
144
145 void FrameLoaderClientWx::forceLayoutForNonHTML()
146 {
147     notImplemented();
148 }
149
150
151 void FrameLoaderClientWx::updateHistoryForCommit()
152 {
153     notImplemented();
154 }
155
156
157 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
158 {
159     notImplemented();
160 }
161
162
163 void FrameLoaderClientWx::updateHistoryForReload()
164 {
165     notImplemented();
166 }
167
168
169 void FrameLoaderClientWx::updateHistoryForStandardLoad()
170 {
171     notImplemented();
172 }
173
174
175 void FrameLoaderClientWx::updateHistoryForInternalLoad()
176 {
177     notImplemented();
178 }
179
180
181 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
182 {
183     notImplemented();
184 }
185
186
187 void FrameLoaderClientWx::setCopiesOnScroll()
188 {
189     // apparently mac specific
190     notImplemented();
191 }
192
193
194 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
195 {
196     notImplemented();
197     return 0;
198 }
199
200
201 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
202 {
203     notImplemented();
204 }
205
206
207 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
208 {
209     notImplemented();
210 }
211
212
213 void FrameLoaderClientWx::willCloseDocument()
214 {
215     notImplemented();
216 }
217
218
219 void FrameLoaderClientWx::detachedFromParent1()
220 {
221     notImplemented();
222 }
223
224
225 void FrameLoaderClientWx::detachedFromParent2()
226 {
227     notImplemented();
228 }
229
230
231 void FrameLoaderClientWx::detachedFromParent3()
232 {
233     notImplemented();
234 }
235
236
237 void FrameLoaderClientWx::detachedFromParent4()
238 {
239     notImplemented();
240 }
241
242
243 void FrameLoaderClientWx::loadedFromCachedPage()
244 {
245     notImplemented();
246 }
247
248
249 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
250 {
251     notImplemented();
252 }
253
254
255 void FrameLoaderClientWx::dispatchDidReceiveServerRedirectForProvisionalLoad()
256 {
257     notImplemented();
258 }
259
260
261 void FrameLoaderClientWx::dispatchDidCancelClientRedirect()
262 {
263     notImplemented();
264 }
265
266
267 void FrameLoaderClientWx::dispatchWillPerformClientRedirect(const KURL&,
268                                                             double interval,
269                                                             double fireDate)
270 {
271     notImplemented();
272 }
273
274
275 void FrameLoaderClientWx::dispatchDidChangeLocationWithinPage()
276 {
277     notImplemented();
278 }
279
280
281 void FrameLoaderClientWx::dispatchWillClose()
282 {
283     notImplemented();
284 }
285
286
287 void FrameLoaderClientWx::dispatchDidStartProvisionalLoad()
288 {
289     wxWindow* target = m_frame->view()->nativeWindow();
290     if (target) {
291         wxWebViewStateChangedEvent wkEvent(target);
292         wkEvent.SetState(wxWEBVIEW_STATE_NEGOTIATING);
293         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().string());
294         target->GetEventHandler()->ProcessEvent(wkEvent);
295     }
296 }
297
298
299 void FrameLoaderClientWx::dispatchDidReceiveTitle(const String& title)
300 {
301     wxWebView* target = static_cast<wxWebView*>(m_frame->view()->nativeWindow());
302     if (target)
303         target->SetPageTitle(title);
304 }
305
306
307 void FrameLoaderClientWx::dispatchDidCommitLoad()
308 {
309     wxWindow* target = m_frame->view()->nativeWindow();
310     if (target) {
311         wxWebViewStateChangedEvent wkEvent(target);
312         wkEvent.SetState(wxWEBVIEW_STATE_TRANSFERRING);
313         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
314         target->GetEventHandler()->ProcessEvent(wkEvent);
315     }
316 }
317
318 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
319 {
320     wxWindow* target = m_frame->view()->nativeWindow();
321     if (target) {
322         wxWebViewStateChangedEvent wkEvent(target);
323         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
324         wkEvent.SetURL(m_frame->loader()->url().string());
325         target->GetEventHandler()->ProcessEvent(wkEvent);
326     }
327 }
328
329 void FrameLoaderClientWx::dispatchDidFinishLoad()
330 {
331     notImplemented();
332 }
333
334
335 void FrameLoaderClientWx::dispatchDidFirstLayout()
336 {
337     notImplemented();
338 }
339
340
341 void FrameLoaderClientWx::dispatchShow()
342 {
343     notImplemented();
344 }
345
346
347 void FrameLoaderClientWx::cancelPolicyCheck()
348 {
349     notImplemented();
350 }
351
352
353 void FrameLoaderClientWx::dispatchWillSubmitForm(FramePolicyFunction function,
354                                                  PassRefPtr<FormState>)
355 {
356     // FIXME: Send an event to allow for alerts and cancellation
357     if (!m_frame)
358         return;
359     (m_frame->loader()->*function)(PolicyUse);
360 }
361
362
363 void FrameLoaderClientWx::dispatchDidLoadMainResource(DocumentLoader*)
364 {
365     notImplemented();
366 }
367
368
369 void FrameLoaderClientWx::revertToProvisionalState(DocumentLoader*)
370 {
371     notImplemented();
372 }
373
374
375 void FrameLoaderClientWx::clearUnarchivingState(DocumentLoader*)
376 {
377     notImplemented();
378 }
379
380 void FrameLoaderClientWx::postProgressStartedNotification()
381 {
382     notImplemented();
383 }
384
385 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
386 {
387     notImplemented();
388 }
389
390 void FrameLoaderClientWx::postProgressFinishedNotification()
391 {
392     wxWindow* target = m_frame->view()->nativeWindow();
393     if (target) {
394         wxWebViewStateChangedEvent wkEvent(target);
395         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
396         wkEvent.SetURL(m_frame->loader()->url().string());
397         target->GetEventHandler()->ProcessEvent(wkEvent);
398     }
399 }
400
401 void FrameLoaderClientWx::progressStarted()
402 {
403     notImplemented();
404 }
405
406
407 void FrameLoaderClientWx::progressCompleted()
408 {
409     notImplemented();
410 }
411
412
413 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
414 {
415     notImplemented();
416     // this is only interesting once we provide an external API for the DOM
417 }
418
419
420 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
421 {
422     notImplemented();
423 }
424
425
426 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
427 {
428     setTitle(l->title(), l->url());
429 }
430
431
432 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
433 {
434     notImplemented();
435 }
436
437
438 void FrameLoaderClientWx::finalSetupForReplace(DocumentLoader*)
439 {
440     notImplemented();
441 }
442
443
444 void FrameLoaderClientWx::setDefersLoading(bool)
445 {
446     notImplemented();
447 }
448
449
450 bool FrameLoaderClientWx::isArchiveLoadPending(ResourceLoader*) const
451 {
452     notImplemented();
453     return false;
454 }
455
456
457 void FrameLoaderClientWx::cancelPendingArchiveLoad(ResourceLoader*)
458 {
459     notImplemented();
460 }
461
462
463 void FrameLoaderClientWx::clearArchivedResources()
464 {
465     notImplemented();
466 }
467
468
469 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
470 {
471     notImplemented();
472     return true;
473 }
474
475
476 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
477 {
478     notImplemented();
479     return false;
480 }
481
482
483 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
484 {
485     notImplemented();
486     return String();
487 }
488
489
490 void FrameLoaderClientWx::frameLoadCompleted()
491 {
492     notImplemented();
493 }
494
495 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
496 {
497     notImplemented();
498 }
499
500 void FrameLoaderClientWx::restoreViewState()
501 {
502     notImplemented();
503 }
504         
505 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
506 {
507     notImplemented();
508 }
509
510
511 void FrameLoaderClientWx::provisionalLoadStarted()
512 {
513     notImplemented();
514 }
515
516
517 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
518 {
519     notImplemented();
520     return false;
521 }
522
523
524 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
525 {
526     notImplemented();
527 }
528
529
530 void FrameLoaderClientWx::didFinishLoad()
531 {
532     notImplemented();
533 }
534
535
536 void FrameLoaderClientWx::prepareForDataSourceReplacement()
537 {
538     if (m_frame && m_frame->loader())
539         m_frame->loader()->detachChildren();
540 }
541
542
543 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
544 {
545     notImplemented();
546 }
547
548
549 String FrameLoaderClientWx::userAgent(const KURL&)
550 {
551     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
552     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
553 }
554
555 void FrameLoaderClientWx::dispatchDidReceiveIcon()
556 {
557     notImplemented();
558 }
559
560 void FrameLoaderClientWx::frameLoaderDestroyed()
561 {
562     m_frame = 0;
563     delete this;
564 }
565
566 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
567 {
568     notImplemented();
569     return true;
570 }
571
572 void FrameLoaderClientWx::partClearedInBegin()
573 {
574     notImplemented();
575 }
576
577 void FrameLoaderClientWx::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
578 {
579     notImplemented();
580 }
581
582 void FrameLoaderClientWx::updateGlobalHistoryForReload(const WebCore::KURL&)
583 {
584     notImplemented();
585 }
586
587 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
588 {
589     notImplemented();
590     return true;
591 }
592
593 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
594 {
595     notImplemented();
596 }
597
598 bool FrameLoaderClientWx::canCachePage() const
599 {
600     return false;
601 }
602
603 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
604 {
605     notImplemented();
606 }
607
608 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
609 {
610     if (!m_frame)
611         return;
612     FrameLoader* fl = loader->frameLoader();
613     fl->setEncoding(m_response.textEncodingName(), false);
614     fl->addData(data, length);
615 }
616
617 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
618 {
619     notImplemented();
620     return ResourceError();
621 }
622
623 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
624 {
625     notImplemented();
626     return ResourceError();
627 }
628
629 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
630 {
631     notImplemented();
632     return ResourceError();
633 }
634
635 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
636 {
637     notImplemented();
638     return ResourceError();
639 }
640
641 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
642 {
643     notImplemented();
644     return ResourceError();
645 }
646
647 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
648 {
649     notImplemented();
650     return ResourceError();
651 }
652
653 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
654 {
655     notImplemented();
656     return false;
657 }
658
659 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
660 {
661     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
662     return loader.release();
663 }
664
665 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
666 {
667     notImplemented();
668 }
669
670 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
671 {
672     notImplemented();   
673 }
674
675 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
676 {
677     notImplemented();
678 }
679
680 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
681 {
682     notImplemented();
683 }
684
685 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
686 {
687     notImplemented();
688 }
689
690 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
691 {
692     notImplemented();
693     m_response = response;
694     m_firstData = true;
695 }
696
697 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
698 {
699     notImplemented();
700 }
701
702 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
703 {
704     notImplemented();
705 }
706
707 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
708 {
709     notImplemented();
710 }
711
712 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
713 {
714     notImplemented();
715     return false;
716 }
717
718 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
719 {
720     notImplemented();
721 }
722
723 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
724 {
725     notImplemented();
726 }
727
728 Frame* FrameLoaderClientWx::dispatchCreatePage()
729 {
730     notImplemented();
731     return false;
732 }
733
734 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
735 {
736     if (!m_frame)
737         return;
738     
739     notImplemented();
740     (m_frame->loader()->*function)(PolicyUse);
741 }
742
743 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
744 {
745     if (!m_frame)
746         return;
747
748     notImplemented();
749     (m_frame->loader()->*function)(PolicyUse);
750 }
751
752 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
753 {
754     if (!m_frame)
755         return;
756         
757     wxWindow* target = m_frame->view()->nativeWindow();
758     if (target) {
759         wxWebViewBeforeLoadEvent wkEvent(target);
760         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
761         wkEvent.SetURL(request.url().string());
762         
763         target->GetEventHandler()->ProcessEvent(wkEvent);
764         if (wkEvent.IsCancelled())
765             (m_frame->loader()->*function)(PolicyIgnore);
766         else
767             (m_frame->loader()->*function)(PolicyUse);
768         
769     }
770 }
771
772 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
773 {
774     notImplemented();
775 }
776
777 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
778 {
779     notImplemented();
780 }
781
782 bool FrameLoaderClientWx::willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const
783 {
784     notImplemented();
785     return false;
786 }
787
788 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
789                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
790 {
791 /*
792     FIXME: Temporarily disabling code for loading subframes. While most 
793     (i)frames load and are destroyed properly, the iframe created by
794     google.com in its new homepage does not get destroyed when 
795     document()->detach() is called, as other (i)frames do. It is destroyed on 
796     app shutdown, but until that point, this 'in limbo' frame will do things
797     like steal keyboard focus and crash when clicked on. (On some platforms,
798     it is actually a visible object, even though it's not in a valid state.)
799     
800     Since just about every user is probably going to test against Google at 
801     some point, I'm disabling this functionality until I have time to track down
802     why it is not being destroyed.
803 */
804
805 /*
806     wxWindow* parent = m_frame->view()->nativeWindow();
807
808     WebViewFrameData* data = new WebViewFrameData();
809     data->name = name;
810     data->ownerElement = ownerElement;
811     data->url = url;
812     data->referrer = referrer;
813     data->marginWidth = marginWidth;
814     data->marginHeight = marginHeight;
815
816     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
817
818     RefPtr<Frame> childFrame = newWin->m_impl->frame;
819
820     // FIXME: All of the below should probably be moved over into WebCore
821     childFrame->tree()->setName(name);
822     m_frame->tree()->appendChild(childFrame);
823     // ### set override encoding if we have one
824
825     FrameLoadType loadType = m_frame->loader()->loadType();
826     FrameLoadType childLoadType = FrameLoadTypeInternal;
827
828     childFrame->loader()->load(url, referrer, childLoadType,
829                             String(), 0, 0);
830     
831     // The frame's onload handler may have removed it from the document.
832     if (!childFrame->tree()->parent())
833         return 0;
834     
835     delete data;
836     
837     return childFrame.get();
838 */
839     notImplemented();
840     return 0;
841 }
842
843 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
844 {
845     notImplemented();
846     return ObjectContentType();
847 }
848
849 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
850 {
851     notImplemented();
852     return 0;
853 }
854
855 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
856 {
857     notImplemented();
858     return;
859 }
860
861 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
862                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
863 {
864     notImplemented();
865     return 0;
866 }
867
868 String FrameLoaderClientWx::overrideMediaType() const
869 {
870     notImplemented();
871     return String();
872 }
873
874 void FrameLoaderClientWx::windowObjectCleared()
875 {
876     notImplemented();
877 }
878
879 void FrameLoaderClientWx::didPerformFirstNavigation() const
880 {
881     notImplemented();
882 }
883
884 void FrameLoaderClientWx::registerForIconNotification(bool listen)
885 {
886     notImplemented();
887 }
888
889 void FrameLoaderClientWx::savePlatformDataToCachedPage(CachedPage*)
890
891     notImplemented();
892 }
893
894 void FrameLoaderClientWx::transitionToCommittedFromCachedPage(CachedPage*)
895
896     notImplemented();
897 }
898
899 void FrameLoaderClientWx::transitionToCommittedForNewPage()
900
901     notImplemented();
902 }
903
904 }