Remove an unneeded argument from FrameLoaderClient::download
[WebKit-https.git] / Source / WebKit / gtk / WebCoreSupport / FrameLoaderClientGtk.cpp
1 /*
2  *  Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>
3  *  Copyright (C) 2007, 2008, 2009 Holger Hans Peter Freyther
4  *  Copyright (C) 2007 Christian Dywan <christian@twotoasts.de>
5  *  Copyright (C) 2008, 2009 Collabora Ltd.  All rights reserved.
6  *  Copyright (C) 2009, 2010 Gustavo Noronha Silva <gns@gnome.org>
7  *  Copyright (C) Research In Motion Limited 2009. All rights reserved.
8  *  Copyright (C) 2010 Igalia S.L.
9  *  Copyright (C) 2011 Apple Inc. All rights reserved.
10  *
11  *  This library is free software; you can redistribute it and/or
12  *  modify it under the terms of the GNU Lesser General Public
13  *  License as published by the Free Software Foundation; either
14  *  version 2 of the License, or (at your option) any later version.
15  *
16  *  This library is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  *  Lesser General Public License for more details.
20  *
21  *  You should have received a copy of the GNU Lesser General Public
22  *  License along with this library; if not, write to the Free Software
23  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
24  */
25
26 #include "config.h"
27 #include "FrameLoaderClientGtk.h"
28
29 #include "AXObjectCache.h"
30 #include "AccessibilityObject.h"
31 #include "ArchiveResource.h"
32 #include "CachedFrame.h"
33 #include "Color.h"
34 #include "DOMObjectCache.h"
35 #include "DocumentLoader.h"
36 #include "DocumentLoaderGtk.h"
37 #include "ErrorsGtk.h"
38 #include "FormState.h"
39 #include "FrameLoader.h"
40 #include "FrameNetworkingContextGtk.h"
41 #include "FrameTree.h"
42 #include "FrameView.h"
43 #include "GOwnPtr.h"
44 #include "GRefPtr.h"
45 #include "GtkPluginWidget.h"
46 #include "HTMLAppletElement.h"
47 #include "HTMLFormElement.h"
48 #include "HTMLFrameElement.h"
49 #include "HTMLFrameOwnerElement.h"
50 #include "HTMLNames.h"
51 #include "HTMLPlugInElement.h"
52 #include "JSDOMBinding.h"
53 #include "JSDOMWindow.h"
54 #include "Language.h"
55 #include "MIMETypeRegistry.h"
56 #include "MouseEvent.h"
57 #include "NotImplemented.h"
58 #include "Page.h"
59 #include "PluginDatabase.h"
60 #include "ProgressTracker.h"
61 #include "RenderPart.h"
62 #include "RenderView.h"
63 #include "ResourceHandle.h"
64 #include "ResourceLoader.h"
65 #include "ResourceRequest.h"
66 #include "ScriptController.h"
67 #include "Settings.h"
68 #include "webkiterror.h"
69 #include "webkitglobals.h"
70 #include "webkitglobalsprivate.h"
71 #include "webkiticondatabase.h"
72 #include "webkitnetworkrequest.h"
73 #include "webkitnetworkrequestprivate.h"
74 #include "webkitnetworkresponse.h"
75 #include "webkitnetworkresponseprivate.h"
76 #include "webkitviewportattributes.h"
77 #include "webkitviewportattributesprivate.h"
78 #include "webkitwebdatasourceprivate.h"
79 #include "webkitwebframe.h"
80 #include "webkitwebframeprivate.h"
81 #include "webkitwebnavigationaction.h"
82 #include "webkitwebnavigationactionprivate.h"
83 #include "webkitwebpolicydecision.h"
84 #include "webkitwebpolicydecisionprivate.h"
85 #include "webkitwebresource.h"
86 #include "webkitwebresourceprivate.h"
87 #include "webkitwebsettingsprivate.h"
88 #include "webkitwebview.h"
89 #include "webkitwebviewprivate.h"
90 #include <JavaScriptCore/APICast.h>
91 #include <gio/gio.h>
92 #include <glib.h>
93 #include <glib/gi18n-lib.h>
94 #include <stdio.h>
95 #include <wtf/text/CString.h>
96 #include <wtf/text/StringConcatenate.h>
97
98 using namespace WebCore;
99
100 namespace WebKit {
101
102 FrameLoaderClient::FrameLoaderClient(WebKitWebFrame* frame)
103     : m_frame(frame)
104     , m_policyDecision(0)
105     , m_loadingErrorPage(false)
106     , m_pluginView(0)
107     , m_hasSentResponseToPlugin(false)
108     , m_hasRepresentation(false)
109 {
110     ASSERT(m_frame);
111 }
112
113 FrameLoaderClient::~FrameLoaderClient()
114 {
115     if (m_policyDecision)
116         g_object_unref(m_policyDecision);
117 }
118
119
120 String FrameLoaderClient::userAgent(const KURL& url)
121 {
122     WebKitWebSettings* settings = webkit_web_view_get_settings(getViewFromFrame(m_frame));
123     GOwnPtr<gchar> userAgentString(webkitWebSettingsUserAgentForURI(settings, url.string().utf8().data()));
124     return String::fromUTF8(userAgentString.get());
125 }
126
127 static void notifyAccessibilityStatus(WebKitWebFrame* frame, WebKitLoadStatus loadStatus)
128 {
129     if (loadStatus != WEBKIT_LOAD_PROVISIONAL
130         && loadStatus != WEBKIT_LOAD_FAILED
131         && loadStatus != WEBKIT_LOAD_FINISHED)
132         return;
133
134     WebKitWebFramePrivate* priv = frame->priv;
135     if (!priv->coreFrame || !priv->coreFrame->document())
136         return;
137
138     RenderView* contentRenderer = priv->coreFrame->contentRenderer();
139     if (!contentRenderer)
140         return;
141
142     AXObjectCache* axObjectCache = priv->coreFrame->document()->axObjectCache();
143     if (!axObjectCache)
144         return;
145
146     AccessibilityObject* coreAxObject = axObjectCache->getOrCreate(contentRenderer);
147     if (!coreAxObject)
148         return;
149
150     AtkObject* axObject = coreAxObject->wrapper();
151     if (!axObject || !ATK_IS_DOCUMENT(axObject))
152         return;
153
154     switch (loadStatus) {
155     case WEBKIT_LOAD_PROVISIONAL:
156         g_signal_emit_by_name(axObject, "state-change", "busy", true);
157         if (core(frame)->loader()->loadType() == FrameLoadTypeReload)
158             g_signal_emit_by_name(axObject, "reload");
159         break;
160     case WEBKIT_LOAD_FAILED:
161         g_signal_emit_by_name(axObject, "load-stopped");
162         g_signal_emit_by_name(axObject, "state-change", "busy", false);
163         break;
164     case WEBKIT_LOAD_FINISHED:
165         g_signal_emit_by_name(axObject, "load-complete");
166         g_signal_emit_by_name(axObject, "state-change", "busy", false);
167     default:
168         break;
169     }
170 }
171
172 static void notifyStatus(WebKitWebFrame* frame, WebKitLoadStatus loadStatus)
173 {
174     frame->priv->loadStatus = loadStatus;
175     g_object_notify(G_OBJECT(frame), "load-status");
176
177     WebKitWebView* webView = getViewFromFrame(frame);
178     if (frame == webkit_web_view_get_main_frame(webView)) {
179         webView->priv->loadStatus = loadStatus;
180         g_object_notify(G_OBJECT(webView), "load-status");
181
182         if (AXObjectCache::accessibilityEnabled())
183             notifyAccessibilityStatus(frame, loadStatus);
184     }
185 }
186
187 static void loadDone(WebKitWebFrame* frame, bool didSucceed)
188 {
189     // FIXME: load-done is deprecated. Please remove when signal's been removed.
190     g_signal_emit_by_name(frame, "load-done", didSucceed);
191     notifyStatus(frame, WEBKIT_LOAD_FINISHED);
192 }
193
194 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClient::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
195 {
196     RefPtr<WebKit::DocumentLoader> loader = WebKit::DocumentLoader::create(request, substituteData);
197
198     GRefPtr<WebKitWebDataSource> webDataSource(adoptGRef(kitNew(loader.get())));
199     loader->setDataSource(webDataSource.get());
200
201     return loader.release();
202 }
203
204 void FrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction policyFunction, PassRefPtr<FormState>)
205 {
206     // FIXME: This is surely too simple
207     ASSERT(policyFunction);
208     if (!policyFunction)
209         return;
210     (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyUse);
211 }
212
213 void FrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
214 {
215     if (!m_pluginView) {
216         ASSERT(loader->frame());
217         loader->commitData(data, length);
218
219         Frame* coreFrame = loader->frame();
220         if (coreFrame && coreFrame->document()->isMediaDocument())
221             loader->cancelMainResourceLoad(coreFrame->loader()->client()->pluginWillHandleLoadError(loader->response()));
222     }
223
224     if (m_pluginView) {
225         if (!m_hasSentResponseToPlugin) {
226             m_pluginView->didReceiveResponse(loader->response());
227             m_hasSentResponseToPlugin = true;
228         }
229
230         // FIXME: We may want to investigate refactoring our plugin loading
231         // code to be similar to mac's.
232         // Also, see http://trac.webkit.org/changeset/24118.
233         if (!m_pluginView)
234             return;
235
236         m_pluginView->didReceiveData(data, length);
237     }
238 }
239
240 bool
241 FrameLoaderClient::shouldUseCredentialStorage(WebCore::DocumentLoader*, unsigned long  identifier)
242 {
243     notImplemented();
244     return false;
245 }
246
247 void FrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
248 {
249     notImplemented();
250 }
251
252 void FrameLoaderClient::dispatchDidCancelAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
253 {
254     notImplemented();
255 }
256
257 // We convert this to string because it's easier to use strings as
258 // keys in a GHashTable.
259 static char* toString(unsigned long identifier)
260 {
261     return g_strdup_printf("%ld", identifier);
262 }
263
264 void FrameLoaderClient::dispatchWillSendRequest(WebCore::DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse)
265 {
266     GRefPtr<WebKitNetworkResponse> networkResponse(0);
267
268     // We are adding one more resource to the load, or maybe we are
269     // just redirecting a load.
270     if (redirectResponse.isNull())
271         static_cast<WebKit::DocumentLoader*>(loader)->increaseLoadCount(identifier);
272     else
273         networkResponse = adoptGRef(kitNew(redirectResponse));
274
275     WebKitWebView* webView = getViewFromFrame(m_frame);
276     GOwnPtr<gchar> identifierString(toString(identifier));
277     WebKitWebResource* webResource = webkit_web_view_get_resource(webView, identifierString.get());
278     GRefPtr<WebKitNetworkRequest> networkRequest(adoptGRef(kitNew(request)));
279
280     if (!redirectResponse.isNull()) {
281         // This is a redirect, so we need to update the WebResource's knowledge
282         // of the URI.
283         g_free(webResource->priv->uri);
284         webResource->priv->uri = g_strdup(request.url().string().utf8().data());
285     }
286     
287     g_signal_emit_by_name(webView, "resource-request-starting", m_frame, webResource, networkRequest.get(), networkResponse.get());
288
289     // Feed any changes back into the ResourceRequest object.
290     SoupMessage* message = webkit_network_request_get_message(networkRequest.get());
291     if (!message) {
292         request.setURL(KURL(KURL(), String::fromUTF8(webkit_network_request_get_uri(networkRequest.get()))));
293         return;
294     }
295
296     request.updateFromSoupMessage(message);
297 }
298
299 void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader* loader, const ResourceRequest& request)
300 {
301     GOwnPtr<gchar> identifierString(toString(identifier));
302
303     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(g_object_new(WEBKIT_TYPE_WEB_RESOURCE, "uri", request.url().string().utf8().data(), 0));
304
305     if (loader == loader->frameLoader()->provisionalDocumentLoader()
306         && loader->frameLoader()->isLoadingMainFrame()) {
307         webkit_web_view_add_main_resource(getViewFromFrame(m_frame), identifierString.get(), webResource);
308         return;
309     }
310
311     webkit_web_view_add_resource(getViewFromFrame(m_frame), identifierString.get(), webResource);
312 }
313
314 void FrameLoaderClient::postProgressStartedNotification()
315 {
316     WebKitWebView* webView = getViewFromFrame(m_frame);
317     g_signal_emit_by_name(webView, "load-started", m_frame);
318
319     g_object_notify(G_OBJECT(webView), "progress");
320 }
321
322 void FrameLoaderClient::postProgressEstimateChangedNotification()
323 {
324     WebKitWebView* webView = getViewFromFrame(m_frame);
325     Page* corePage = core(webView);
326
327     g_signal_emit_by_name(webView, "load-progress-changed", lround(corePage->progress()->estimatedProgress()*100));
328
329     g_object_notify(G_OBJECT(webView), "progress");
330 }
331
332 void FrameLoaderClient::postProgressFinishedNotification()
333 {
334     WebKitWebView* webView = getViewFromFrame(m_frame);
335     WebKitWebViewPrivate* privateData = webView->priv;
336
337     // We can get a stopLoad() from dispose when the object is being
338     // destroyed, don't emit the signal in that case.
339     if (!privateData->disposing)
340         g_signal_emit_by_name(webView, "load-finished", m_frame);
341 }
342
343 void FrameLoaderClient::frameLoaderDestroyed()
344 {
345     webkit_web_frame_core_frame_gone(m_frame);
346     g_object_unref(m_frame);
347     m_frame = 0;
348     delete this;
349 }
350
351 void FrameLoaderClient::dispatchDidReceiveResponse(WebCore::DocumentLoader* loader, unsigned long, const ResourceResponse& response)
352 {
353     // Update our knowledge of request soup flags - some are only set
354     // after the request is done.
355     loader->request().setSoupMessageFlags(response.soupMessageFlags());
356
357     m_response = response;
358 }
359
360 void FrameLoaderClient::dispatchDecidePolicyForResponse(FramePolicyFunction policyFunction, const ResourceResponse& response, const ResourceRequest& resourceRequest)
361 {
362     ASSERT(policyFunction);
363     if (!policyFunction)
364         return;
365
366     if (resourceRequest.isNull()) {
367         (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyIgnore);
368         return;
369     }
370
371     WebKitWebView* page = getViewFromFrame(m_frame);
372     GRefPtr<WebKitNetworkRequest> request(adoptGRef(kitNew(resourceRequest)));
373
374     WebKitWebPolicyDecision* policyDecision = webkit_web_policy_decision_new(m_frame, policyFunction);
375     if (m_policyDecision)
376         g_object_unref(m_policyDecision);
377     m_policyDecision = policyDecision;
378
379     String mimeType = response.mimeType();
380
381     gboolean isHandled = false;
382     g_signal_emit_by_name(page, "mime-type-policy-decision-requested", m_frame, request.get(), mimeType.utf8().data(), policyDecision, &isHandled);
383
384     if (isHandled)
385         return;
386
387     GRefPtr<WebKitNetworkResponse> networkResponse(adoptGRef(webkit_web_frame_get_network_response(m_frame)));
388     if (networkResponse) {
389         ResourceResponse response = core(networkResponse.get());
390         if (response.isAttachment()) {
391             webkit_web_policy_decision_download(policyDecision);
392             return;
393         }
394     }
395
396     if (canShowMIMEType(mimeType))
397         webkit_web_policy_decision_use(policyDecision);
398     else
399         webkit_web_policy_decision_ignore(policyDecision);
400 }
401
402 static WebKitWebNavigationAction* getNavigationAction(const NavigationAction& action, const char* targetFrame)
403 {
404     gint button = -1;
405
406     const Event* event = action.event();
407     if (event && event->isMouseEvent()) {
408         const MouseEvent* mouseEvent = static_cast<const MouseEvent*>(event);
409         // DOM button values are 0, 1 and 2 for left, middle and right buttons.
410         // GTK+ uses 1, 2 and 3, so let's add 1 to remain consistent.
411         button = mouseEvent->button() + 1;
412     }
413
414     gint modifierFlags = 0;
415     UIEventWithKeyState* keyStateEvent = findEventWithKeyState(const_cast<Event*>(event));
416     if (keyStateEvent) {
417         if (keyStateEvent->shiftKey())
418             modifierFlags |= GDK_SHIFT_MASK;
419         if (keyStateEvent->ctrlKey())
420             modifierFlags |= GDK_CONTROL_MASK;
421         if (keyStateEvent->altKey())
422             modifierFlags |= GDK_MOD1_MASK;
423         if (keyStateEvent->metaKey())
424             modifierFlags |= GDK_MOD2_MASK;
425     }
426
427     return WEBKIT_WEB_NAVIGATION_ACTION(g_object_new(WEBKIT_TYPE_WEB_NAVIGATION_ACTION,
428                                                      "reason", kit(action.type()),
429                                                      "original-uri", action.url().string().utf8().data(),
430                                                      "button", button,
431                                                      "modifier-state", modifierFlags,
432                                                      "target-frame", targetFrame,
433                                                      NULL));
434 }
435
436 void FrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>, const String& frameName)
437 {
438     ASSERT(policyFunction);
439     if (!policyFunction)
440         return;
441
442     if (resourceRequest.isNull()) {
443         (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyIgnore);
444         return;
445     }
446
447     WebKitWebPolicyDecision* policyDecision = webkit_web_policy_decision_new(m_frame, policyFunction);
448
449     if (m_policyDecision)
450         g_object_unref(m_policyDecision);
451     m_policyDecision = policyDecision;
452
453     WebKitWebView* webView = getViewFromFrame(m_frame);
454     GRefPtr<WebKitNetworkRequest> request(adoptGRef(webkit_network_request_new(resourceRequest.url().string().utf8().data())));
455     GRefPtr<WebKitWebNavigationAction> navigationAction(adoptGRef(getNavigationAction(action, frameName.utf8().data())));
456     gboolean isHandled = false;
457
458     g_signal_emit_by_name(webView, "new-window-policy-decision-requested", m_frame, request.get(), navigationAction.get(), policyDecision, &isHandled);
459
460     // FIXME: I think Qt version marshals this to another thread so when we
461     // have multi-threaded download, we might need to do the same
462     if (!isHandled)
463         (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyUse);
464 }
465
466 void FrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>)
467 {
468     ASSERT(policyFunction);
469     if (!policyFunction)
470         return;
471
472     if (resourceRequest.isNull()) {
473         (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyIgnore);
474         return;
475     }
476
477     WebKitWebView* webView = getViewFromFrame(m_frame);
478     GRefPtr<WebKitNetworkRequest> request(adoptGRef(kitNew(resourceRequest)));
479     WebKitNavigationResponse response;
480     /*
481      * We still support the deprecated navigation-requested signal, if the
482      * application doesn't ignore the navigation then the new signal is
483      * emitted.
484      * navigation-policy-decision-requested must be emitted after
485      * navigation-requested as the policy decision can be async.
486      */
487     g_signal_emit_by_name(webView, "navigation-requested", m_frame, request.get(), &response);
488
489     if (response == WEBKIT_NAVIGATION_RESPONSE_IGNORE) {
490         (core(m_frame)->loader()->policyChecker()->*policyFunction)(PolicyIgnore);
491         return;
492     }
493
494     WebKitWebPolicyDecision* policyDecision = webkit_web_policy_decision_new(m_frame, policyFunction);
495     if (m_policyDecision)
496         g_object_unref(m_policyDecision);
497     m_policyDecision = policyDecision;
498
499     GRefPtr<WebKitWebNavigationAction> navigationAction(adoptGRef(getNavigationAction(action, 0)));
500     gboolean isHandled = false;
501     g_signal_emit_by_name(webView, "navigation-policy-decision-requested", m_frame, request.get(), navigationAction.get(), policyDecision, &isHandled);
502
503     // FIXME Implement default behavior when we can query the backend what protocols it supports
504     if (!isHandled)
505         webkit_web_policy_decision_use(m_policyDecision);
506 }
507
508 PassRefPtr<Widget> FrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
509 {
510     /* Check if we want to embed a GtkWidget, fallback to plugins later */
511     CString urlString = url.string().utf8();
512     CString mimeTypeString = mimeType.utf8();
513
514     ASSERT(paramNames.size() == paramValues.size());
515     GRefPtr<GHashTable> hash = adoptGRef(g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free));
516     for (unsigned i = 0; i < paramNames.size(); ++i) {
517         g_hash_table_insert(hash.get(),
518                             g_strdup(paramNames[i].utf8().data()),
519                             g_strdup(paramValues[i].utf8().data()));
520     }
521
522     GtkWidget* gtkWidget = 0;
523     g_signal_emit_by_name(getViewFromFrame(m_frame), "create-plugin-widget",
524                           mimeTypeString.data(), urlString.data(), hash.get(), &gtkWidget);
525     if (gtkWidget)
526         return adoptRef(new GtkPluginWidget(gtkWidget));
527
528     RefPtr<PluginView> pluginView = PluginView::create(core(m_frame), pluginSize, element, url, paramNames, paramValues, mimeType, loadManually);
529
530     if (pluginView->status() == PluginStatusLoadedSuccessfully)
531         return pluginView;
532
533     return 0;
534 }
535
536 PassRefPtr<Frame> FrameLoaderClient::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
537                                                  const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
538 {
539     ASSERT(m_frame);
540     Frame* parentFrame = core(m_frame);
541     WebKitWebView* webView = getViewFromFrame(m_frame);
542     WebCore::Page* page = core(webView);
543     ASSERT(page == parentFrame->page());
544
545     WebKitWebFrame* kitFrame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
546     WebKitWebFramePrivate* framePrivate = kitFrame->priv;
547     framePrivate->webView = webView;
548
549     RefPtr<Frame> childFrame = Frame::create(page, ownerElement, new FrameLoaderClient(kitFrame));
550     framePrivate->coreFrame = childFrame.get();
551
552     childFrame->tree()->setName(name);
553     parentFrame->tree()->appendChild(childFrame);
554     childFrame->init();
555
556     // The creation of the frame may have run arbitrary JavaScript that removed it from the page already.
557     if (!childFrame->page())
558         return 0;
559
560     g_signal_emit_by_name(webView, "frame-created", kitFrame);
561
562     parentFrame->loader()->loadURLIntoChildFrame(url, referrer, childFrame.get());
563
564     // The frame's onload handler may have removed it from the document.
565     if (!childFrame->tree()->parent())
566         return 0;
567
568     return childFrame.release();
569 }
570
571 void FrameLoaderClient::didTransferChildFrameToNewDocument(WebCore::Page*)
572 {
573     ASSERT(m_frame);
574
575     // Update the frame's webview to the new parent's webview.
576     Frame* coreFrame = core(m_frame);
577     WebKitWebView* webView = getViewFromFrame(m_frame);
578
579     Frame* parentCoreFrame = coreFrame->tree()->parent();
580     WebKitWebFrame* parentKitFrame = kit(parentCoreFrame);
581     WebKitWebView* parentWebView = getViewFromFrame(parentKitFrame);
582     if (webView != parentWebView)
583         m_frame->priv->webView = parentWebView;
584
585     ASSERT(core(getViewFromFrame(m_frame)) == coreFrame->page());
586 }
587
588 void FrameLoaderClient::transferLoadingResourceFromPage(WebCore::ResourceLoader* loader, const WebCore::ResourceRequest& request, WebCore::Page* oldPage)
589 {
590     ASSERT(oldPage != core(m_frame)->page());
591
592     GOwnPtr<gchar> identifierString(toString(loader->identifier()));
593     ASSERT(!webkit_web_view_get_resource(getViewFromFrame(m_frame), identifierString.get()));
594
595     assignIdentifierToInitialRequest(loader->identifier(), loader->documentLoader(), request);
596
597     webkit_web_view_remove_resource(kit(oldPage), identifierString.get());
598 }
599
600 void FrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget)
601 {
602     ASSERT(!m_pluginView);
603     m_pluginView = static_cast<PluginView*>(pluginWidget);
604     m_hasSentResponseToPlugin = false;
605 }
606
607 PassRefPtr<Widget> FrameLoaderClient::createJavaAppletWidget(const IntSize& pluginSize, HTMLAppletElement* element, const KURL& baseURL, const Vector<String>& paramNames, const Vector<String>& paramValues)
608 {
609     return FrameLoaderClient::createPlugin(pluginSize, element, baseURL, paramNames, paramValues, "application/x-java-applet", false);
610 }
611
612 ObjectContentType FrameLoaderClient::objectContentType(const KURL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
613 {
614     return FrameLoader::defaultObjectContentType(url, mimeType, shouldPreferPlugInsForImages);
615 }
616
617 String FrameLoaderClient::overrideMediaType() const
618 {
619     notImplemented();
620     return String();
621 }
622
623 void FrameLoaderClient::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
624 {
625     if (world != mainThreadNormalWorld())
626         return;
627
628     // Is this obsolete now?
629     g_signal_emit_by_name(m_frame, "cleared");
630
631     Frame* coreFrame = core(m_frame);
632     ASSERT(coreFrame);
633
634     Settings* settings = coreFrame->settings();
635     if (!settings || !settings->isScriptEnabled())
636         return;
637
638     // TODO: Consider using g_signal_has_handler_pending() to avoid the overhead
639     // when there are no handlers.
640     JSGlobalContextRef context = toGlobalRef(coreFrame->script()->globalObject(mainThreadNormalWorld())->globalExec());
641     JSObjectRef windowObject = toRef(coreFrame->script()->globalObject(mainThreadNormalWorld()));
642     ASSERT(windowObject);
643
644     WebKitWebView* webView = getViewFromFrame(m_frame);
645     g_signal_emit_by_name(webView, "window-object-cleared", m_frame, context, windowObject);
646
647     // TODO: Re-attach debug clients if present.
648     // The Win port has an example of how we might do this.
649 }
650
651 void FrameLoaderClient::documentElementAvailable()
652 {
653 }
654
655 void FrameLoaderClient::didPerformFirstNavigation() const
656 {
657     WebKitCacheModel cacheModel = webkit_get_cache_model();
658     // If user agents do not determine the cache model, we use WEBKIT_CACHE_MODEL_WEB_BROWSER by default.
659     if (cacheModel == WEBKIT_CACHE_MODEL_DEFAULT)
660         webkit_set_cache_model(WEBKIT_CACHE_MODEL_WEB_BROWSER);
661 }
662
663 void FrameLoaderClient::registerForIconNotification(bool shouldRegister)
664 {
665     notImplemented();
666 }
667
668 void FrameLoaderClient::setMainFrameDocumentReady(bool ready)
669 {
670     if (!ready)
671         DOMObjectCache::clearByFrame(core(m_frame));
672 }
673
674 bool FrameLoaderClient::hasWebView() const
675 {
676     return getViewFromFrame(m_frame);
677 }
678
679 void FrameLoaderClient::dispatchDidFinishLoad()
680 {
681     if (m_loadingErrorPage) {
682         m_loadingErrorPage = false;
683         return;
684     }
685
686     loadDone(m_frame, true);
687 }
688
689 void FrameLoaderClient::frameLoadCompleted()
690 {
691     notImplemented();
692 }
693
694 void FrameLoaderClient::saveViewStateToItem(HistoryItem*)
695 {
696     notImplemented();
697 }
698
699 void FrameLoaderClient::restoreViewState()
700 {
701     notImplemented();
702 }
703
704 bool FrameLoaderClient::shouldGoToHistoryItem(HistoryItem* item) const
705 {
706     // FIXME: This is a very simple implementation. More sophisticated
707     // implementation would delegate the decision to a PolicyDelegate.
708     // See mac implementation for example.
709     return item != 0;
710 }
711
712 bool FrameLoaderClient::shouldStopLoadingForHistoryItem(HistoryItem* item) const
713 {
714     return true;
715 }
716
717 void FrameLoaderClient::didDisplayInsecureContent()
718 {
719     notImplemented();
720 }
721
722 void FrameLoaderClient::didRunInsecureContent(SecurityOrigin*, const KURL&)
723 {
724     notImplemented();
725 }
726
727 void FrameLoaderClient::didDetectXSS(const KURL&, bool)
728 {
729     notImplemented();
730 }
731
732 void FrameLoaderClient::makeRepresentation(WebCore::DocumentLoader*)
733 {
734     m_hasRepresentation = true;
735 }
736
737 void FrameLoaderClient::forceLayout()
738 {
739     FrameView* view = core(m_frame)->view();
740     if (view)
741         view->forceLayout(true);
742 }
743
744 void FrameLoaderClient::forceLayoutForNonHTML()
745 {
746     notImplemented();
747 }
748
749 void FrameLoaderClient::setCopiesOnScroll()
750 {
751     notImplemented();
752 }
753
754 void FrameLoaderClient::detachedFromParent2()
755 {
756     notImplemented();
757 }
758
759 void FrameLoaderClient::detachedFromParent3()
760 {
761     notImplemented();
762 }
763
764 void FrameLoaderClient::dispatchDidHandleOnloadEvents()
765 {
766     g_signal_emit_by_name(getViewFromFrame(m_frame), "onload-event", m_frame);
767 }
768
769 void FrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad()
770 {
771     notImplemented();
772 }
773
774 void FrameLoaderClient::dispatchDidCancelClientRedirect()
775 {
776     notImplemented();
777 }
778
779 void FrameLoaderClient::dispatchWillPerformClientRedirect(const KURL&, double, double)
780 {
781     notImplemented();
782 }
783
784 void FrameLoaderClient::dispatchDidChangeLocationWithinPage()
785 {
786     WebKitWebFramePrivate* priv = m_frame->priv;
787     g_free(priv->uri);
788     priv->uri = g_strdup(core(m_frame)->document()->url().string().utf8().data());
789     g_object_notify(G_OBJECT(m_frame), "uri");
790     WebKitWebView* webView = getViewFromFrame(m_frame);
791     if (m_frame == webkit_web_view_get_main_frame(webView))
792         g_object_notify(G_OBJECT(webView), "uri");
793 }
794
795 void FrameLoaderClient::dispatchDidPushStateWithinPage()
796 {
797     notImplemented();
798 }
799
800 void FrameLoaderClient::dispatchDidReplaceStateWithinPage()
801 {
802     notImplemented();
803 }
804
805 void FrameLoaderClient::dispatchDidPopStateWithinPage()
806 {
807     notImplemented();
808 }
809
810 void FrameLoaderClient::dispatchWillClose()
811 {
812     notImplemented();
813 }
814
815 void FrameLoaderClient::dispatchDidReceiveIcon()
816 {
817     if (m_loadingErrorPage)
818         return;
819
820     const gchar* frameURI = webkit_web_frame_get_uri(m_frame);
821     WebKitIconDatabase* database = webkit_get_icon_database();
822     g_signal_emit_by_name(database, "icon-loaded", m_frame, frameURI);
823
824     WebKitWebView* webView = getViewFromFrame(m_frame);
825
826     // Avoid reporting favicons for non-main frames.
827     if (m_frame != webkit_web_view_get_main_frame(webView))
828         return;
829
830     g_object_notify(G_OBJECT(webView), "icon-uri");
831     g_signal_emit_by_name(webView, "icon-loaded", webkit_web_view_get_icon_uri(webView));
832 }
833
834 void FrameLoaderClient::dispatchDidStartProvisionalLoad()
835 {
836     if (m_loadingErrorPage)
837         return;
838
839     notifyStatus(m_frame, WEBKIT_LOAD_PROVISIONAL);
840 }
841
842 void FrameLoaderClient::dispatchDidReceiveTitle(const StringWithDirection& title)
843 {
844     if (m_loadingErrorPage)
845         return;
846
847     WebKitWebFramePrivate* priv = m_frame->priv;
848     g_free(priv->title);
849     // FIXME: use direction of title.
850     priv->title = g_strdup(title.string().utf8().data());
851
852     g_signal_emit_by_name(m_frame, "title-changed", priv->title);
853     g_object_notify(G_OBJECT(m_frame), "title");
854
855     WebKitWebView* webView = getViewFromFrame(m_frame);
856     if (m_frame == webkit_web_view_get_main_frame(webView)) {
857         g_signal_emit_by_name(webView, "title-changed", m_frame, title.string().utf8().data());
858         g_object_notify(G_OBJECT(webView), "title");
859     }
860 }
861
862 void FrameLoaderClient::dispatchDidChangeIcons(WebCore::IconType)
863 {
864     notImplemented();
865 }
866
867 void FrameLoaderClient::dispatchDidCommitLoad()
868 {
869     if (m_loadingErrorPage)
870         return;
871
872     /* Update the URI once first data has been received.
873      * This means the URI is valid and successfully identify the page that's going to be loaded.
874      */
875     g_object_freeze_notify(G_OBJECT(m_frame));
876
877     WebKitWebFramePrivate* priv = m_frame->priv;
878     g_free(priv->uri);
879     priv->uri = g_strdup(core(m_frame)->loader()->activeDocumentLoader()->url().string().utf8().data());
880     g_free(priv->title);
881     priv->title = NULL;
882     g_object_notify(G_OBJECT(m_frame), "uri");
883     g_object_notify(G_OBJECT(m_frame), "title");
884
885     g_signal_emit_by_name(m_frame, "load-committed");
886     notifyStatus(m_frame, WEBKIT_LOAD_COMMITTED);
887
888     WebKitWebView* webView = getViewFromFrame(m_frame);
889     if (m_frame == webkit_web_view_get_main_frame(webView)) {
890         g_object_freeze_notify(G_OBJECT(webView));
891         g_object_notify(G_OBJECT(webView), "uri");
892         g_object_notify(G_OBJECT(webView), "title");
893         g_object_thaw_notify(G_OBJECT(webView));
894         g_signal_emit_by_name(webView, "load-committed", m_frame);
895     }
896
897     g_object_thaw_notify(G_OBJECT(m_frame));
898 }
899
900 void FrameLoaderClient::dispatchDidFinishDocumentLoad()
901 {
902     WebKitWebView* webView = getViewFromFrame(m_frame);
903     g_signal_emit_by_name(webView, "document-load-finished", m_frame);
904 }
905
906 void FrameLoaderClient::dispatchDidFirstLayout()
907 {
908     notImplemented();
909 }
910
911 void FrameLoaderClient::dispatchDidFirstVisuallyNonEmptyLayout()
912 {
913     if (m_loadingErrorPage)
914         return;
915
916     notifyStatus(m_frame, WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT);
917 }
918
919 void FrameLoaderClient::dispatchShow()
920 {
921     WebKitWebView* webView = getViewFromFrame(m_frame);
922     webkit_web_view_notify_ready(webView);
923 }
924
925 void FrameLoaderClient::cancelPolicyCheck()
926 {
927     //FIXME Add support for more than one policy decision at once
928     if (m_policyDecision)
929         webkit_web_policy_decision_cancel(m_policyDecision);
930 }
931
932 void FrameLoaderClient::dispatchDidLoadMainResource(WebCore::DocumentLoader*)
933 {
934     notImplemented();
935 }
936
937 void FrameLoaderClient::revertToProvisionalState(WebCore::DocumentLoader*)
938 {
939     m_hasRepresentation = true;
940 }
941
942 void FrameLoaderClient::willChangeTitle(WebCore::DocumentLoader*)
943 {
944     notImplemented();
945 }
946
947 void FrameLoaderClient::didChangeTitle(WebCore::DocumentLoader *l)
948 {
949     setTitle(l->title(), l->url());
950 }
951
952 bool FrameLoaderClient::canHandleRequest(const ResourceRequest&) const
953 {
954     notImplemented();
955     return true;
956 }
957
958 bool FrameLoaderClient::canShowMIMETypeAsHTML(const String& MIMEType) const
959 {
960     notImplemented();
961     return false;
962 }
963
964 bool FrameLoaderClient::canShowMIMEType(const String& type) const
965 {
966     return (MIMETypeRegistry::isSupportedImageMIMEType(type)
967             || MIMETypeRegistry::isSupportedNonImageMIMEType(type)
968             || MIMETypeRegistry::isSupportedMediaMIMEType(type)
969             || PluginDatabase::installedPlugins()->isMIMETypeRegistered(type));
970 }
971
972 bool FrameLoaderClient::representationExistsForURLScheme(const String&) const
973 {
974     notImplemented();
975     return false;
976 }
977
978 String FrameLoaderClient::generatedMIMETypeForURLScheme(const String&) const
979 {
980     notImplemented();
981     return String();
982 }
983
984 void FrameLoaderClient::finishedLoading(WebCore::DocumentLoader* documentLoader)
985 {
986     if (!m_pluginView) {
987         // This is necessary to create an empty document,
988         // but it has to be skipped in the provisional phase.
989         if (m_hasRepresentation)
990             documentLoader->writer()->setEncoding("", false);
991     } else {
992         m_pluginView->didFinishLoading();
993         m_pluginView = 0;
994         m_hasSentResponseToPlugin = false;
995     }
996 }
997
998
999 void FrameLoaderClient::provisionalLoadStarted()
1000 {
1001     notImplemented();
1002 }
1003
1004 void FrameLoaderClient::didFinishLoad() {
1005     notImplemented();
1006 }
1007
1008 void FrameLoaderClient::prepareForDataSourceReplacement() 
1009 {
1010     notImplemented();
1011 }
1012
1013 void FrameLoaderClient::setTitle(const StringWithDirection& title, const KURL& url)
1014 {
1015     WebKitWebFramePrivate* frameData = m_frame->priv;
1016     g_free(frameData->title);
1017     // FIXME: use direction of title.
1018     frameData->title = g_strdup(title.string().utf8().data());
1019 }
1020
1021 void FrameLoaderClient::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long identifier, int dataLength)
1022 {
1023     notImplemented();
1024 }
1025
1026 void FrameLoaderClient::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long identifier)
1027 {
1028     static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier);
1029
1030     WebKitWebView* webView = getViewFromFrame(m_frame);
1031     GOwnPtr<gchar> identifierString(toString(identifier));
1032     WebKitWebResource* webResource = webkit_web_view_get_resource(webView, identifierString.get());
1033
1034     // A NULL WebResource means the load has been interrupted, and
1035     // replaced by another one while this resource was being loaded.
1036     if (!webResource)
1037         return;
1038
1039     const char* uri = webkit_web_resource_get_uri(webResource);
1040     RefPtr<ArchiveResource> coreResource(loader->subresource(KURL(KURL(), uri)));
1041
1042     // If coreResource is NULL here, the resource failed to load,
1043     // unless it's the main resource.
1044     if (!coreResource && webResource != webkit_web_view_get_main_resource(webView))
1045         return;
1046
1047     if (!coreResource)
1048         coreResource = loader->mainResource();
1049
1050     webkit_web_resource_init_with_core_resource(webResource, coreResource.get());
1051
1052     // FIXME: This function should notify the application that the resource
1053     // finished loading, maybe using a load-status property in the
1054     // WebKitWebResource object, similar to what we do for WebKitWebFrame'
1055     // signal.
1056     notImplemented();
1057 }
1058
1059 void FrameLoaderClient::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long identifier, const ResourceError& error)
1060 {
1061     static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier);
1062
1063     // FIXME: This function should notify the application that the resource failed
1064     // loading, maybe a 'load-error' signal in the WebKitWebResource object.
1065     notImplemented();
1066 }
1067
1068 bool FrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length)
1069 {
1070     notImplemented();
1071     return false;
1072 }
1073
1074 void FrameLoaderClient::dispatchDidFailProvisionalLoad(const ResourceError& error)
1075 {
1076     dispatchDidFailLoad(error);
1077 }
1078
1079 void FrameLoaderClient::dispatchDidFailLoad(const ResourceError& error)
1080 {
1081     if (m_loadingErrorPage)
1082         return;
1083
1084     notifyStatus(m_frame, WEBKIT_LOAD_FAILED);
1085
1086     WebKitWebView* webView = getViewFromFrame(m_frame);
1087     GError* webError = g_error_new_literal(g_quark_from_string(error.domain().utf8().data()),
1088                                            error.errorCode(),
1089                                            error.localizedDescription().utf8().data());
1090     gboolean isHandled = false;
1091     g_signal_emit_by_name(webView, "load-error", m_frame, error.failingURL().utf8().data(), webError, &isHandled);
1092
1093     if (isHandled) {
1094         g_error_free(webError);
1095         return;
1096     }
1097
1098     if (!shouldFallBack(error)) {
1099         g_error_free(webError);
1100         return;
1101     }
1102
1103     m_loadingErrorPage = true;
1104
1105     String content;
1106     gchar* fileContent = 0;
1107     gchar* errorURI = g_filename_to_uri(DATA_DIR"/webkit-1.0/resources/error.html", NULL, NULL);
1108     GFile* errorFile = g_file_new_for_uri(errorURI);
1109     g_free(errorURI);
1110
1111     if (!errorFile)
1112         content = makeString("<html><body>", webError->message, "</body></html>");
1113     else {
1114         gboolean loaded = g_file_load_contents(errorFile, 0, &fileContent, 0, 0, 0);
1115         if (!loaded)
1116             content = makeString("<html><body>", webError->message, "</body></html>");
1117         else
1118             content = String::format(fileContent, error.failingURL().utf8().data(), webError->message);
1119     }
1120
1121     webkit_web_frame_load_alternate_string(m_frame, content.utf8().data(), 0, error.failingURL().utf8().data());
1122
1123     g_free(fileContent);
1124
1125     if (errorFile)
1126         g_object_unref(errorFile);
1127
1128     g_error_free(webError);
1129 }
1130
1131 void FrameLoaderClient::download(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& response)
1132 {
1133     GRefPtr<WebKitNetworkRequest> networkRequest(adoptGRef(kitNew(request)));
1134     WebKitWebView* view = getViewFromFrame(m_frame);
1135
1136     webkit_web_view_request_download(view, networkRequest.get(), response, handle);
1137 }
1138
1139 ResourceError FrameLoaderClient::cancelledError(const ResourceRequest& request)
1140 {
1141     return WebCore::cancelledError(request);
1142 }
1143
1144 ResourceError FrameLoaderClient::blockedError(const ResourceRequest& request)
1145 {
1146     return WebCore::blockedError(request);
1147 }
1148
1149 ResourceError FrameLoaderClient::cannotShowURLError(const ResourceRequest& request)
1150 {
1151     return WebCore::cannotShowURLError(request);
1152 }
1153
1154 ResourceError FrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request)
1155 {
1156     return WebCore::interruptedForPolicyChangeError(request);
1157 }
1158
1159 ResourceError FrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response)
1160 {
1161     return WebCore::cannotShowMIMETypeError(response);
1162 }
1163
1164 ResourceError FrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response)
1165 {
1166     return WebCore::fileDoesNotExistError(response);
1167 }
1168
1169 ResourceError FrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response)
1170 {
1171     return WebCore::pluginWillHandleLoadError(response);
1172 }
1173
1174 bool FrameLoaderClient::shouldFallBack(const ResourceError& error)
1175 {
1176     return !(error.isCancellation() || error.errorCode() == WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE || error.errorCode() == WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD);
1177 }
1178
1179 bool FrameLoaderClient::canCachePage() const
1180 {
1181     return true;
1182 }
1183
1184 Frame* FrameLoaderClient::dispatchCreatePage(const NavigationAction&)
1185 {
1186     WebKitWebView* webView = getViewFromFrame(m_frame);
1187     WebKitWebView* newWebView = 0;
1188
1189     g_signal_emit_by_name(webView, "create-web-view", m_frame, &newWebView);
1190
1191     if (!newWebView)
1192         return 0;
1193
1194     WebKitWebViewPrivate* privateData = newWebView->priv;
1195     return core(privateData->mainFrame);
1196 }
1197
1198 void FrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&)
1199 {
1200     notImplemented();
1201 }
1202
1203 void FrameLoaderClient::setMainDocumentError(WebCore::DocumentLoader*, const ResourceError& error)
1204 {
1205     if (m_pluginView) {
1206         m_pluginView->didFail(error);
1207         m_pluginView = 0;
1208         m_hasSentResponseToPlugin = false;
1209     }
1210 }
1211
1212 void FrameLoaderClient::startDownload(const ResourceRequest& request, const String& /* suggestedName */)
1213 {
1214     GRefPtr<WebKitNetworkRequest> networkRequest(adoptGRef(kitNew(request)));
1215     WebKitWebView* view = getViewFromFrame(m_frame);
1216
1217     webkit_web_view_request_download(view, networkRequest.get());
1218 }
1219
1220 void FrameLoaderClient::updateGlobalHistory()
1221 {
1222     notImplemented();
1223 }
1224
1225 void FrameLoaderClient::updateGlobalHistoryRedirectLinks()
1226 {
1227     notImplemented();
1228 }
1229
1230 void FrameLoaderClient::savePlatformDataToCachedFrame(CachedFrame* cachedFrame)
1231 {
1232 }
1233
1234 static void postCommitFrameViewSetup(WebKitWebFrame *frame)
1235 {
1236     WebKitWebView* containingWindow = getViewFromFrame(frame);
1237     webkit_web_view_clear_resources(containingWindow);
1238
1239     // Invalidate the viewport attributes - they will only be valid
1240     // again if the page we're beginning to load now has an
1241     // appropriate viewport meta tag.
1242     WebKitWebViewPrivate* priv = containingWindow->priv;
1243     priv->viewportAttributes->priv->isValid = FALSE;
1244     g_object_notify(G_OBJECT(priv->viewportAttributes.get()), "valid");
1245
1246     if (priv->currentMenu) {
1247         gtk_widget_destroy(GTK_WIDGET(priv->currentMenu));
1248         priv->currentMenu = 0;
1249     }
1250
1251     // Do not allow click counting between main frame loads.
1252     priv->clickCounter.reset();
1253 }
1254
1255 void FrameLoaderClient::transitionToCommittedFromCachedFrame(CachedFrame* cachedFrame)
1256 {
1257     ASSERT(cachedFrame->view());
1258
1259     Frame* frame = core(m_frame);
1260     if (frame != frame->page()->mainFrame())
1261         return;
1262
1263     postCommitFrameViewSetup(m_frame);
1264 }
1265
1266 void FrameLoaderClient::transitionToCommittedForNewPage()
1267 {
1268     WebKitWebView* containingWindow = getViewFromFrame(m_frame);
1269     GtkAllocation allocation;
1270 #if GTK_CHECK_VERSION(2, 18, 0)
1271     gtk_widget_get_allocation(GTK_WIDGET(containingWindow), &allocation);
1272 #else
1273     allocation = GTK_WIDGET(containingWindow)->allocation;
1274 #endif
1275     IntSize size = IntSize(allocation.width, allocation.height);
1276     bool transparent = webkit_web_view_get_transparent(containingWindow);
1277     Color backgroundColor = transparent ? WebCore::Color::transparent : WebCore::Color::white;
1278     Frame* frame = core(m_frame);
1279     ASSERT(frame);
1280
1281     frame->createView(size, backgroundColor, transparent, IntSize(), false);
1282
1283     // We need to do further manipulation on the FrameView if it was the mainFrame
1284     if (frame != frame->page()->mainFrame())
1285         return;
1286
1287     postCommitFrameViewSetup(m_frame);
1288 }
1289
1290 void FrameLoaderClient::didSaveToPageCache()
1291 {
1292 }
1293
1294 void FrameLoaderClient::didRestoreFromPageCache()
1295 {
1296 }
1297
1298 void FrameLoaderClient::dispatchDidBecomeFrameset(bool)
1299 {
1300 }
1301
1302 PassRefPtr<FrameNetworkingContext> FrameLoaderClient::createNetworkingContext()
1303 {
1304     return FrameNetworkingContextGtk::create(core(m_frame));
1305 }
1306
1307 }