Remove an unneeded argument from FrameLoaderClient::download
[WebKit-https.git] / Source / WebKit / efl / WebCoreSupport / FrameLoaderClientEfl.cpp
1 /*
2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
3  * Copyright (C) 2006, 2011 Apple Inc. All rights reserved.
4  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
5  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
6  * Copyright (C) 2008 Holger Hans Peter Freyther
7  * Copyright (C) 2008 Kenneth Rohde Christiansen
8  * Copyright (C) 2009-2010 ProFUSION embedded systems
9  * Copyright (C) 2009-2010 Samsung Electronics
10  *
11  * All rights reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  *
22  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
23  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
26  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
30  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #include "config.h"
36 #include "FrameLoaderClientEfl.h"
37
38 #include "APICast.h"
39 #include "DocumentLoader.h"
40 #include "EWebKit.h"
41 #include "FormState.h"
42 #include "FrameLoader.h"
43 #include "FrameNetworkingContextEfl.h"
44 #include "FrameTree.h"
45 #include "FrameView.h"
46 #include "HTMLFormElement.h"
47 #include "MIMETypeRegistry.h"
48 #include "NotImplemented.h"
49 #include "Page.h"
50 #include "PluginDatabase.h"
51 #include "ProgressTracker.h"
52 #include "RenderPart.h"
53 #include "ResourceRequest.h"
54 #include "WebKitVersion.h"
55 #include "ewk_private.h"
56 #include <wtf/text/CString.h>
57 #include <wtf/text/StringConcatenate.h>
58
59 #include <Ecore_Evas.h>
60
61 using namespace WebCore;
62
63 namespace WebCore {
64
65 FrameLoaderClientEfl::FrameLoaderClientEfl(Evas_Object* view)
66     : m_view(view)
67     , m_frame(0)
68     , m_userAgent("")
69     , m_customUserAgent("")
70     , m_pluginView(0)
71     , m_hasSentResponseToPlugin(false)
72     , m_hasRepresentation(false)
73 {
74 }
75
76 static String composeUserAgent()
77 {
78     return String(ewk_settings_default_user_agent_get());
79 }
80
81 void FrameLoaderClientEfl::setCustomUserAgent(const String& agent)
82 {
83     m_customUserAgent = agent;
84 }
85
86 const String& FrameLoaderClientEfl::customUserAgent() const
87 {
88     return m_customUserAgent;
89 }
90
91 String FrameLoaderClientEfl::userAgent(const KURL&)
92 {
93     if (!m_customUserAgent.isEmpty())
94         return m_customUserAgent;
95
96     if (m_userAgent.isEmpty())
97         m_userAgent = composeUserAgent();
98     return m_userAgent;
99 }
100
101 void FrameLoaderClientEfl::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
102 {
103     Frame* f = EWKPrivate::coreFrame(m_frame);
104     ASSERT(f);
105     (f->loader()->policyChecker()->*function)(action);
106 }
107
108 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientEfl::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
109 {
110     RefPtr<DocumentLoader> loader = DocumentLoader::create(request, substituteData);
111     if (substituteData.isValid())
112         loader->setDeferMainResourceDataLoad(false);
113     return loader.release();
114 }
115
116 void FrameLoaderClientEfl::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState>)
117 {
118     // FIXME: This is surely too simple
119     ASSERT(function);
120     callPolicyFunction(function, PolicyUse);
121 }
122
123 void FrameLoaderClientEfl::committedLoad(DocumentLoader* loader, const char* data, int length)
124 {
125     if (!m_pluginView)
126         loader->commitData(data, length);
127
128     // We re-check here as the plugin can have been created
129     if (m_pluginView) {
130         if (!m_hasSentResponseToPlugin) {
131             m_pluginView->didReceiveResponse(loader->response());
132             m_hasSentResponseToPlugin = true;
133         }
134         m_pluginView->didReceiveData(data, length);
135     }
136 }
137
138 void FrameLoaderClientEfl::dispatchDidReplaceStateWithinPage()
139 {
140     notImplemented();
141 }
142
143 void FrameLoaderClientEfl::dispatchDidPushStateWithinPage()
144 {
145     notImplemented();
146 }
147
148 void FrameLoaderClientEfl::dispatchDidPopStateWithinPage()
149 {
150     notImplemented();
151 }
152
153 void FrameLoaderClientEfl::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
154 {
155     notImplemented();
156 }
157
158 void FrameLoaderClientEfl::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
159 {
160     notImplemented();
161 }
162
163 void FrameLoaderClientEfl::dispatchWillSendRequest(DocumentLoader* loader, unsigned long identifier, ResourceRequest& coreRequest, const ResourceResponse& coreResponse)
164 {
165     CString url = coreRequest.url().string().utf8();
166     DBG("Resource url=%s", url.data());
167
168     Ewk_Frame_Resource_Request request = { 0, identifier };
169     Ewk_Frame_Resource_Request orig = request; /* Initialize const fields. */
170
171     orig.url = request.url = url.data();
172
173     ewk_frame_request_will_send(m_frame, &request);
174
175     if (request.url != orig.url) {
176         coreRequest.setURL(KURL(KURL(), request.url));
177
178         // Calling client might have changed our url pointer.
179         // Free the new allocated string.
180         free(const_cast<char*>(request.url));
181     }
182 }
183
184 bool FrameLoaderClientEfl::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
185 {
186     notImplemented();
187     return false;
188 }
189
190 void FrameLoaderClientEfl::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest& coreRequest)
191 {
192     CString url = coreRequest.url().string().utf8();
193     DBG("Resource url=%s", url.data());
194
195     Ewk_Frame_Resource_Request request = { 0, identifier };
196     ewk_frame_request_assign_identifier(m_frame, &request);
197 }
198
199 void FrameLoaderClientEfl::postProgressStartedNotification()
200 {
201     ewk_frame_load_started(m_frame);
202     postProgressEstimateChangedNotification();
203 }
204
205 void FrameLoaderClientEfl::postProgressEstimateChangedNotification()
206 {
207     ewk_frame_load_progress_changed(m_frame);
208 }
209
210 void FrameLoaderClientEfl::postProgressFinishedNotification()
211 {
212     if (m_loadError.isNull())
213         ewk_frame_load_finished(m_frame, 0, 0, 0, 0, 0);
214     else {
215         ewk_frame_load_finished(m_frame,
216                                 m_loadError.domain().utf8().data(),
217                                 m_loadError.errorCode(),
218                                 m_loadError.isCancellation(),
219                                 m_loadError.localizedDescription().utf8().data(),
220                                 m_loadError.failingURL().utf8().data());
221     }
222 }
223
224 void FrameLoaderClientEfl::frameLoaderDestroyed()
225 {
226     if (m_frame)
227         ewk_frame_core_gone(m_frame);
228     m_frame = 0;
229
230     delete this;
231 }
232
233 void FrameLoaderClientEfl::dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse& response)
234 {
235     m_response = response;
236 }
237
238 void FrameLoaderClientEfl::dispatchDecidePolicyForResponse(FramePolicyFunction function, const ResourceResponse& response, const ResourceRequest& resourceRequest)
239 {
240     // we need to call directly here (currently callPolicyFunction does that!)
241     ASSERT(function);
242
243     if (resourceRequest.isNull()) {
244         callPolicyFunction(function, PolicyIgnore);
245         return;
246     }
247
248     if (canShowMIMEType(response.mimeType()))
249         callPolicyFunction(function, PolicyUse);
250     else
251         callPolicyFunction(function, PolicyDownload);
252 }
253
254 void FrameLoaderClientEfl::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>, const String&)
255 {
256     ASSERT(function);
257     ASSERT(m_frame);
258
259     if (resourceRequest.isNull()) {
260         callPolicyFunction(function, PolicyIgnore);
261         return;
262     }
263
264     // if not acceptNavigationRequest - look at Qt -> PolicyIgnore;
265     // FIXME: do proper check and only reset forms when on PolicyIgnore
266     Frame* f = EWKPrivate::coreFrame(m_frame);
267     f->loader()->resetMultipleFormSubmissionProtection();
268     callPolicyFunction(function, PolicyUse);
269 }
270
271 void FrameLoaderClientEfl::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>)
272 {
273     ASSERT(function);
274     ASSERT(m_frame);
275
276     if (resourceRequest.isNull()) {
277         callPolicyFunction(function, PolicyIgnore);
278         return;
279     }
280
281     // if not acceptNavigationRequest - look at Qt -> PolicyIgnore;
282     // FIXME: do proper check and only reset forms when on PolicyIgnore
283     char* url = strdup(resourceRequest.url().string().utf8().data());
284     Ewk_Frame_Resource_Request request = { url, 0 };
285     bool ret = ewk_view_navigation_policy_decision(m_view, &request);
286     free(url);
287
288     PolicyAction policy;
289     if (!ret)
290         policy = PolicyIgnore;
291     else {
292         if (action.type() == NavigationTypeFormSubmitted || action.type() == NavigationTypeFormResubmitted) {
293             Frame* f = EWKPrivate::coreFrame(m_frame);
294             f->loader()->resetMultipleFormSubmissionProtection();
295         }
296         policy = PolicyUse;
297     }
298     callPolicyFunction(function, policy);
299 }
300
301 PassRefPtr<Widget> FrameLoaderClientEfl::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
302 {
303     ASSERT(m_frame);
304     ASSERT(m_view);
305
306     return ewk_view_plugin_create(m_view, m_frame, pluginSize,
307                                   element, url, paramNames, paramValues,
308                                   mimeType, loadManually);
309 }
310
311 PassRefPtr<Frame> FrameLoaderClientEfl::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
312 {
313     ASSERT(m_frame);
314     ASSERT(m_view);
315
316     return ewk_view_frame_create(m_view, m_frame, name, ownerElement, url, referrer);
317 }
318
319 void FrameLoaderClientEfl::didTransferChildFrameToNewDocument(Page*)
320 {
321     ASSERT(m_frame);
322
323     Frame* currentFrame = EWKPrivate::coreFrame(m_frame);
324     Evas_Object* currentView = ewk_frame_view_get(m_frame);
325     Frame* parentFrame = currentFrame->tree()->parent();
326
327     FrameLoaderClientEfl* client = static_cast<FrameLoaderClientEfl*>(parentFrame->loader()->client());
328     Evas_Object* clientFrame = client ? client->webFrame() : 0;
329     Evas_Object* clientView = ewk_frame_view_get(clientFrame);
330
331     if (currentView != clientView) {
332         ewk_frame_view_set(m_frame, clientView);
333         m_view = clientView;
334     }
335
336     ASSERT(ewk_view_core_page_get(ewk_frame_view_get(m_frame)) == currentFrame->page());
337 }
338
339 void FrameLoaderClientEfl::transferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*)
340 {
341 }
342
343 void FrameLoaderClientEfl::redirectDataToPlugin(Widget* pluginWidget)
344 {
345     ASSERT(!m_pluginView);
346     m_pluginView = static_cast<PluginView*>(pluginWidget);
347     m_hasSentResponseToPlugin = false;
348 }
349
350 PassRefPtr<Widget> FrameLoaderClientEfl::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL& baseURL,
351                                                                 const Vector<String>& paramNames, const Vector<String>& paramValues)
352 {
353     notImplemented();
354     return 0;
355 }
356
357 ObjectContentType FrameLoaderClientEfl::objectContentType(const KURL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
358 {
359     // FIXME: once plugin support is enabled, this method needs to correctly handle the 'shouldPreferPlugInsForImages' flag. See
360     // WebCore::FrameLoader::defaultObjectContentType() for an example.
361     UNUSED_PARAM(shouldPreferPlugInsForImages);
362
363     if (url.isEmpty() && mimeType.isEmpty())
364         return ObjectContentNone;
365
366     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
367     String type = mimeType;
368     if (type.isEmpty())
369         type = MIMETypeRegistry::getMIMETypeForExtension(url.path().substring(url.path().reverseFind('.') + 1));
370
371     if (type.isEmpty())
372         return ObjectContentFrame;
373
374     if (MIMETypeRegistry::isSupportedImageMIMEType(type))
375         return ObjectContentImage;
376
377 #if 0 // PluginDatabase is disabled until we have Plugin system done.
378     if (PluginDatabase::installedPlugins()->isMIMETypeRegistered(mimeType))
379         return ObjectContentNetscapePlugin;
380 #endif
381
382     if (MIMETypeRegistry::isSupportedNonImageMIMEType(type))
383         return ObjectContentFrame;
384
385     if (url.protocol() == "about")
386         return ObjectContentFrame;
387
388     return ObjectContentNone;
389 }
390
391 String FrameLoaderClientEfl::overrideMediaType() const
392 {
393     notImplemented();
394     return String();
395 }
396
397 void FrameLoaderClientEfl::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
398 {
399     if (world != mainThreadNormalWorld())
400         return;
401
402     Frame* coreFrame = EWKPrivate::coreFrame(m_frame);
403     ASSERT(coreFrame);
404
405     Settings* settings = coreFrame->settings();
406     if (!settings || !settings->isScriptEnabled())
407         return;
408
409     Ewk_Window_Object_Cleared_Event event;
410     event.context = toGlobalRef(coreFrame->script()->globalObject(mainThreadNormalWorld())->globalExec());
411     event.windowObject = toRef(coreFrame->script()->globalObject(mainThreadNormalWorld()));
412     event.frame = m_frame;
413
414     evas_object_smart_callback_call(m_view, "window,object,cleared", &event);
415
416 #if ENABLE(NETSCAPE_PLUGIN_API)
417     ewk_view_js_window_object_clear(m_view, m_frame);
418 #endif
419 }
420
421 void FrameLoaderClientEfl::documentElementAvailable()
422 {
423     return;
424 }
425
426 void FrameLoaderClientEfl::didPerformFirstNavigation() const
427 {
428     ewk_frame_did_perform_first_navigation(m_frame);
429 }
430
431 void FrameLoaderClientEfl::registerForIconNotification(bool)
432 {
433     notImplemented();
434 }
435
436 void FrameLoaderClientEfl::setMainFrameDocumentReady(bool)
437 {
438     // this is only interesting once we provide an external API for the DOM
439 }
440
441 bool FrameLoaderClientEfl::hasWebView() const
442 {
443     if (!m_view)
444         return false;
445
446     return true;
447 }
448
449 bool FrameLoaderClientEfl::hasFrameView() const
450 {
451     notImplemented();
452     return true;
453 }
454
455 void FrameLoaderClientEfl::dispatchDidFinishLoad()
456 {
457     m_loadError = ResourceError(); /* clears previous error */
458 }
459
460 void FrameLoaderClientEfl::frameLoadCompleted()
461 {
462     // Note: Can be called multiple times.
463 }
464
465 void FrameLoaderClientEfl::saveViewStateToItem(HistoryItem* item)
466 {
467     ewk_frame_view_state_save(m_frame, item);
468 }
469
470 void FrameLoaderClientEfl::restoreViewState()
471 {
472     ASSERT(m_frame);
473     ASSERT(m_view);
474
475     ewk_view_restore_state(m_view, m_frame);
476 }
477
478 void FrameLoaderClientEfl::updateGlobalHistoryRedirectLinks()
479 {
480 }
481
482 bool FrameLoaderClientEfl::shouldGoToHistoryItem(HistoryItem* item) const
483 {
484     // FIXME: This is a very simple implementation. More sophisticated
485     // implementation would delegate the decision to a PolicyDelegate.
486     // See mac implementation for example.
487     return item;
488 }
489
490 bool FrameLoaderClientEfl::shouldStopLoadingForHistoryItem(HistoryItem* item) const
491 {
492     return true;
493 }
494
495 void FrameLoaderClientEfl::didDisplayInsecureContent()
496 {
497     notImplemented();
498 }
499
500 void FrameLoaderClientEfl::didRunInsecureContent(SecurityOrigin*, const KURL&)
501 {
502     notImplemented();
503 }
504
505 void FrameLoaderClientEfl::didDetectXSS(const KURL&, bool)
506 {
507     notImplemented();
508 }
509
510 void FrameLoaderClientEfl::makeRepresentation(DocumentLoader*)
511 {
512     m_hasRepresentation = true;
513 }
514
515 void FrameLoaderClientEfl::forceLayout()
516 {
517     ewk_frame_force_layout(m_frame);
518 }
519
520 void FrameLoaderClientEfl::forceLayoutForNonHTML()
521 {
522 }
523
524 void FrameLoaderClientEfl::setCopiesOnScroll()
525 {
526     // apparently mac specific (Qt comment)
527 }
528
529 void FrameLoaderClientEfl::detachedFromParent2()
530 {
531 }
532
533 void FrameLoaderClientEfl::detachedFromParent3()
534 {
535 }
536
537 void FrameLoaderClientEfl::loadedFromCachedPage()
538 {
539     notImplemented();
540 }
541
542 void FrameLoaderClientEfl::dispatchDidHandleOnloadEvents()
543 {
544     notImplemented();
545 }
546
547 void FrameLoaderClientEfl::dispatchDidReceiveServerRedirectForProvisionalLoad()
548 {
549     notImplemented();
550 }
551
552 void FrameLoaderClientEfl::dispatchDidCancelClientRedirect()
553 {
554     notImplemented();
555 }
556
557 void FrameLoaderClientEfl::dispatchWillPerformClientRedirect(const KURL&, double, double)
558 {
559     notImplemented();
560 }
561
562 void FrameLoaderClientEfl::dispatchDidChangeLocationWithinPage()
563 {
564     ewk_frame_uri_changed(m_frame);
565
566     if (ewk_view_frame_main_get(m_view) != m_frame)
567         return;
568     ewk_view_uri_changed(m_view);
569 }
570
571 void FrameLoaderClientEfl::dispatchWillClose()
572 {
573     notImplemented();
574 }
575
576 void FrameLoaderClientEfl::dispatchDidReceiveIcon()
577 {
578     /* report received favicon only for main frame. */
579     if (ewk_view_frame_main_get(m_view) != m_frame)
580         return;
581
582     ewk_view_frame_main_icon_received(m_view);
583 }
584
585 void FrameLoaderClientEfl::dispatchDidStartProvisionalLoad()
586 {
587     ewk_frame_load_provisional(m_frame);
588     if (ewk_view_frame_main_get(m_view) == m_frame)
589         ewk_view_load_provisional(m_view);
590 }
591
592 void FrameLoaderClientEfl::dispatchDidReceiveTitle(const StringWithDirection& title)
593 {
594     // FIXME: use direction of title.
595     CString cs = title.string().utf8();
596     ewk_frame_title_set(m_frame, cs.data());
597
598     if (ewk_view_frame_main_get(m_view) != m_frame)
599         return;
600     ewk_view_title_set(m_view, cs.data());
601 }
602
603 void FrameLoaderClientEfl::dispatchDidChangeIcons(WebCore::IconType)
604 {
605     notImplemented();
606 }
607
608 void FrameLoaderClientEfl::dispatchDidCommitLoad()
609 {
610     ewk_frame_uri_changed(m_frame);
611     if (ewk_view_frame_main_get(m_view) != m_frame)
612         return;
613     ewk_view_title_set(m_view, 0);
614     ewk_view_uri_changed(m_view);
615 }
616
617 void FrameLoaderClientEfl::dispatchDidFinishDocumentLoad()
618 {
619     ewk_frame_load_document_finished(m_frame);
620 }
621
622 void FrameLoaderClientEfl::dispatchDidFirstLayout()
623 {
624     ewk_frame_load_firstlayout_finished(m_frame);
625 }
626
627 void FrameLoaderClientEfl::dispatchDidFirstVisuallyNonEmptyLayout()
628 {
629     ewk_frame_load_firstlayout_nonempty_finished(m_frame);
630 }
631
632 void FrameLoaderClientEfl::dispatchShow()
633 {
634     ewk_view_load_show(m_view);
635 }
636
637 void FrameLoaderClientEfl::cancelPolicyCheck()
638 {
639     notImplemented();
640 }
641
642 void FrameLoaderClientEfl::dispatchDidLoadMainResource(DocumentLoader*)
643 {
644     notImplemented();
645 }
646
647 void FrameLoaderClientEfl::revertToProvisionalState(DocumentLoader*)
648 {
649     m_hasRepresentation = true;
650 }
651
652 void FrameLoaderClientEfl::willChangeTitle(DocumentLoader*)
653 {
654     // no need for, dispatchDidReceiveTitle is the right callback
655 }
656
657 void FrameLoaderClientEfl::didChangeTitle(DocumentLoader*)
658 {
659     // no need for, dispatchDidReceiveTitle is the right callback
660 }
661
662 bool FrameLoaderClientEfl::canHandleRequest(const ResourceRequest&) const
663 {
664     notImplemented();
665     return true;
666 }
667
668 bool FrameLoaderClientEfl::canShowMIMETypeAsHTML(const String& MIMEType) const
669 {
670     notImplemented();
671     return false;
672 }
673
674 bool FrameLoaderClientEfl::canShowMIMEType(const String& MIMEType) const
675 {
676     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
677         return true;
678
679     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
680         return true;
681
682 #if 0 // PluginDatabase is disabled until we have Plugin system done.
683     if (PluginDatabase::installedPlugins()->isMIMETypeRegistered(MIMEType))
684         return true;
685 #endif
686
687     return false;
688 }
689
690 bool FrameLoaderClientEfl::representationExistsForURLScheme(const String&) const
691 {
692     return false;
693 }
694
695 String FrameLoaderClientEfl::generatedMIMETypeForURLScheme(const String&) const
696 {
697     notImplemented();
698     return String();
699 }
700
701 void FrameLoaderClientEfl::finishedLoading(DocumentLoader* documentLoader)
702 {
703     if (!m_pluginView) {
704         if (m_hasRepresentation)
705             documentLoader->writer()->setEncoding("", false);
706         return;
707     }
708     m_pluginView->didFinishLoading();
709     m_pluginView = 0;
710     m_hasSentResponseToPlugin = false;
711 }
712
713
714 void FrameLoaderClientEfl::provisionalLoadStarted()
715 {
716     notImplemented();
717 }
718
719 void FrameLoaderClientEfl::didFinishLoad()
720 {
721     notImplemented();
722 }
723
724 void FrameLoaderClientEfl::prepareForDataSourceReplacement()
725 {
726     notImplemented();
727 }
728
729 void FrameLoaderClientEfl::setTitle(const StringWithDirection& title, const KURL& url)
730 {
731     // no need for, dispatchDidReceiveTitle is the right callback
732 }
733
734 void FrameLoaderClientEfl::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int dataLength)
735 {
736     notImplemented();
737 }
738
739 void FrameLoaderClientEfl::dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier)
740 {
741     notImplemented();
742 }
743
744 void FrameLoaderClientEfl::dispatchDidFailLoading(DocumentLoader* loader, unsigned long identifier, const ResourceError& err)
745 {
746     notImplemented();
747 }
748
749 bool FrameLoaderClientEfl::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length)
750 {
751     notImplemented();
752     return false;
753 }
754
755 void FrameLoaderClientEfl::dispatchDidLoadResourceByXMLHttpRequest(unsigned long, const String&)
756 {
757     notImplemented();
758 }
759
760 void FrameLoaderClientEfl::dispatchDidFailProvisionalLoad(const ResourceError& err)
761 {
762     dispatchDidFailLoad(err);
763 }
764
765 void FrameLoaderClientEfl::dispatchDidFailLoad(const ResourceError& err)
766 {
767     if (!shouldFallBack(err))
768         return;
769
770     m_loadError = err;
771     ewk_frame_load_error(m_frame,
772                          m_loadError.domain().utf8().data(),
773                          m_loadError.errorCode(), m_loadError.isCancellation(),
774                          m_loadError.localizedDescription().utf8().data(),
775                          m_loadError.failingURL().utf8().data());
776 }
777
778 void FrameLoaderClientEfl::download(ResourceHandle*, const ResourceRequest& request, const ResourceResponse&)
779 {
780     if (!m_view)
781         return;
782
783     CString url = request.url().string().utf8();
784     Ewk_Download download;
785
786     download.url = url.data();
787     ewk_view_download_request(m_view, &download);
788 }
789
790 // copied from WebKit/Misc/WebKitErrors[Private].h
791 enum {
792     WebKitErrorCannotShowMIMEType = 100,
793     WebKitErrorCannotShowURL = 101,
794     WebKitErrorFrameLoadInterruptedByPolicyChange = 102,
795     WebKitErrorCannotUseRestrictedPort = 103,
796     WebKitErrorCannotFindPlugIn = 200,
797     WebKitErrorCannotLoadPlugIn = 201,
798     WebKitErrorJavaUnavailable = 202,
799 };
800
801 ResourceError FrameLoaderClientEfl::cancelledError(const ResourceRequest& request)
802 {
803     ResourceError error("Error", -999, request.url().string(),
804                         "Request cancelled");
805     error.setIsCancellation(true);
806     return error;
807 }
808
809 ResourceError FrameLoaderClientEfl::blockedError(const ResourceRequest& request)
810 {
811     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().string(),
812                          "Request blocked");
813 }
814
815 ResourceError FrameLoaderClientEfl::cannotShowURLError(const ResourceRequest& request)
816 {
817     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
818                          "Cannot show URL");
819 }
820
821 ResourceError FrameLoaderClientEfl::interruptedForPolicyChangeError(const ResourceRequest& request)
822 {
823     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange,
824                          request.url().string(), "Frame load interrupted by policy change");
825 }
826
827 ResourceError FrameLoaderClientEfl::cannotShowMIMETypeError(const ResourceResponse& response)
828 {
829     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
830                          "Cannot show mimetype");
831 }
832
833 ResourceError FrameLoaderClientEfl::fileDoesNotExistError(const ResourceResponse& response)
834 {
835     return ResourceError("Error", -998 /* ### */, response.url().string(),
836                          "File does not exist");
837 }
838
839 ResourceError FrameLoaderClientEfl::pluginWillHandleLoadError(const ResourceResponse&)
840 {
841     notImplemented();
842     return ResourceError("Error", 0, "", "");
843 }
844
845 bool FrameLoaderClientEfl::shouldFallBack(const ResourceError& error)
846 {
847     return !(error.isCancellation() || (error.errorCode() == WebKitErrorFrameLoadInterruptedByPolicyChange));
848 }
849
850 bool FrameLoaderClientEfl::canCachePage() const
851 {
852     return false;
853 }
854
855 Frame* FrameLoaderClientEfl::dispatchCreatePage(const NavigationAction&)
856 {
857     if (!m_view)
858         return 0;
859
860     Evas_Object* newView = ewk_view_window_create(m_view, EINA_FALSE, 0);
861     Evas_Object* mainFrame;
862     if (!newView)
863         mainFrame = m_frame;
864     else
865         mainFrame = ewk_view_frame_main_get(newView);
866
867     return EWKPrivate::coreFrame(mainFrame);
868 }
869
870 void FrameLoaderClientEfl::dispatchUnableToImplementPolicy(const ResourceError&)
871 {
872     notImplemented();
873 }
874
875 void FrameLoaderClientEfl::setMainDocumentError(DocumentLoader* loader, const ResourceError& error)
876 {
877     if (!m_pluginView)
878         return;
879     m_pluginView->didFail(error);
880     m_pluginView = 0;
881     m_hasSentResponseToPlugin = false;
882 }
883
884 void FrameLoaderClientEfl::startDownload(const ResourceRequest& request, const String& /* suggestedName */)
885 {
886     if (!m_view)
887         return;
888
889     CString url = request.url().string().utf8();
890     Ewk_Download download;
891
892     download.url = url.data();
893     ewk_view_download_request(m_view, &download);
894 }
895
896 void FrameLoaderClientEfl::updateGlobalHistory()
897 {
898     notImplemented();
899 }
900
901 void FrameLoaderClientEfl::savePlatformDataToCachedFrame(CachedFrame*)
902 {
903     notImplemented();
904 }
905
906 void FrameLoaderClientEfl::transitionToCommittedFromCachedFrame(CachedFrame*)
907 {
908 }
909
910 void FrameLoaderClientEfl::transitionToCommittedForNewPage()
911 {
912     ASSERT(m_frame);
913     ASSERT(m_view);
914
915     ewk_frame_view_create_for_view(m_frame, m_view);
916
917     if (m_frame == ewk_view_frame_main_get(m_view))
918         ewk_view_frame_main_cleared(m_view);
919 }
920
921 void FrameLoaderClientEfl::didSaveToPageCache()
922 {
923 }
924
925 void FrameLoaderClientEfl::didRestoreFromPageCache()
926 {
927 }
928
929 void FrameLoaderClientEfl::dispatchDidBecomeFrameset(bool)
930 {
931 }
932
933 PassRefPtr<FrameNetworkingContext> FrameLoaderClientEfl::createNetworkingContext()
934 {
935     return FrameNetworkingContextEfl::create(EWKPrivate::coreFrame(m_frame));
936 }
937
938 }