dec56cc258b6e7301c6e455eee6e8e8ff92bb25b
[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     : RefCounted<FrameLoaderClientWx>(0)
72     , m_frame(0)
73 {
74 }
75
76
77 FrameLoaderClientWx::~FrameLoaderClientWx()
78 {
79 }
80
81 void FrameLoaderClientWx::setFrame(Frame *frame)
82 {
83     m_frame = frame;
84 }
85
86 void FrameLoaderClientWx::detachFrameLoader()
87 {
88     m_frame = 0;
89 }
90
91 void FrameLoaderClientWx::ref()
92 {
93     RefCounted<FrameLoaderClientWx>::ref();
94 }
95
96 void FrameLoaderClientWx::deref()
97 {
98     RefCounted<FrameLoaderClientWx>::deref();
99 }
100
101 bool FrameLoaderClientWx::hasWebView() const
102 {
103     notImplemented();
104     return true;
105 }
106
107
108 bool FrameLoaderClientWx::hasFrameView() const
109 {
110     notImplemented();
111     return true;
112 }
113
114
115 bool FrameLoaderClientWx::hasBackForwardList() const
116 {
117     notImplemented();
118     return true;
119 }
120
121
122 void FrameLoaderClientWx::resetBackForwardList()
123 {
124     notImplemented();
125 }
126
127
128 bool FrameLoaderClientWx::provisionalItemIsTarget() const
129 {
130     notImplemented();
131     return false;
132 }
133
134 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
135 {
136     notImplemented();
137 }
138
139
140 void FrameLoaderClientWx::forceLayout()
141 {
142     notImplemented();
143 }
144
145
146 void FrameLoaderClientWx::forceLayoutForNonHTML()
147 {
148     notImplemented();
149 }
150
151
152 void FrameLoaderClientWx::updateHistoryForCommit()
153 {
154     notImplemented();
155 }
156
157
158 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
159 {
160     notImplemented();
161 }
162
163
164 void FrameLoaderClientWx::updateHistoryForReload()
165 {
166     notImplemented();
167 }
168
169
170 void FrameLoaderClientWx::updateHistoryForStandardLoad()
171 {
172     notImplemented();
173 }
174
175
176 void FrameLoaderClientWx::updateHistoryForInternalLoad()
177 {
178     notImplemented();
179 }
180
181
182 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
183 {
184     notImplemented();
185 }
186
187
188 void FrameLoaderClientWx::setCopiesOnScroll()
189 {
190     // apparently mac specific
191     notImplemented();
192 }
193
194
195 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
196 {
197     notImplemented();
198     return 0;
199 }
200
201
202 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
203 {
204     notImplemented();
205 }
206
207
208 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
209 {
210     notImplemented();
211 }
212
213
214 void FrameLoaderClientWx::willCloseDocument()
215 {
216     notImplemented();
217 }
218
219
220 void FrameLoaderClientWx::detachedFromParent1()
221 {
222     notImplemented();
223 }
224
225
226 void FrameLoaderClientWx::detachedFromParent2()
227 {
228     notImplemented();
229 }
230
231
232 void FrameLoaderClientWx::detachedFromParent3()
233 {
234     notImplemented();
235 }
236
237
238 void FrameLoaderClientWx::detachedFromParent4()
239 {
240     notImplemented();
241 }
242
243
244 void FrameLoaderClientWx::loadedFromCachedPage()
245 {
246     notImplemented();
247 }
248
249
250 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
251 {
252     wxWindow* target = m_frame->view()->nativeWindow();
253     if (target) {
254         wxWebViewLoadEvent wkEvent(target);
255         wkEvent.SetState(wxWEBVIEW_LOAD_ONLOAD_HANDLED);
256         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
257         target->GetEventHandler()->ProcessEvent(wkEvent);
258     }
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         wxWebViewLoadEvent wkEvent(target);
299         wkEvent.SetState(wxWEBVIEW_LOAD_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         wxWebViewLoadEvent wkEvent(target);
319         wkEvent.SetState(wxWEBVIEW_LOAD_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         wxWebViewLoadEvent wkEvent(target);
330         wkEvent.SetState(wxWEBVIEW_LOAD_DOC_COMPLETED);
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 void FrameLoaderClientWx::postProgressStartedNotification()
382 {
383     notImplemented();
384 }
385
386 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
387 {
388     notImplemented();
389 }
390
391 void FrameLoaderClientWx::postProgressFinishedNotification()
392 {
393     wxWindow* target = m_frame->view()->nativeWindow();
394     if (target) {
395         wxWebViewLoadEvent wkEvent(target);
396         wkEvent.SetState(wxWEBVIEW_LOAD_DL_COMPLETED);
397         wkEvent.SetURL(m_frame->loader()->url().string());
398         target->GetEventHandler()->ProcessEvent(wkEvent);
399     }
400 }
401
402 void FrameLoaderClientWx::progressStarted()
403 {
404     notImplemented();
405 }
406
407
408 void FrameLoaderClientWx::progressCompleted()
409 {
410     notImplemented();
411 }
412
413
414 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
415 {
416     notImplemented();
417     // this is only interesting once we provide an external API for the DOM
418 }
419
420
421 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
422 {
423     notImplemented();
424 }
425
426
427 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
428 {
429     setTitle(l->title(), l->url());
430 }
431
432
433 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
434 {
435     notImplemented();
436 }
437
438
439 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
440 {
441     notImplemented();
442     return true;
443 }
444
445
446 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
447 {
448     notImplemented();
449     return false;
450 }
451
452
453 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
454 {
455     notImplemented();
456     return String();
457 }
458
459
460 void FrameLoaderClientWx::frameLoadCompleted()
461 {
462     notImplemented();
463 }
464
465 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
466 {
467     notImplemented();
468 }
469
470 void FrameLoaderClientWx::restoreViewState()
471 {
472     notImplemented();
473 }
474         
475 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
476 {
477     notImplemented();
478 }
479
480
481 void FrameLoaderClientWx::provisionalLoadStarted()
482 {
483     notImplemented();
484 }
485
486
487 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
488 {
489     notImplemented();
490     return false;
491 }
492
493
494 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
495 {
496     notImplemented();
497 }
498
499
500 void FrameLoaderClientWx::didFinishLoad()
501 {
502     notImplemented();
503 }
504
505
506 void FrameLoaderClientWx::prepareForDataSourceReplacement()
507 {
508     if (m_frame && m_frame->loader())
509         m_frame->loader()->detachChildren();
510 }
511
512
513 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
514 {
515     notImplemented();
516 }
517
518
519 String FrameLoaderClientWx::userAgent(const KURL&)
520 {
521     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
522     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
523 }
524
525 void FrameLoaderClientWx::dispatchDidReceiveIcon()
526 {
527     notImplemented();
528 }
529
530 void FrameLoaderClientWx::frameLoaderDestroyed()
531 {
532     m_frame = 0;
533     delete this;
534 }
535
536 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
537 {
538     notImplemented();
539     return true;
540 }
541
542 void FrameLoaderClientWx::partClearedInBegin()
543 {
544     notImplemented();
545 }
546
547 void FrameLoaderClientWx::updateGlobalHistory(const WebCore::KURL&)
548 {
549     notImplemented();
550 }
551
552 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
553 {
554     notImplemented();
555     return true;
556 }
557
558 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
559 {
560     notImplemented();
561 }
562
563 bool FrameLoaderClientWx::canCachePage() const
564 {
565     return false;
566 }
567
568 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
569 {
570     notImplemented();
571 }
572
573 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
574 {
575     if (!m_frame)
576         return;
577     FrameLoader* fl = loader->frameLoader();
578     fl->setEncoding(m_response.textEncodingName(), false);
579     fl->addData(data, length);
580 }
581
582 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
583 {
584     notImplemented();
585     return ResourceError();
586 }
587
588 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
589 {
590     notImplemented();
591     return ResourceError();
592 }
593
594 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
595 {
596     notImplemented();
597     return ResourceError();
598 }
599
600 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
601 {
602     notImplemented();
603     return ResourceError();
604 }
605
606 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
607 {
608     notImplemented();
609     return ResourceError();
610 }
611
612 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
613 {
614     notImplemented();
615     return ResourceError();
616 }
617
618 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
619 {
620     notImplemented();
621     return false;
622 }
623
624 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
625 {
626     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
627     return loader.release();
628 }
629
630 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
631 {
632     notImplemented();
633 }
634
635 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
636 {
637     notImplemented();   
638 }
639
640 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
641 {
642     notImplemented();
643 }
644
645 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
646 {
647     notImplemented();
648 }
649
650 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
651 {
652     notImplemented();
653 }
654
655 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
656 {
657     notImplemented();
658     m_response = response;
659     m_firstData = true;
660 }
661
662 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
663 {
664     notImplemented();
665 }
666
667 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
668 {
669     notImplemented();
670 }
671
672 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
673 {
674     notImplemented();
675 }
676
677 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
678 {
679     notImplemented();
680     return false;
681 }
682
683 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
684 {
685     notImplemented();
686 }
687
688 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
689 {
690     notImplemented();
691 }
692
693 Frame* FrameLoaderClientWx::dispatchCreatePage()
694 {
695     notImplemented();
696     return false;
697 }
698
699 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
700 {
701     if (!m_frame)
702         return;
703     
704     notImplemented();
705     (m_frame->loader()->*function)(PolicyUse);
706 }
707
708 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
709 {
710     if (!m_frame)
711         return;
712
713     notImplemented();
714     (m_frame->loader()->*function)(PolicyUse);
715 }
716
717 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
718 {
719     if (!m_frame)
720         return;
721         
722     wxWindow* target = m_frame->view()->nativeWindow();
723     if (target) {
724         wxWebViewBeforeLoadEvent wkEvent(target);
725         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
726         wkEvent.SetURL(request.url().string());
727         
728         target->GetEventHandler()->ProcessEvent(wkEvent);
729         if (wkEvent.IsCancelled())
730             (m_frame->loader()->*function)(PolicyIgnore);
731         else
732             (m_frame->loader()->*function)(PolicyUse);
733         
734     }
735 }
736
737 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
738 {
739     notImplemented();
740 }
741
742 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
743 {
744     notImplemented();
745 }
746
747 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
748                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
749 {
750 /*
751     FIXME: Temporarily disabling code for loading subframes. While most 
752     (i)frames load and are destroyed properly, the iframe created by
753     google.com in its new homepage does not get destroyed when 
754     document()->detach() is called, as other (i)frames do. It is destroyed on 
755     app shutdown, but until that point, this 'in limbo' frame will do things
756     like steal keyboard focus and crash when clicked on. (On some platforms,
757     it is actually a visible object, even though it's not in a valid state.)
758     
759     Since just about every user is probably going to test against Google at 
760     some point, I'm disabling this functionality until I have time to track down
761     why it is not being destroyed.
762 */
763
764 /*
765     wxWindow* parent = m_frame->view()->nativeWindow();
766
767     WebViewFrameData* data = new WebViewFrameData();
768     data->name = name;
769     data->ownerElement = ownerElement;
770     data->url = url;
771     data->referrer = referrer;
772     data->marginWidth = marginWidth;
773     data->marginHeight = marginHeight;
774
775     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
776
777     RefPtr<Frame> childFrame = newWin->m_impl->frame;
778
779     // FIXME: All of the below should probably be moved over into WebCore
780     childFrame->tree()->setName(name);
781     m_frame->tree()->appendChild(childFrame);
782     // ### set override encoding if we have one
783
784     FrameLoadType loadType = m_frame->loader()->loadType();
785     FrameLoadType childLoadType = FrameLoadTypeInternal;
786
787     childFrame->loader()->load(url, referrer, childLoadType,
788                             String(), 0, 0);
789     
790     // The frame's onload handler may have removed it from the document.
791     if (!childFrame->tree()->parent())
792         return 0;
793     
794     delete data;
795     
796     return childFrame.get();
797 */
798     notImplemented();
799     return 0;
800 }
801
802 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
803 {
804     notImplemented();
805     return ObjectContentType();
806 }
807
808 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
809 {
810     notImplemented();
811     return 0;
812 }
813
814 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
815 {
816     notImplemented();
817     return;
818 }
819
820 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
821                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
822 {
823     notImplemented();
824     return 0;
825 }
826
827 String FrameLoaderClientWx::overrideMediaType() const
828 {
829     notImplemented();
830     return String();
831 }
832
833 void FrameLoaderClientWx::windowObjectCleared()
834 {
835     notImplemented();
836 }
837
838 void FrameLoaderClientWx::didPerformFirstNavigation() const
839 {
840     notImplemented();
841 }
842
843 void FrameLoaderClientWx::registerForIconNotification(bool listen)
844 {
845     notImplemented();
846 }
847
848 void FrameLoaderClientWx::savePlatformDataToCachedPage(CachedPage*)
849
850     notImplemented();
851 }
852
853 void FrameLoaderClientWx::transitionToCommittedFromCachedPage(CachedPage*)
854
855     notImplemented();
856 }
857
858 void FrameLoaderClientWx::transitionToCommittedForNewPage()
859
860     notImplemented();
861 }
862
863 }