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