Reviewed by Kevin Ollivier.
[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 "HTMLFrameOwnerElement.h"
38 #include "NotImplemented.h"
39 #include "Page.h"
40 #include "PlatformString.h"
41 #include "ProgressTracker.h"
42 #include "RenderPart.h"
43 #include "ResourceError.h"
44 #include "ResourceResponse.h"
45
46 #include <stdio.h>
47
48 #include "WebView.h"
49 #include "WebViewPrivate.h"
50
51 namespace WebCore {
52
53 inline int wxNavTypeFromWebNavType(NavigationType type){
54     if (type == NavigationTypeLinkClicked)
55         return wxWEBVIEW_NAV_LINK_CLICKED;
56     
57     if (type == NavigationTypeFormSubmitted)
58         return wxWEBVIEW_NAV_FORM_SUBMITTED;
59         
60     if (type == NavigationTypeBackForward)
61         return wxWEBVIEW_NAV_BACK_NEXT;
62         
63     if (type == NavigationTypeReload)
64         return wxWEBVIEW_NAV_RELOAD;
65         
66     if (type == NavigationTypeFormResubmitted)
67         return wxWEBVIEW_NAV_FORM_RESUBMITTED;
68         
69     return wxWEBVIEW_NAV_OTHER;
70 }
71
72 FrameLoaderClientWx::FrameLoaderClientWx()
73     : RefCounted<FrameLoaderClientWx>(0)
74     , m_frame(0)
75 {
76 }
77
78
79 FrameLoaderClientWx::~FrameLoaderClientWx()
80 {
81 }
82
83 void FrameLoaderClientWx::setFrame(Frame *frame)
84 {
85     m_frame = frame;
86 }
87
88 void FrameLoaderClientWx::setWebView(wxWebView *webview)
89 {
90     m_webView = webview;
91 }
92
93 void FrameLoaderClientWx::detachFrameLoader()
94 {
95     m_frame = 0;
96 }
97
98 void FrameLoaderClientWx::ref()
99 {
100     RefCounted<FrameLoaderClientWx>::ref();
101 }
102
103 void FrameLoaderClientWx::deref()
104 {
105     RefCounted<FrameLoaderClientWx>::deref();
106 }
107
108 bool FrameLoaderClientWx::hasWebView() const
109 {
110     notImplemented();
111     return true;
112 }
113
114
115 bool FrameLoaderClientWx::hasFrameView() const
116 {
117     notImplemented();
118     return true;
119 }
120
121
122 bool FrameLoaderClientWx::hasBackForwardList() const
123 {
124     notImplemented();
125     return true;
126 }
127
128
129 void FrameLoaderClientWx::resetBackForwardList()
130 {
131     notImplemented();
132 }
133
134
135 bool FrameLoaderClientWx::provisionalItemIsTarget() const
136 {
137     notImplemented();
138     return false;
139 }
140
141 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
142 {
143     notImplemented();
144 }
145
146
147 void FrameLoaderClientWx::forceLayout()
148 {
149     notImplemented();
150 }
151
152
153 void FrameLoaderClientWx::forceLayoutForNonHTML()
154 {
155     notImplemented();
156 }
157
158
159 void FrameLoaderClientWx::updateHistoryForCommit()
160 {
161     notImplemented();
162 }
163
164
165 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
166 {
167     notImplemented();
168 }
169
170
171 void FrameLoaderClientWx::updateHistoryForReload()
172 {
173     notImplemented();
174 }
175
176
177 void FrameLoaderClientWx::updateHistoryForStandardLoad()
178 {
179     notImplemented();
180 }
181
182
183 void FrameLoaderClientWx::updateHistoryForInternalLoad()
184 {
185     notImplemented();
186 }
187
188
189 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
190 {
191     notImplemented();
192 }
193
194
195 void FrameLoaderClientWx::setCopiesOnScroll()
196 {
197     // apparently mac specific
198     notImplemented();
199 }
200
201
202 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
203 {
204     notImplemented();
205     return 0;
206 }
207
208
209 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
210 {
211     notImplemented();
212 }
213
214
215 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
216 {
217     notImplemented();
218 }
219
220
221 void FrameLoaderClientWx::willCloseDocument()
222 {
223     notImplemented();
224 }
225
226
227 void FrameLoaderClientWx::detachedFromParent1()
228 {
229     notImplemented();
230 }
231
232
233 void FrameLoaderClientWx::detachedFromParent2()
234 {
235     notImplemented();
236 }
237
238
239 void FrameLoaderClientWx::detachedFromParent3()
240 {
241     notImplemented();
242 }
243
244
245 void FrameLoaderClientWx::detachedFromParent4()
246 {
247     notImplemented();
248 }
249
250
251 void FrameLoaderClientWx::loadedFromCachedPage()
252 {
253     notImplemented();
254 }
255
256
257 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
258 {
259     if (m_webView) {
260         wxWebViewLoadEvent wkEvent(m_webView);
261         wkEvent.SetState(wxWEBVIEW_LOAD_ONLOAD_HANDLED);
262         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
263         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
264     }
265 }
266
267
268 void FrameLoaderClientWx::dispatchDidReceiveServerRedirectForProvisionalLoad()
269 {
270     notImplemented();
271 }
272
273
274 void FrameLoaderClientWx::dispatchDidCancelClientRedirect()
275 {
276     notImplemented();
277 }
278
279
280 void FrameLoaderClientWx::dispatchWillPerformClientRedirect(const KURL&,
281                                                             double interval,
282                                                             double fireDate)
283 {
284     notImplemented();
285 }
286
287
288 void FrameLoaderClientWx::dispatchDidChangeLocationWithinPage()
289 {
290     notImplemented();
291 }
292
293
294 void FrameLoaderClientWx::dispatchWillClose()
295 {
296     notImplemented();
297 }
298
299
300 void FrameLoaderClientWx::dispatchDidStartProvisionalLoad()
301 {
302     if (m_webView) {
303         wxWebViewLoadEvent wkEvent(m_webView);
304         wkEvent.SetState(wxWEBVIEW_LOAD_NEGOTIATING);
305         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().string());
306         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
307     }
308 }
309
310
311 void FrameLoaderClientWx::dispatchDidReceiveTitle(const String& title)
312 {
313     if (m_webView)
314         m_webView->SetPageTitle(title);
315 }
316
317
318 void FrameLoaderClientWx::dispatchDidCommitLoad()
319 {
320     if (m_webView) {
321         wxWebViewLoadEvent wkEvent(m_webView);
322         wkEvent.SetState(wxWEBVIEW_LOAD_TRANSFERRING);
323         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
324         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
325     }
326 }
327
328 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
329 {
330     if (m_webView) {
331         wxWebViewLoadEvent wkEvent(m_webView);
332         wkEvent.SetState(wxWEBVIEW_LOAD_DOC_COMPLETED);
333         wkEvent.SetURL(m_frame->loader()->url().string());
334         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
335     }
336 }
337
338 void FrameLoaderClientWx::dispatchDidFinishLoad()
339 {
340     notImplemented();
341 }
342
343
344 void FrameLoaderClientWx::dispatchDidFirstLayout()
345 {
346     notImplemented();
347 }
348
349
350 void FrameLoaderClientWx::dispatchShow()
351 {
352     notImplemented();
353 }
354
355
356 void FrameLoaderClientWx::cancelPolicyCheck()
357 {
358     notImplemented();
359 }
360
361
362 void FrameLoaderClientWx::dispatchWillSubmitForm(FramePolicyFunction function,
363                                                  PassRefPtr<FormState>)
364 {
365     // FIXME: Send an event to allow for alerts and cancellation
366     if (!m_frame)
367         return;
368     (m_frame->loader()->*function)(PolicyUse);
369 }
370
371
372 void FrameLoaderClientWx::dispatchDidLoadMainResource(DocumentLoader*)
373 {
374     notImplemented();
375 }
376
377
378 void FrameLoaderClientWx::revertToProvisionalState(DocumentLoader*)
379 {
380     notImplemented();
381 }
382
383 void FrameLoaderClientWx::postProgressStartedNotification()
384 {
385     notImplemented();
386 }
387
388 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
389 {
390     notImplemented();
391 }
392
393 void FrameLoaderClientWx::postProgressFinishedNotification()
394 {
395     if (m_webView) {
396         wxWebViewLoadEvent wkEvent(m_webView);
397         wkEvent.SetState(wxWEBVIEW_LOAD_DL_COMPLETED);
398         wkEvent.SetURL(m_frame->loader()->url().string());
399         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
400     }
401 }
402
403 void FrameLoaderClientWx::progressStarted()
404 {
405     notImplemented();
406 }
407
408
409 void FrameLoaderClientWx::progressCompleted()
410 {
411     notImplemented();
412 }
413
414
415 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
416 {
417     notImplemented();
418     // this is only interesting once we provide an external API for the DOM
419 }
420
421
422 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
423 {
424     notImplemented();
425 }
426
427
428 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
429 {
430     setTitle(l->title(), l->url());
431 }
432
433
434 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
435 {
436     notImplemented();
437 }
438
439
440 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
441 {
442     notImplemented();
443     return true;
444 }
445
446
447 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
448 {
449     notImplemented();
450     return false;
451 }
452
453
454 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
455 {
456     notImplemented();
457     return String();
458 }
459
460
461 void FrameLoaderClientWx::frameLoadCompleted()
462 {
463     notImplemented();
464 }
465
466 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
467 {
468     notImplemented();
469 }
470
471 void FrameLoaderClientWx::restoreViewState()
472 {
473     notImplemented();
474 }
475         
476 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
477 {
478     notImplemented();
479 }
480
481
482 void FrameLoaderClientWx::provisionalLoadStarted()
483 {
484     notImplemented();
485 }
486
487
488 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
489 {
490     notImplemented();
491     return false;
492 }
493
494
495 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
496 {
497     notImplemented();
498 }
499
500
501 void FrameLoaderClientWx::didFinishLoad()
502 {
503     notImplemented();
504 }
505
506
507 void FrameLoaderClientWx::prepareForDataSourceReplacement()
508 {
509     if (m_frame && m_frame->loader())
510         m_frame->loader()->detachChildren();
511 }
512
513
514 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
515 {
516     notImplemented();
517 }
518
519
520 String FrameLoaderClientWx::userAgent(const KURL&)
521 {
522     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
523     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
524 }
525
526 void FrameLoaderClientWx::dispatchDidReceiveIcon()
527 {
528     notImplemented();
529 }
530
531 void FrameLoaderClientWx::frameLoaderDestroyed()
532 {
533     m_frame = 0;
534     delete this;
535 }
536
537 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
538 {
539     notImplemented();
540     return true;
541 }
542
543 void FrameLoaderClientWx::partClearedInBegin()
544 {
545     notImplemented();
546 }
547
548 void FrameLoaderClientWx::updateGlobalHistory(const WebCore::KURL&)
549 {
550     notImplemented();
551 }
552
553 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
554 {
555     notImplemented();
556     return true;
557 }
558
559 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
560 {
561     notImplemented();
562 }
563
564 bool FrameLoaderClientWx::canCachePage() const
565 {
566     return false;
567 }
568
569 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
570 {
571     notImplemented();
572 }
573
574 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
575 {
576     if (!m_frame)
577         return;
578     FrameLoader* fl = loader->frameLoader();
579     fl->setEncoding(m_response.textEncodingName(), false);
580     fl->addData(data, length);
581 }
582
583 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
584 {
585     notImplemented();
586     return ResourceError();
587 }
588
589 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
590 {
591     notImplemented();
592     return ResourceError();
593 }
594
595 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
596 {
597     notImplemented();
598     return ResourceError();
599 }
600
601 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
602 {
603     notImplemented();
604     return ResourceError();
605 }
606
607 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
608 {
609     notImplemented();
610     return ResourceError();
611 }
612
613 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
614 {
615     notImplemented();
616     return ResourceError();
617 }
618
619 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
620 {
621     notImplemented();
622     return false;
623 }
624
625 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
626 {
627     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
628     return loader.release();
629 }
630
631 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
632 {
633     notImplemented();
634 }
635
636 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
637 {
638     notImplemented();   
639 }
640
641 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
642 {
643     notImplemented();
644 }
645
646 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
647 {
648     notImplemented();
649 }
650
651 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
652 {
653     notImplemented();
654 }
655
656 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
657 {
658     notImplemented();
659     m_response = response;
660     m_firstData = true;
661 }
662
663 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
664 {
665     notImplemented();
666 }
667
668 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
669 {
670     notImplemented();
671 }
672
673 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
674 {
675     notImplemented();
676 }
677
678 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
679 {
680     notImplemented();
681     return false;
682 }
683
684 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
685 {
686     notImplemented();
687 }
688
689 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
690 {
691     notImplemented();
692 }
693
694 Frame* FrameLoaderClientWx::dispatchCreatePage()
695 {
696     notImplemented();
697     return false;
698 }
699
700 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
701 {
702     if (!m_frame)
703         return;
704     
705     notImplemented();
706     (m_frame->loader()->*function)(PolicyUse);
707 }
708
709 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
710 {
711     if (!m_frame)
712         return;
713
714     notImplemented();
715     (m_frame->loader()->*function)(PolicyUse);
716 }
717
718 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
719 {
720     if (!m_frame)
721         return;
722         
723     if (m_webView) {
724         wxWebViewBeforeLoadEvent wkEvent(m_webView);
725         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
726         wkEvent.SetURL(request.url().string());
727         
728         m_webView->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_webView;
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     ASSERT(m_frame);
861     ASSERT(m_webView);
862     
863     Page* page = m_frame->page();
864     ASSERT(page);
865
866     bool isMainFrame = m_frame == page->mainFrame();
867
868     m_frame->setView(0);
869
870     FrameView* frameView;
871     if (isMainFrame) {
872         frameView = new FrameView(m_frame, IntRect(m_webView->GetRect()).size());
873     } else
874         frameView = new FrameView(m_frame);
875
876     ASSERT(frameView);
877     m_frame->setView(frameView);
878     frameView->deref(); // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
879
880     frameView->setNativeWindow(m_webView);
881
882     if (m_frame->ownerRenderer())
883         m_frame->ownerRenderer()->setWidget(frameView);
884
885     if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
886         m_frame->view()->setScrollbarsMode(owner->scrollingMode());
887 }
888
889 }