Build fix for Wx: Finish de-RefCount-ing FrameLoaderClientWx
[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     : 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     if (m_frame && m_frame->loader())
480         m_frame->loader()->detachChildren();
481 }
482
483
484 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
485 {
486     notImplemented();
487 }
488
489
490 String FrameLoaderClientWx::userAgent(const KURL&)
491 {
492     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
493     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
494 }
495
496 void FrameLoaderClientWx::dispatchDidReceiveIcon()
497 {
498     notImplemented();
499 }
500
501 void FrameLoaderClientWx::frameLoaderDestroyed()
502 {
503     m_frame = 0;
504     delete this;
505 }
506
507 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
508 {
509     notImplemented();
510     return true;
511 }
512
513 void FrameLoaderClientWx::partClearedInBegin()
514 {
515     notImplemented();
516 }
517
518 void FrameLoaderClientWx::updateGlobalHistory()
519 {
520     notImplemented();
521 }
522
523 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
524 {
525     notImplemented();
526     return true;
527 }
528
529 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
530 {
531     notImplemented();
532 }
533
534 bool FrameLoaderClientWx::canCachePage() const
535 {
536     return false;
537 }
538
539 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
540 {
541     notImplemented();
542 }
543
544 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
545 {
546     if (!m_frame)
547         return;
548     FrameLoader* fl = loader->frameLoader();
549     fl->setEncoding(m_response.textEncodingName(), false);
550     fl->addData(data, length);
551 }
552
553 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
554 {
555     notImplemented();
556     return ResourceError();
557 }
558
559 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
560 {
561     notImplemented();
562     return ResourceError();
563 }
564
565 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
566 {
567     notImplemented();
568     return ResourceError();
569 }
570
571 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
572 {
573     notImplemented();
574     return ResourceError();
575 }
576
577 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
578 {
579     notImplemented();
580     return ResourceError();
581 }
582
583 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
584 {
585     notImplemented();
586     return ResourceError();
587 }
588
589 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
590 {
591     notImplemented();
592     return false;
593 }
594
595 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
596 {
597     return DocumentLoader::create(request, substituteData);
598 }
599
600 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
601 {
602     notImplemented();
603 }
604
605 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
606 {
607     notImplemented();   
608 }
609
610 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
611 {
612     notImplemented();
613 }
614
615 bool FrameLoaderClientWx::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
616 {
617     notImplemented();
618     return false;
619 }
620
621 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
622 {
623     notImplemented();
624 }
625
626 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
627 {
628     notImplemented();
629 }
630
631 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
632 {
633     notImplemented();
634     m_response = response;
635     m_firstData = true;
636 }
637
638 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
639 {
640     notImplemented();
641 }
642
643 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
644 {
645     notImplemented();
646 }
647
648 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
649 {
650     notImplemented();
651 }
652
653 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
654 {
655     notImplemented();
656     return false;
657 }
658
659 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
660 {
661     notImplemented();
662 }
663
664 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
665 {
666     notImplemented();
667 }
668
669 Frame* FrameLoaderClientWx::dispatchCreatePage()
670 {
671     notImplemented();
672     return false;
673 }
674
675 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
676 {
677     if (!m_frame)
678         return;
679     
680     notImplemented();
681     (m_frame->loader()->*function)(PolicyUse);
682 }
683
684 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&)
685 {
686     if (!m_frame)
687         return;
688
689     notImplemented();
690     (m_frame->loader()->*function)(PolicyUse);
691 }
692
693 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request, PassRefPtr<FormState>)
694 {
695     if (!m_frame)
696         return;
697         
698     if (m_webView) {
699         wxWebViewBeforeLoadEvent wkEvent(m_webView);
700         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
701         wkEvent.SetURL(request.url().string());
702         
703         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
704         if (wkEvent.IsCancelled())
705             (m_frame->loader()->*function)(PolicyIgnore);
706         else
707             (m_frame->loader()->*function)(PolicyUse);
708         
709     }
710 }
711
712 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
713 {
714     notImplemented();
715 }
716
717 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
718 {
719     notImplemented();
720 }
721
722 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
723                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
724 {
725 /*
726     FIXME: Temporarily disabling code for loading subframes. While most 
727     (i)frames load and are destroyed properly, the iframe created by
728     google.com in its new homepage does not get destroyed when 
729     document()->detach() is called, as other (i)frames do. It is destroyed on 
730     app shutdown, but until that point, this 'in limbo' frame will do things
731     like steal keyboard focus and crash when clicked on. (On some platforms,
732     it is actually a visible object, even though it's not in a valid state.)
733     
734     Since just about every user is probably going to test against Google at 
735     some point, I'm disabling this functionality until I have time to track down
736     why it is not being destroyed.
737 */
738
739 /*
740     wxWindow* parent = m_webView;
741
742     WebViewFrameData* data = new WebViewFrameData();
743     data->name = name;
744     data->ownerElement = ownerElement;
745     data->url = url;
746     data->referrer = referrer;
747     data->marginWidth = marginWidth;
748     data->marginHeight = marginHeight;
749
750     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
751
752     RefPtr<Frame> childFrame = newWin->m_impl->frame;
753
754     // FIXME: All of the below should probably be moved over into WebCore
755     childFrame->tree()->setName(name);
756     m_frame->tree()->appendChild(childFrame);
757     // ### set override encoding if we have one
758
759     FrameLoadType loadType = m_frame->loader()->loadType();
760     FrameLoadType childLoadType = FrameLoadTypeInternal;
761
762     childFrame->loader()->load(url, referrer, childLoadType,
763                             String(), 0, 0);
764     
765     // The frame's onload handler may have removed it from the document.
766     if (!childFrame->tree()->parent())
767         return 0;
768     
769     delete data;
770     
771     return childFrame.get();
772 */
773     notImplemented();
774     return 0;
775 }
776
777 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
778 {
779     notImplemented();
780     return ObjectContentType();
781 }
782
783 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
784 {
785     notImplemented();
786     return 0;
787 }
788
789 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
790 {
791     notImplemented();
792     return;
793 }
794
795 ResourceError FrameLoaderClientWx::pluginWillHandleLoadError(const ResourceResponse&)
796 {
797     notImplemented();
798     return ResourceError();
799 }
800
801 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
802                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
803 {
804     notImplemented();
805     return 0;
806 }
807
808 String FrameLoaderClientWx::overrideMediaType() const
809 {
810     notImplemented();
811     return String();
812 }
813
814 void FrameLoaderClientWx::windowObjectCleared()
815 {
816     notImplemented();
817 }
818
819 void FrameLoaderClientWx::didPerformFirstNavigation() const
820 {
821     notImplemented();
822 }
823
824 void FrameLoaderClientWx::registerForIconNotification(bool listen)
825 {
826     notImplemented();
827 }
828
829 void FrameLoaderClientWx::savePlatformDataToCachedFrame(CachedFrame*)
830
831     notImplemented();
832 }
833
834 void FrameLoaderClientWx::transitionToCommittedFromCachedFrame(CachedFrame*)
835
836     notImplemented();
837 }
838
839 void FrameLoaderClientWx::transitionToCommittedForNewPage()
840
841     ASSERT(m_frame);
842     ASSERT(m_webView);
843     
844     Page* page = m_frame->page();
845     ASSERT(page);
846
847     bool isMainFrame = m_frame == page->mainFrame();
848
849     m_frame->setView(0);
850
851     FrameView* frameView;
852     if (isMainFrame)
853         frameView = new FrameView(m_frame, IntRect(m_webView->GetRect()).size());
854     else
855         frameView = new FrameView(m_frame);
856
857     ASSERT(frameView);
858     m_frame->setView(frameView);
859     frameView->deref(); // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
860
861     frameView->setPlatformWidget(m_webView);
862
863     if (m_frame->ownerRenderer())
864         m_frame->ownerRenderer()->setWidget(frameView);
865
866     if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
867         m_frame->view()->setScrollbarModes(owner->scrollingMode(), owner->scrollingMode());
868 }
869
870 }