2009-03-03 Gustavo Noronha Silva <gns@gnome.org>
[WebKit-https.git] / WebKit / gtk / WebCoreSupport / FrameLoaderClientGtk.cpp
1 /*
2  *  Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>
3  *  Copyright (C) 2007, 2008 Holger Hans Peter Freyther
4  *  Copyright (C) 2007 Christian Dywan <christian@twotoasts.de>
5  *  Copyright (C) 2008 Collabora Ltd.  All rights reserved.
6  *  Copyright (C) 2009 Gustavo Noronha Silva <gns@gnome.org>
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  */
22
23 #include "config.h"
24 #include "FrameLoaderClientGtk.h"
25
26 #include "Color.h"
27 #include "DocumentLoader.h"
28 #include "FormState.h"
29 #include "FrameLoader.h"
30 #include "FrameView.h"
31 #include "FrameTree.h"
32 #include "HTMLAppletElement.h"
33 #include "HTMLFormElement.h"
34 #include "HTMLFrameElement.h"
35 #include "HTMLFrameOwnerElement.h"
36 #include "HTMLNames.h"
37 #include "HTMLPlugInElement.h"
38 #include "JSDOMWindow.h"
39 #include "Language.h"
40 #include "MIMETypeRegistry.h"
41 #include "MouseEvent.h"
42 #include "NotImplemented.h"
43 #include "PlatformString.h"
44 #include "PluginDatabase.h"
45 #include "RenderPart.h"
46 #include "ResourceHandle.h"
47 #include "ResourceRequest.h"
48 #include "CString.h"
49 #include "ProgressTracker.h"
50 #include "JSDOMBinding.h"
51 #include "ScriptController.h"
52 #include "webkitwebview.h"
53 #include "webkitnetworkrequest.h"
54 #include "webkitwebframe.h"
55 #include "webkitwebnavigationaction.h"
56 #include "webkitwebpolicydecision.h"
57 #include "webkitprivate.h"
58
59 #include <JavaScriptCore/APICast.h>
60 #include <stdio.h>
61 #if PLATFORM(UNIX)
62 #include <sys/utsname.h>
63 #endif
64
65 using namespace WebCore;
66
67 namespace WebKit {
68
69 FrameLoaderClient::FrameLoaderClient(WebKitWebFrame* frame)
70     : m_frame(frame)
71     , m_userAgent("")
72     , m_policyDecision(0)
73     , m_pluginView(0)
74     , m_hasSentResponseToPlugin(false)
75 {
76     ASSERT(m_frame);
77 }
78
79 FrameLoaderClient::~FrameLoaderClient()
80 {
81     if (m_policyDecision)
82         g_object_unref(m_policyDecision);
83 }
84
85 static String agentPlatform()
86 {
87 #ifdef GDK_WINDOWING_X11
88     return "X11";
89 #elif defined(GDK_WINDOWING_WIN32)
90     return "Windows";
91 #elif defined(GDK_WINDOWING_QUARTZ)
92     return "Macintosh";
93 #elif defined(GDK_WINDOWING_DIRECTFB)
94     return "DirectFB";
95 #else
96     notImplemented();
97     return "Unknown";
98 #endif
99 }
100
101 static String agentOS()
102 {
103 #if PLATFORM(DARWIN)
104 #if PLATFORM(X86)
105     return "Intel Mac OS X";
106 #else
107     return "PPC Mac OS X";
108 #endif
109 #elif PLATFORM(UNIX)
110     struct utsname name;
111     if (uname(&name) != -1)
112         return String::format("%s %s", name.sysname, name.machine);
113     else
114         return "Unknown";
115 #elif PLATFORM(WIN_OS)
116     // FIXME: Compute the Windows version
117     return "Windows";
118 #else
119     notImplemented();
120     return "Unknown";
121 #endif
122 }
123
124 static String composeUserAgent()
125 {
126     // This is a liberal interpretation of http://www.mozilla.org/build/revised-user-agent-strings.html
127     // See also http://developer.apple.com/internet/safari/faq.html#anchor2
128
129     String ua;
130
131     // Product
132     ua += "Mozilla/5.0";
133
134     // Comment
135     ua += " (";
136     ua += agentPlatform(); // Platform
137     ua += "; U; "; // Security
138     ua += agentOS(); // OS-or-CPU
139     ua += "; ";
140     ua += defaultLanguage(); // Localization information
141     ua += ") ";
142
143     // WebKit Product
144     // FIXME: The WebKit version is hardcoded
145     static const String webKitVersion = "528.5+";
146     ua += "AppleWebKit/" + webKitVersion;
147     ua += " (KHTML, like Gecko, ";
148     // We mention Safari since many broken sites check for it (OmniWeb does this too)
149     // We re-use the WebKit version, though it doesn't seem to matter much in practice
150     ua += "Safari/" + webKitVersion;
151     ua += ") ";
152
153     // Vendor Product
154     ua += g_get_prgname();
155
156     return ua;
157 }
158
159 String FrameLoaderClient::userAgent(const KURL&)
160 {
161     if (m_userAgent.isEmpty())
162         m_userAgent = composeUserAgent();
163
164     return m_userAgent;
165 }
166
167 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClient::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
168 {
169     return DocumentLoader::create(request, substituteData);
170 }
171
172 void FrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction policyFunction, PassRefPtr<FormState>)
173 {
174     // FIXME: This is surely too simple
175     ASSERT(policyFunction);
176     if (!policyFunction)
177         return;
178     (core(m_frame)->loader()->*policyFunction)(PolicyUse);
179 }
180
181
182 void FrameLoaderClient::committedLoad(DocumentLoader* loader, const char* data, int length)
183 {
184     if (!m_pluginView) {
185         ASSERT(loader->frame());
186         // Setting the encoding on the frame loader is our way to get work done that is normally done
187         // when the first bit of data is received, even for the case of a document with no data (like about:blank).
188         String encoding = loader->overrideEncoding();
189         bool userChosen = !encoding.isNull();
190         if (!userChosen)
191             encoding = loader->response().textEncodingName();
192
193         FrameLoader* frameLoader = loader->frameLoader();
194         frameLoader->setEncoding(encoding, userChosen);
195         if (data)
196             frameLoader->addData(data, length);
197     }
198
199     if (m_pluginView) {
200         if (!m_hasSentResponseToPlugin) {
201             m_pluginView->didReceiveResponse(loader->response());
202             m_hasSentResponseToPlugin = true;
203         }
204         m_pluginView->didReceiveData(data, length);
205     }
206 }
207
208 bool
209 FrameLoaderClient::shouldUseCredentialStorage(DocumentLoader*, unsigned long  identifier)
210 {
211     notImplemented();
212     return false;
213 }
214
215 void FrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
216 {
217     notImplemented();
218 }
219
220 void FrameLoaderClient::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
221 {
222     notImplemented();
223 }
224
225 void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&)
226 {
227     notImplemented();
228 }
229
230 void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
231 {
232     notImplemented();
233 }
234
235 void FrameLoaderClient::postProgressStartedNotification()
236 {
237     WebKitWebView* webView = getViewFromFrame(m_frame);
238     g_signal_emit_by_name(webView, "load-started", m_frame);
239 }
240
241 void FrameLoaderClient::postProgressEstimateChangedNotification()
242 {
243     WebKitWebView* webView = getViewFromFrame(m_frame);
244     Page* corePage = core(webView);
245
246     g_signal_emit_by_name(webView, "load-progress-changed", lround(corePage->progress()->estimatedProgress()*100));
247 }
248
249 void FrameLoaderClient::postProgressFinishedNotification()
250 {
251     WebKitWebView* webView = getViewFromFrame(m_frame);
252     WebKitWebViewPrivate* privateData = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
253
254     // We can get a stopLoad() from dispose when the object is being
255     // destroyed, don't emit the signal in that case.
256     if (!privateData->disposing)
257         g_signal_emit_by_name(webView, "load-finished", m_frame);
258 }
259
260 void FrameLoaderClient::frameLoaderDestroyed()
261 {
262     webkit_web_frame_core_frame_gone(m_frame);
263     g_object_unref(m_frame);
264     m_frame = 0;
265     delete this;
266 }
267
268 void FrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse& response)
269 {
270     m_response = response;
271 }
272
273 void FrameLoaderClient::dispatchDecidePolicyForMIMEType(FramePolicyFunction policyFunction, const String& mimeType, const ResourceRequest& resourceRequest)
274 {
275     ASSERT(policyFunction);
276     if (!policyFunction)
277         return;
278
279     if (resourceRequest.isNull()) {
280         (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
281         return;
282     }
283
284     WebKitWebView* page = getViewFromFrame(m_frame);
285     WebKitNetworkRequest* request = webkit_network_request_new(resourceRequest.url().string().utf8().data());
286
287     WebKitWebPolicyDecision* policyDecision = webkit_web_policy_decision_new(m_frame, policyFunction);
288     if (m_policyDecision)
289         g_object_unref(m_policyDecision);
290     m_policyDecision = policyDecision;
291
292     gboolean isHandled = false;
293     g_signal_emit_by_name(page, "mime-type-policy-decision-requested", m_frame, request, mimeType.utf8().data(), policyDecision, &isHandled);
294
295     g_object_unref(request);
296
297     if (isHandled)
298         return;
299
300     if (canShowMIMEType(mimeType))
301         webkit_web_policy_decision_use (policyDecision);
302     else
303         webkit_web_policy_decision_download (policyDecision);
304 }
305
306 void FrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>, const String& s)
307 {
308     ASSERT(policyFunction);
309     if (!policyFunction)
310         return;
311
312     if (resourceRequest.isNull()) {
313         (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
314         return;
315     }
316
317     // FIXME: I think Qt version marshals this to another thread so when we
318     // have multi-threaded download, we might need to do the same
319     (core(m_frame)->loader()->*policyFunction)(PolicyUse);
320 }
321
322 void FrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>)
323 {
324     ASSERT(policyFunction);
325     if (!policyFunction)
326         return;
327
328     if (resourceRequest.isNull()) {
329         (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
330         return;
331     }
332
333     WebKitWebView* webView = getViewFromFrame(m_frame);
334     WebKitNetworkRequest* request = webkit_network_request_new(resourceRequest.url().string().utf8().data());
335     WebKitNavigationResponse response;
336     /*
337      * We still support the deprecated navigation-requested signal, if the
338      * application doesn't ignore the navigation then the new signal is
339      * emitted.
340      * navigation-policy-decision-requested must be emitted after
341      * navigation-requested as the policy decision can be async.
342      */
343     g_signal_emit_by_name(webView, "navigation-requested", m_frame, request, &response);
344
345     if (response == WEBKIT_NAVIGATION_RESPONSE_IGNORE) {
346         (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
347         g_object_unref(request);
348         return;
349     }
350
351     WebKitWebPolicyDecision* policyDecision = webkit_web_policy_decision_new(m_frame, policyFunction);
352     if (m_policyDecision)
353         g_object_unref(m_policyDecision);
354     m_policyDecision = policyDecision;
355
356     gint button = -1;
357     gint modifierFlags = 0;
358
359     const Event* event = action.event();
360     if (event && event->isMouseEvent()) {
361         const MouseEvent* mouseEvent = static_cast<const MouseEvent*>(event);
362         // DOM button values are 0, 1 and 2 for left, middle and right buttons.
363         // GTK+ uses 1, 2 and 3, so let's add 1 to remain consistent.
364         button = mouseEvent->button() + 1;
365     }
366
367     UIEventWithKeyState* keyStateEvent = findEventWithKeyState(const_cast<Event*>(event));
368     if (keyStateEvent) {
369         if (keyStateEvent->shiftKey())
370             modifierFlags |= GDK_SHIFT_MASK;
371         if (keyStateEvent->ctrlKey())
372             modifierFlags |= GDK_CONTROL_MASK;
373         if (keyStateEvent->altKey())
374             modifierFlags |= GDK_MOD1_MASK;
375         if (keyStateEvent->metaKey())
376             modifierFlags |= GDK_MOD2_MASK;
377     }
378
379     GObject* navigationAction = G_OBJECT(g_object_new(WEBKIT_TYPE_WEB_NAVIGATION_ACTION,
380                                                      "reason", kit(action.type()),
381                                                       "original-uri", action.url().string().utf8().data(),
382                                                       "button", button,
383                                                       "modifier-state", modifierFlags,
384                                                       NULL));
385
386     gboolean isHandled = false;
387     g_signal_emit_by_name(webView, "navigation-policy-decision-requested", m_frame, request, navigationAction, policyDecision, &isHandled);
388
389     g_object_unref(navigationAction);
390     g_object_unref(request);
391
392     // FIXME Implement default behavior when we can query the backend what protocols it supports
393     if (!isHandled)
394         webkit_web_policy_decision_use(m_policyDecision);
395 }
396
397 Widget* FrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
398 {
399     PluginView* pluginView = PluginView::create(core(m_frame), pluginSize, element, url, paramNames, paramValues, mimeType, loadManually);
400
401     if (pluginView->status() == PluginStatusLoadedSuccessfully)
402         return pluginView;
403
404     return 0;
405 }
406
407 PassRefPtr<Frame> FrameLoaderClient::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
408                                                  const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
409 {
410     Frame* coreFrame = core(webFrame());
411
412     ASSERT(core(getViewFromFrame(webFrame())) == coreFrame->page());
413
414     RefPtr<Frame> childFrame = webkit_web_frame_init_with_web_view(getViewFromFrame(webFrame()), ownerElement);
415
416     coreFrame->tree()->appendChild(childFrame);
417
418     childFrame->tree()->setName(name);
419     childFrame->init();
420     childFrame->loader()->loadURL(url, referrer, String(), false, FrameLoadTypeRedirectWithLockedBackForwardList, 0, 0);
421
422     // The frame's onload handler may have removed it from the document.
423     if (!childFrame->tree()->parent())
424         return 0;
425
426     return childFrame.release();
427 }
428
429 void FrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget)
430 {
431     ASSERT(!m_pluginView);
432     m_pluginView = static_cast<PluginView*>(pluginWidget);
433     m_hasSentResponseToPlugin = false;
434 }
435
436 Widget* FrameLoaderClient::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL& baseURL,
437                                                   const Vector<String>& paramNames, const Vector<String>& paramValues)
438 {
439     notImplemented();
440     return 0;
441 }
442
443 ObjectContentType FrameLoaderClient::objectContentType(const KURL& url, const String& mimeType)
444 {
445     String type = mimeType;
446     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
447     if (type.isEmpty())
448         type = MIMETypeRegistry::getMIMETypeForExtension(url.path().substring(url.path().reverseFind('.') + 1));
449
450     if (type.isEmpty())
451         return WebCore::ObjectContentFrame;
452
453     if (MIMETypeRegistry::isSupportedImageMIMEType(type))
454         return WebCore::ObjectContentImage;
455
456     if (PluginDatabase::installedPlugins()->isMIMETypeRegistered(mimeType))
457         return WebCore::ObjectContentNetscapePlugin;
458
459     if (MIMETypeRegistry::isSupportedNonImageMIMEType(type))
460         return WebCore::ObjectContentFrame;
461
462     return WebCore::ObjectContentNone;
463 }
464
465 String FrameLoaderClient::overrideMediaType() const
466 {
467     notImplemented();
468     return String();
469 }
470
471 void FrameLoaderClient::windowObjectCleared()
472 {
473     // Is this obsolete now?
474     g_signal_emit_by_name(m_frame, "cleared");
475
476     Frame* coreFrame = core(webFrame());
477     ASSERT(coreFrame);
478
479     Settings* settings = coreFrame->settings();
480     if (!settings || !settings->isJavaScriptEnabled())
481         return;
482
483     // TODO: Consider using g_signal_has_handler_pending() to avoid the overhead
484     // when there are no handlers.
485     JSGlobalContextRef context = toGlobalRef(coreFrame->script()->globalObject()->globalExec());
486     JSObjectRef windowObject = toRef(coreFrame->script()->globalObject());
487     ASSERT(windowObject);
488
489     WebKitWebView* webView = getViewFromFrame(m_frame);
490     g_signal_emit_by_name(webView, "window-object-cleared", m_frame, context, windowObject);
491
492     // TODO: Re-attach debug clients if present.
493     // The Win port has an example of how we might do this.
494 }
495
496 void FrameLoaderClient::documentElementAvailable()
497 {
498 }
499
500 void FrameLoaderClient::didPerformFirstNavigation() const
501 {
502 }
503
504 void FrameLoaderClient::registerForIconNotification(bool)
505 {
506     notImplemented();
507 }
508
509 void FrameLoaderClient::setMainFrameDocumentReady(bool)
510 {
511     // this is only interesting once we provide an external API for the DOM
512 }
513
514 bool FrameLoaderClient::hasWebView() const
515 {
516     notImplemented();
517     return true;
518 }
519
520 void FrameLoaderClient::dispatchDidFinishLoad()
521 {
522     g_signal_emit_by_name(m_frame, "load-done", true);
523 }
524
525 void FrameLoaderClient::frameLoadCompleted()
526 {
527     notImplemented();
528 }
529
530 void FrameLoaderClient::saveViewStateToItem(HistoryItem*)
531 {
532     notImplemented();
533 }
534
535 void FrameLoaderClient::restoreViewState()
536 {
537     notImplemented();
538 }
539
540 bool FrameLoaderClient::shouldGoToHistoryItem(HistoryItem* item) const
541 {
542     // FIXME: This is a very simple implementation. More sophisticated
543     // implementation would delegate the decision to a PolicyDelegate.
544     // See mac implementation for example.
545     return item != 0;
546 }
547
548 void FrameLoaderClient::makeRepresentation(DocumentLoader*)
549 {
550     notImplemented();
551 }
552
553 void FrameLoaderClient::forceLayout()
554 {
555     FrameView* view = core(m_frame)->view();
556     if (view)
557         view->forceLayout(true);
558 }
559
560 void FrameLoaderClient::forceLayoutForNonHTML()
561 {
562     notImplemented();
563 }
564
565 void FrameLoaderClient::setCopiesOnScroll()
566 {
567     notImplemented();
568 }
569
570 void FrameLoaderClient::detachedFromParent2()
571 {
572     notImplemented();
573 }
574
575 void FrameLoaderClient::detachedFromParent3()
576 {
577     notImplemented();
578 }
579
580 void FrameLoaderClient::dispatchDidHandleOnloadEvents()
581 {
582     notImplemented();
583 }
584
585 void FrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad()
586 {
587     notImplemented();
588 }
589
590 void FrameLoaderClient::dispatchDidCancelClientRedirect()
591 {
592     notImplemented();
593 }
594
595 void FrameLoaderClient::dispatchWillPerformClientRedirect(const KURL&, double, double)
596 {
597     notImplemented();
598 }
599
600 void FrameLoaderClient::dispatchDidChangeLocationWithinPage()
601 {
602     notImplemented();
603 }
604
605 void FrameLoaderClient::dispatchWillClose()
606 {
607     notImplemented();
608 }
609
610 void FrameLoaderClient::dispatchDidReceiveIcon()
611 {
612     WebKitWebView* webView = getViewFromFrame(m_frame);
613
614     g_signal_emit_by_name(webView, "icon-loaded", m_frame);
615 }
616
617 void FrameLoaderClient::dispatchDidStartProvisionalLoad()
618 {
619 }
620
621 void FrameLoaderClient::dispatchDidReceiveTitle(const String& title)
622 {
623     g_signal_emit_by_name(m_frame, "title-changed", title.utf8().data());
624
625     WebKitWebView* webView = getViewFromFrame(m_frame);
626     if (m_frame == webkit_web_view_get_main_frame(webView))
627         g_signal_emit_by_name(webView, "title-changed", m_frame, title.utf8().data());
628 }
629
630 void FrameLoaderClient::dispatchDidCommitLoad()
631 {
632     /* Update the URI once first data has been received.
633      * This means the URI is valid and successfully identify the page that's going to be loaded.
634      */
635     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(m_frame);
636     g_free(frameData->uri);
637     frameData->uri = g_strdup(core(m_frame)->loader()->url().prettyURL().utf8().data());
638
639     g_signal_emit_by_name(m_frame, "load-committed");
640
641     WebKitWebView* webView = getViewFromFrame(m_frame);
642     if (m_frame == webkit_web_view_get_main_frame(webView))
643         g_signal_emit_by_name(webView, "load-committed", m_frame);
644 }
645
646 void FrameLoaderClient::dispatchDidFinishDocumentLoad()
647 {
648     notImplemented();
649 }
650
651 void FrameLoaderClient::dispatchDidFirstLayout()
652 {
653     notImplemented();
654 }
655
656 void FrameLoaderClient::dispatchDidFirstVisuallyNonEmptyLayout()
657 {
658     notImplemented();
659 }
660
661 void FrameLoaderClient::dispatchShow()
662 {
663     WebKitWebView* webView = getViewFromFrame(m_frame);
664     webkit_web_view_notify_ready(webView);
665 }
666
667 void FrameLoaderClient::cancelPolicyCheck()
668 {
669     //FIXME Add support for more than one policy decision at once
670     if (m_policyDecision)
671         webkit_web_policy_decision_cancel(m_policyDecision);
672 }
673
674 void FrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*)
675 {
676     notImplemented();
677 }
678
679 void FrameLoaderClient::revertToProvisionalState(DocumentLoader*)
680 {
681     notImplemented();
682 }
683
684 void FrameLoaderClient::willChangeTitle(DocumentLoader*)
685 {
686     notImplemented();
687 }
688
689 void FrameLoaderClient::didChangeTitle(DocumentLoader *l)
690 {
691     setTitle(l->title(), l->url());
692 }
693
694 bool FrameLoaderClient::canHandleRequest(const ResourceRequest&) const
695 {
696     notImplemented();
697     return true;
698 }
699
700 bool FrameLoaderClient::canShowMIMEType(const String& type) const
701 {
702     return MIMETypeRegistry::isSupportedImageMIMEType(type) || MIMETypeRegistry::isSupportedNonImageMIMEType(type) ||
703         PluginDatabase::installedPlugins()->isMIMETypeRegistered(type);
704 }
705
706 bool FrameLoaderClient::representationExistsForURLScheme(const String&) const
707 {
708     notImplemented();
709     return false;
710 }
711
712 String FrameLoaderClient::generatedMIMETypeForURLScheme(const String&) const
713 {
714     notImplemented();
715     return String();
716 }
717
718 void FrameLoaderClient::finishedLoading(DocumentLoader* documentLoader)
719 {
720     if (!m_pluginView)
721         committedLoad(documentLoader, 0, 0);
722     else {
723         m_pluginView->didFinishLoading();
724         m_pluginView = 0;
725         m_hasSentResponseToPlugin = false;
726     }
727 }
728
729
730 void FrameLoaderClient::provisionalLoadStarted()
731 {
732     notImplemented();
733 }
734
735 void FrameLoaderClient::didFinishLoad() {
736     notImplemented();
737 }
738
739 void FrameLoaderClient::prepareForDataSourceReplacement() { notImplemented(); }
740
741 void FrameLoaderClient::setTitle(const String& title, const KURL& url)
742 {
743     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(m_frame);
744     g_free(frameData->title);
745     frameData->title = g_strdup(title.utf8().data());
746 }
747
748 void FrameLoaderClient::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int lengthReceived)
749 {
750     notImplemented();
751 }
752
753 void FrameLoaderClient::dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier)
754 {
755     notImplemented();
756 }
757
758 void FrameLoaderClient::dispatchDidFailLoading(DocumentLoader*, unsigned long identifier, const ResourceError&)
759 {
760     notImplemented();
761 }
762
763 bool FrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length)
764 {
765     notImplemented();
766     return false;
767 }
768
769 void FrameLoaderClient::dispatchDidFailProvisionalLoad(const ResourceError&)
770 {
771     g_signal_emit_by_name(m_frame, "load-done", false);
772 }
773
774 void FrameLoaderClient::dispatchDidFailLoad(const ResourceError&)
775 {
776     g_signal_emit_by_name(m_frame, "load-done", false);
777 }
778
779 void FrameLoaderClient::download(ResourceHandle* handle, const ResourceRequest& request, const ResourceRequest&, const ResourceResponse&)
780 {
781     // FIXME: We could reuse the same handle here, but when I tried
782     // implementing that the main load would fail and stop, so I have
783     // simplified this case for now.
784     handle->cancel();
785     startDownload(request);
786 }
787
788 ResourceError FrameLoaderClient::cancelledError(const ResourceRequest&)
789 {
790     notImplemented();
791     ResourceError error("", 0, "", "");
792     error.setIsCancellation(true);
793     return error;
794 }
795
796 ResourceError FrameLoaderClient::blockedError(const ResourceRequest&)
797 {
798     notImplemented();
799     return ResourceError("", 0, "", "");
800 }
801
802 ResourceError FrameLoaderClient::cannotShowURLError(const ResourceRequest&)
803 {
804     notImplemented();
805     return ResourceError("", 0, "", "");
806 }
807
808 ResourceError FrameLoaderClient::interruptForPolicyChangeError(const ResourceRequest&)
809 {
810     notImplemented();
811     return ResourceError("", 0, "", "");
812 }
813
814 ResourceError FrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse&)
815 {
816     notImplemented();
817     return ResourceError("", 0, "", "");
818 }
819
820 ResourceError FrameLoaderClient::fileDoesNotExistError(const ResourceResponse&)
821 {
822     notImplemented();
823     return ResourceError("", 0, "", "");
824 }
825
826 ResourceError FrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse&)
827 {
828     notImplemented();
829     return ResourceError("", 0, "", "");
830 }
831
832 bool FrameLoaderClient::shouldFallBack(const ResourceError&)
833 {
834     notImplemented();
835     return false;
836 }
837
838 bool FrameLoaderClient::canCachePage() const
839 {
840     return true;
841 }
842
843 Frame* FrameLoaderClient::dispatchCreatePage()
844 {
845     WebKitWebView* webView = getViewFromFrame(m_frame);
846     WebKitWebView* newWebView = 0;
847
848     g_signal_emit_by_name(webView, "create-web-view", m_frame, &newWebView);
849
850     if (!newWebView)
851         return 0;
852
853     WebKitWebViewPrivate* privateData = WEBKIT_WEB_VIEW_GET_PRIVATE(newWebView);
854     return core(privateData->mainFrame);
855 }
856
857 void FrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&)
858 {
859     notImplemented();
860 }
861
862 void FrameLoaderClient::setMainDocumentError(DocumentLoader*, const ResourceError& error)
863 {
864     if (m_pluginView) {
865         m_pluginView->didFail(error);
866         m_pluginView = 0;
867         m_hasSentResponseToPlugin = false;
868     }
869 }
870
871 void FrameLoaderClient::startDownload(const ResourceRequest& request)
872 {
873     WebKitNetworkRequest* networkRequest = webkit_network_request_new(request.url().string().utf8().data());
874     WebKitDownload* download = webkit_download_new(networkRequest);
875     g_object_unref(networkRequest);
876
877     WebKitWebView* view = getViewFromFrame(m_frame);
878     gboolean handled;
879     g_signal_emit_by_name(view, "download-requested", download, &handled);
880
881     if (!handled) {
882         webkit_download_cancel(download);
883         g_object_unref(download);
884         return;
885     }
886
887     webkit_download_start(download);
888 }
889
890 void FrameLoaderClient::updateGlobalHistory()
891 {
892     notImplemented();
893 }
894
895 void FrameLoaderClient::updateGlobalHistoryRedirectLinks()
896 {
897     notImplemented();
898 }
899
900 void FrameLoaderClient::savePlatformDataToCachedFrame(CachedFrame*)
901 {
902 }
903
904 void FrameLoaderClient::transitionToCommittedFromCachedFrame(CachedFrame*)
905 {
906 }
907
908 void FrameLoaderClient::transitionToCommittedForNewPage()
909 {
910     WebKitWebView* containingWindow = getViewFromFrame(m_frame);
911     IntSize size = IntSize(GTK_WIDGET(containingWindow)->allocation.width,
912                            GTK_WIDGET(containingWindow)->allocation.height);
913     bool transparent = webkit_web_view_get_transparent(containingWindow);
914     Color backgroundColor = transparent ? WebCore::Color::transparent : WebCore::Color::white;
915     Frame* frame = core(m_frame);
916     ASSERT(frame);
917
918     frame->createView(size, backgroundColor, transparent, IntSize(), false);
919
920     // We need to do further manipulation on the FrameView if it was the mainFrame
921     if (frame != frame->page()->mainFrame())
922         return;
923
924     WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(containingWindow);
925     frame->view()->setGtkAdjustments(priv->horizontalAdjustment, priv->verticalAdjustment);
926 }
927
928 }