37c738c22671d530630493dec8d045cd9c202c82
[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 "FormState.h"
41 #include "FrameLoader.h"
42 #include "FrameNetworkingContextEfl.h"
43 #include "FrameTree.h"
44 #include "FrameView.h"
45 #include "HTMLFormElement.h"
46 #include "MIMETypeRegistry.h"
47 #include "NotImplemented.h"
48 #include "Page.h"
49 #include "PluginDatabase.h"
50 #include "ProgressTracker.h"
51 #include "RenderPart.h"
52 #include "ResourceRequest.h"
53 #include "Settings.h"
54 #include "WebKitVersion.h"
55 #include "ewk_logging.h"
56 #include "ewk_private.h"
57 #include <Ecore_Evas.h>
58 #include <wtf/text/CString.h>
59 #include <wtf/text/StringConcatenate.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* loader, unsigned long, const ResourceResponse& response)
234 {
235 #if USE(SOUP)
236     // Update our knowledge of request soup flags - some are only set
237     // after the request is done.
238     loader->request().setSoupMessageFlags(response.soupMessageFlags());
239 #else
240     UNUSED_PARAM(loader);
241 #endif
242
243     m_response = response;
244 }
245
246 void FrameLoaderClientEfl::dispatchDecidePolicyForResponse(FramePolicyFunction function, const ResourceResponse& response, const ResourceRequest& resourceRequest)
247 {
248     // we need to call directly here (currently callPolicyFunction does that!)
249     ASSERT(function);
250
251     if (resourceRequest.isNull()) {
252         callPolicyFunction(function, PolicyIgnore);
253         return;
254     }
255
256     if (canShowMIMEType(response.mimeType()))
257         callPolicyFunction(function, PolicyUse);
258     else
259         callPolicyFunction(function, PolicyDownload);
260 }
261
262 void FrameLoaderClientEfl::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>, const String&)
263 {
264     ASSERT(function);
265     ASSERT(m_frame);
266
267     if (resourceRequest.isNull()) {
268         callPolicyFunction(function, PolicyIgnore);
269         return;
270     }
271
272     // if not acceptNavigationRequest - look at Qt -> PolicyIgnore;
273     // FIXME: do proper check and only reset forms when on PolicyIgnore
274     Frame* f = EWKPrivate::coreFrame(m_frame);
275     f->loader()->resetMultipleFormSubmissionProtection();
276     callPolicyFunction(function, PolicyUse);
277 }
278
279 void FrameLoaderClientEfl::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>)
280 {
281     ASSERT(function);
282     ASSERT(m_frame);
283
284     if (resourceRequest.isNull()) {
285         callPolicyFunction(function, PolicyIgnore);
286         return;
287     }
288
289     // if not acceptNavigationRequest - look at Qt -> PolicyIgnore;
290     // FIXME: do proper check and only reset forms when on PolicyIgnore
291     char* url = strdup(resourceRequest.url().string().utf8().data());
292     Ewk_Frame_Resource_Request request = { url, 0 };
293     bool ret = ewk_view_navigation_policy_decision(m_view, &request);
294     free(url);
295
296     PolicyAction policy;
297     if (!ret)
298         policy = PolicyIgnore;
299     else {
300         if (action.type() == NavigationTypeFormSubmitted || action.type() == NavigationTypeFormResubmitted) {
301             Frame* f = EWKPrivate::coreFrame(m_frame);
302             f->loader()->resetMultipleFormSubmissionProtection();
303         }
304         policy = PolicyUse;
305     }
306     callPolicyFunction(function, policy);
307 }
308
309 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)
310 {
311     ASSERT(m_frame);
312     ASSERT(m_view);
313
314     return ewk_view_plugin_create(m_view, m_frame, pluginSize,
315                                   element, url, paramNames, paramValues,
316                                   mimeType, loadManually);
317 }
318
319 PassRefPtr<Frame> FrameLoaderClientEfl::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
320 {
321     ASSERT(m_frame);
322     ASSERT(m_view);
323
324     return ewk_view_frame_create(m_view, m_frame, name, ownerElement, url, referrer);
325 }
326
327 void FrameLoaderClientEfl::didTransferChildFrameToNewDocument(Page*)
328 {
329     ASSERT(m_frame);
330
331     Frame* currentFrame = EWKPrivate::coreFrame(m_frame);
332     Evas_Object* currentView = ewk_frame_view_get(m_frame);
333     Frame* parentFrame = currentFrame->tree()->parent();
334
335     FrameLoaderClientEfl* client = static_cast<FrameLoaderClientEfl*>(parentFrame->loader()->client());
336     Evas_Object* clientFrame = client ? client->webFrame() : 0;
337     Evas_Object* clientView = ewk_frame_view_get(clientFrame);
338
339     if (currentView != clientView) {
340         ewk_frame_view_set(m_frame, clientView);
341         m_view = clientView;
342     }
343
344     ASSERT(ewk_view_core_page_get(ewk_frame_view_get(m_frame)) == currentFrame->page());
345 }
346
347 void FrameLoaderClientEfl::transferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*)
348 {
349 }
350
351 void FrameLoaderClientEfl::redirectDataToPlugin(Widget* pluginWidget)
352 {
353     ASSERT(!m_pluginView);
354     m_pluginView = static_cast<PluginView*>(pluginWidget);
355     m_hasSentResponseToPlugin = false;
356 }
357
358 PassRefPtr<Widget> FrameLoaderClientEfl::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL& baseURL,
359                                                                 const Vector<String>& paramNames, const Vector<String>& paramValues)
360 {
361     notImplemented();
362     return 0;
363 }
364
365 ObjectContentType FrameLoaderClientEfl::objectContentType(const KURL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
366 {
367     // FIXME: once plugin support is enabled, this method needs to correctly handle the 'shouldPreferPlugInsForImages' flag. See
368     // WebCore::FrameLoader::defaultObjectContentType() for an example.
369     UNUSED_PARAM(shouldPreferPlugInsForImages);
370
371     if (url.isEmpty() && mimeType.isEmpty())
372         return ObjectContentNone;
373
374     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
375     String type = mimeType;
376     if (type.isEmpty())
377         type = MIMETypeRegistry::getMIMETypeForExtension(url.path().substring(url.path().reverseFind('.') + 1));
378
379     if (type.isEmpty())
380         return ObjectContentFrame;
381
382     if (MIMETypeRegistry::isSupportedImageMIMEType(type))
383         return ObjectContentImage;
384
385 #if 0 // PluginDatabase is disabled until we have Plugin system done.
386     if (PluginDatabase::installedPlugins()->isMIMETypeRegistered(mimeType))
387         return ObjectContentNetscapePlugin;
388 #endif
389
390     if (MIMETypeRegistry::isSupportedNonImageMIMEType(type))
391         return ObjectContentFrame;
392
393     if (url.protocol() == "about")
394         return ObjectContentFrame;
395
396     return ObjectContentNone;
397 }
398
399 String FrameLoaderClientEfl::overrideMediaType() const
400 {
401     notImplemented();
402     return String();
403 }
404
405 void FrameLoaderClientEfl::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
406 {
407     if (world != mainThreadNormalWorld())
408         return;
409
410     Frame* coreFrame = EWKPrivate::coreFrame(m_frame);
411     ASSERT(coreFrame);
412
413     Settings* settings = coreFrame->settings();
414     if (!settings || !settings->isScriptEnabled())
415         return;
416
417     Ewk_Window_Object_Cleared_Event event;
418     event.context = toGlobalRef(coreFrame->script()->globalObject(mainThreadNormalWorld())->globalExec());
419     event.windowObject = toRef(coreFrame->script()->globalObject(mainThreadNormalWorld()));
420     event.frame = m_frame;
421
422     evas_object_smart_callback_call(m_view, "window,object,cleared", &event);
423
424 #if ENABLE(NETSCAPE_PLUGIN_API)
425     ewk_view_js_window_object_clear(m_view, m_frame);
426 #endif
427 }
428
429 void FrameLoaderClientEfl::documentElementAvailable()
430 {
431     return;
432 }
433
434 void FrameLoaderClientEfl::didPerformFirstNavigation() const
435 {
436     ewk_frame_did_perform_first_navigation(m_frame);
437 }
438
439 void FrameLoaderClientEfl::registerForIconNotification(bool)
440 {
441     notImplemented();
442 }
443
444 void FrameLoaderClientEfl::setMainFrameDocumentReady(bool)
445 {
446     // this is only interesting once we provide an external API for the DOM
447 }
448
449 bool FrameLoaderClientEfl::hasWebView() const
450 {
451     if (!m_view)
452         return false;
453
454     return true;
455 }
456
457 bool FrameLoaderClientEfl::hasFrameView() const
458 {
459     notImplemented();
460     return true;
461 }
462
463 void FrameLoaderClientEfl::dispatchDidFinishLoad()
464 {
465     m_loadError = ResourceError(); /* clears previous error */
466 }
467
468 void FrameLoaderClientEfl::frameLoadCompleted()
469 {
470     // Note: Can be called multiple times.
471 }
472
473 void FrameLoaderClientEfl::saveViewStateToItem(HistoryItem* item)
474 {
475     ewk_frame_view_state_save(m_frame, item);
476 }
477
478 void FrameLoaderClientEfl::restoreViewState()
479 {
480     ASSERT(m_frame);
481     ASSERT(m_view);
482
483     ewk_view_restore_state(m_view, m_frame);
484 }
485
486 void FrameLoaderClientEfl::updateGlobalHistoryRedirectLinks()
487 {
488 }
489
490 bool FrameLoaderClientEfl::shouldGoToHistoryItem(HistoryItem* item) const
491 {
492     // FIXME: This is a very simple implementation. More sophisticated
493     // implementation would delegate the decision to a PolicyDelegate.
494     // See mac implementation for example.
495     return item;
496 }
497
498 bool FrameLoaderClientEfl::shouldStopLoadingForHistoryItem(HistoryItem* item) const
499 {
500     return true;
501 }
502
503 void FrameLoaderClientEfl::didDisplayInsecureContent()
504 {
505     ewk_frame_mixed_content_displayed_set(m_frame, true);
506 }
507
508 void FrameLoaderClientEfl::didRunInsecureContent(SecurityOrigin*, const KURL&)
509 {
510     ewk_frame_mixed_content_run_set(m_frame, true);
511 }
512
513 void FrameLoaderClientEfl::didDetectXSS(const KURL&, bool)
514 {
515     notImplemented();
516 }
517
518 void FrameLoaderClientEfl::makeRepresentation(DocumentLoader*)
519 {
520     m_hasRepresentation = true;
521 }
522
523 void FrameLoaderClientEfl::forceLayout()
524 {
525     ewk_frame_force_layout(m_frame);
526 }
527
528 void FrameLoaderClientEfl::forceLayoutForNonHTML()
529 {
530 }
531
532 void FrameLoaderClientEfl::setCopiesOnScroll()
533 {
534     // apparently mac specific (Qt comment)
535 }
536
537 void FrameLoaderClientEfl::detachedFromParent2()
538 {
539 }
540
541 void FrameLoaderClientEfl::detachedFromParent3()
542 {
543 }
544
545 void FrameLoaderClientEfl::loadedFromCachedPage()
546 {
547     notImplemented();
548 }
549
550 void FrameLoaderClientEfl::dispatchDidHandleOnloadEvents()
551 {
552     notImplemented();
553 }
554
555 void FrameLoaderClientEfl::dispatchDidReceiveServerRedirectForProvisionalLoad()
556 {
557     notImplemented();
558 }
559
560 void FrameLoaderClientEfl::dispatchDidCancelClientRedirect()
561 {
562     notImplemented();
563 }
564
565 void FrameLoaderClientEfl::dispatchWillPerformClientRedirect(const KURL&, double, double)
566 {
567     notImplemented();
568 }
569
570 void FrameLoaderClientEfl::dispatchDidChangeLocationWithinPage()
571 {
572     ewk_frame_uri_changed(m_frame);
573
574     if (ewk_view_frame_main_get(m_view) != m_frame)
575         return;
576     ewk_view_uri_changed(m_view);
577 }
578
579 void FrameLoaderClientEfl::dispatchWillClose()
580 {
581     notImplemented();
582 }
583
584 void FrameLoaderClientEfl::dispatchDidReceiveIcon()
585 {
586     /* report received favicon only for main frame. */
587     if (ewk_view_frame_main_get(m_view) != m_frame)
588         return;
589
590     ewk_view_frame_main_icon_received(m_view);
591 }
592
593 void FrameLoaderClientEfl::dispatchDidStartProvisionalLoad()
594 {
595     ewk_frame_load_provisional(m_frame);
596     if (ewk_view_frame_main_get(m_view) == m_frame)
597         ewk_view_load_provisional(m_view);
598 }
599
600 void FrameLoaderClientEfl::dispatchDidReceiveTitle(const StringWithDirection& title)
601 {
602     // FIXME: use direction of title.
603     CString cs = title.string().utf8();
604     ewk_frame_title_set(m_frame, cs.data());
605
606     if (ewk_view_frame_main_get(m_view) != m_frame)
607         return;
608     ewk_view_title_set(m_view, cs.data());
609 }
610
611 void FrameLoaderClientEfl::dispatchDidChangeIcons(WebCore::IconType)
612 {
613     notImplemented();
614 }
615
616 void FrameLoaderClientEfl::dispatchDidCommitLoad()
617 {
618     ewk_frame_uri_changed(m_frame);
619     if (ewk_view_frame_main_get(m_view) != m_frame)
620         return;
621     ewk_view_title_set(m_view, 0);
622     ewk_view_uri_changed(m_view);
623 }
624
625 void FrameLoaderClientEfl::dispatchDidFinishDocumentLoad()
626 {
627     ewk_frame_load_document_finished(m_frame);
628 }
629
630 void FrameLoaderClientEfl::dispatchDidFirstLayout()
631 {
632     ewk_frame_load_firstlayout_finished(m_frame);
633 }
634
635 void FrameLoaderClientEfl::dispatchDidFirstVisuallyNonEmptyLayout()
636 {
637     ewk_frame_load_firstlayout_nonempty_finished(m_frame);
638 }
639
640 void FrameLoaderClientEfl::dispatchShow()
641 {
642     ewk_view_load_show(m_view);
643 }
644
645 void FrameLoaderClientEfl::cancelPolicyCheck()
646 {
647     notImplemented();
648 }
649
650 void FrameLoaderClientEfl::dispatchDidLoadMainResource(DocumentLoader*)
651 {
652     notImplemented();
653 }
654
655 void FrameLoaderClientEfl::revertToProvisionalState(DocumentLoader*)
656 {
657     m_hasRepresentation = true;
658 }
659
660 void FrameLoaderClientEfl::willChangeTitle(DocumentLoader*)
661 {
662     // no need for, dispatchDidReceiveTitle is the right callback
663 }
664
665 void FrameLoaderClientEfl::didChangeTitle(DocumentLoader*)
666 {
667     // no need for, dispatchDidReceiveTitle is the right callback
668 }
669
670 bool FrameLoaderClientEfl::canHandleRequest(const ResourceRequest&) const
671 {
672     notImplemented();
673     return true;
674 }
675
676 bool FrameLoaderClientEfl::canShowMIMETypeAsHTML(const String& MIMEType) const
677 {
678     notImplemented();
679     return false;
680 }
681
682 bool FrameLoaderClientEfl::canShowMIMEType(const String& MIMEType) const
683 {
684     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
685         return true;
686
687     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
688         return true;
689
690 #if 0 // PluginDatabase is disabled until we have Plugin system done.
691     if (PluginDatabase::installedPlugins()->isMIMETypeRegistered(MIMEType))
692         return true;
693 #endif
694
695     return false;
696 }
697
698 bool FrameLoaderClientEfl::representationExistsForURLScheme(const String&) const
699 {
700     return false;
701 }
702
703 String FrameLoaderClientEfl::generatedMIMETypeForURLScheme(const String&) const
704 {
705     notImplemented();
706     return String();
707 }
708
709 void FrameLoaderClientEfl::finishedLoading(DocumentLoader* documentLoader)
710 {
711     if (!m_pluginView) {
712         if (m_hasRepresentation)
713             documentLoader->writer()->setEncoding("", false);
714         return;
715     }
716     m_pluginView->didFinishLoading();
717     m_pluginView = 0;
718     m_hasSentResponseToPlugin = false;
719 }
720
721
722 void FrameLoaderClientEfl::provisionalLoadStarted()
723 {
724     notImplemented();
725 }
726
727 void FrameLoaderClientEfl::didFinishLoad()
728 {
729     notImplemented();
730 }
731
732 void FrameLoaderClientEfl::prepareForDataSourceReplacement()
733 {
734     notImplemented();
735 }
736
737 void FrameLoaderClientEfl::setTitle(const StringWithDirection& title, const KURL& url)
738 {
739     // no need for, dispatchDidReceiveTitle is the right callback
740 }
741
742 void FrameLoaderClientEfl::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int dataLength)
743 {
744     notImplemented();
745 }
746
747 void FrameLoaderClientEfl::dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier)
748 {
749     notImplemented();
750 }
751
752 void FrameLoaderClientEfl::dispatchDidFailLoading(DocumentLoader* loader, unsigned long identifier, const ResourceError& err)
753 {
754     notImplemented();
755 }
756
757 bool FrameLoaderClientEfl::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length)
758 {
759     notImplemented();
760     return false;
761 }
762
763 void FrameLoaderClientEfl::dispatchDidLoadResourceByXMLHttpRequest(unsigned long, const String&)
764 {
765     notImplemented();
766 }
767
768 void FrameLoaderClientEfl::dispatchDidFailProvisionalLoad(const ResourceError& err)
769 {
770     dispatchDidFailLoad(err);
771 }
772
773 void FrameLoaderClientEfl::dispatchDidFailLoad(const ResourceError& err)
774 {
775     if (!shouldFallBack(err))
776         return;
777
778     m_loadError = err;
779     ewk_frame_load_error(m_frame,
780                          m_loadError.domain().utf8().data(),
781                          m_loadError.errorCode(), m_loadError.isCancellation(),
782                          m_loadError.localizedDescription().utf8().data(),
783                          m_loadError.failingURL().utf8().data());
784 }
785
786 void FrameLoaderClientEfl::download(ResourceHandle*, const ResourceRequest& request, const ResourceResponse&)
787 {
788     if (!m_view)
789         return;
790
791     CString url = request.url().string().utf8();
792     Ewk_Download download;
793
794     download.url = url.data();
795     ewk_view_download_request(m_view, &download);
796 }
797
798 // copied from WebKit/Misc/WebKitErrors[Private].h
799 enum {
800     WebKitErrorCannotShowMIMEType = 100,
801     WebKitErrorCannotShowURL = 101,
802     WebKitErrorFrameLoadInterruptedByPolicyChange = 102,
803     WebKitErrorCannotUseRestrictedPort = 103,
804     WebKitErrorCannotFindPlugIn = 200,
805     WebKitErrorCannotLoadPlugIn = 201,
806     WebKitErrorJavaUnavailable = 202,
807 };
808
809 ResourceError FrameLoaderClientEfl::cancelledError(const ResourceRequest& request)
810 {
811     ResourceError error("Error", -999, request.url().string(),
812                         "Request cancelled");
813     error.setIsCancellation(true);
814     return error;
815 }
816
817 ResourceError FrameLoaderClientEfl::blockedError(const ResourceRequest& request)
818 {
819     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().string(),
820                          "Request blocked");
821 }
822
823 ResourceError FrameLoaderClientEfl::cannotShowURLError(const ResourceRequest& request)
824 {
825     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
826                          "Cannot show URL");
827 }
828
829 ResourceError FrameLoaderClientEfl::interruptedForPolicyChangeError(const ResourceRequest& request)
830 {
831     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange,
832                          request.url().string(), "Frame load interrupted by policy change");
833 }
834
835 ResourceError FrameLoaderClientEfl::cannotShowMIMETypeError(const ResourceResponse& response)
836 {
837     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
838                          "Cannot show mimetype");
839 }
840
841 ResourceError FrameLoaderClientEfl::fileDoesNotExistError(const ResourceResponse& response)
842 {
843     return ResourceError("Error", -998 /* ### */, response.url().string(),
844                          "File does not exist");
845 }
846
847 ResourceError FrameLoaderClientEfl::pluginWillHandleLoadError(const ResourceResponse&)
848 {
849     notImplemented();
850     return ResourceError("Error", 0, "", "");
851 }
852
853 bool FrameLoaderClientEfl::shouldFallBack(const ResourceError& error)
854 {
855     return !(error.isCancellation() || (error.errorCode() == WebKitErrorFrameLoadInterruptedByPolicyChange));
856 }
857
858 bool FrameLoaderClientEfl::canCachePage() const
859 {
860     return false;
861 }
862
863 Frame* FrameLoaderClientEfl::dispatchCreatePage(const NavigationAction&)
864 {
865     if (!m_view)
866         return 0;
867
868     Evas_Object* newView = ewk_view_window_create(m_view, EINA_FALSE, 0);
869     Evas_Object* mainFrame;
870     if (!newView)
871         mainFrame = m_frame;
872     else
873         mainFrame = ewk_view_frame_main_get(newView);
874
875     return EWKPrivate::coreFrame(mainFrame);
876 }
877
878 void FrameLoaderClientEfl::dispatchUnableToImplementPolicy(const ResourceError&)
879 {
880     notImplemented();
881 }
882
883 void FrameLoaderClientEfl::setMainDocumentError(DocumentLoader* loader, const ResourceError& error)
884 {
885     if (!m_pluginView)
886         return;
887     m_pluginView->didFail(error);
888     m_pluginView = 0;
889     m_hasSentResponseToPlugin = false;
890 }
891
892 void FrameLoaderClientEfl::startDownload(const ResourceRequest& request, const String& /* suggestedName */)
893 {
894     if (!m_view)
895         return;
896
897     CString url = request.url().string().utf8();
898     Ewk_Download download;
899
900     download.url = url.data();
901     ewk_view_download_request(m_view, &download);
902 }
903
904 void FrameLoaderClientEfl::updateGlobalHistory()
905 {
906     notImplemented();
907 }
908
909 void FrameLoaderClientEfl::savePlatformDataToCachedFrame(CachedFrame*)
910 {
911     notImplemented();
912 }
913
914 void FrameLoaderClientEfl::transitionToCommittedFromCachedFrame(CachedFrame*)
915 {
916 }
917
918 void FrameLoaderClientEfl::transitionToCommittedForNewPage()
919 {
920     ASSERT(m_frame);
921     ASSERT(m_view);
922
923     ewk_frame_view_create_for_view(m_frame, m_view);
924
925     if (m_frame == ewk_view_frame_main_get(m_view)) {
926         ewk_view_frame_view_creation_notify(m_view);
927         ewk_view_frame_main_cleared(m_view);
928     }
929 }
930
931 void FrameLoaderClientEfl::didSaveToPageCache()
932 {
933 }
934
935 void FrameLoaderClientEfl::didRestoreFromPageCache()
936 {
937 }
938
939 void FrameLoaderClientEfl::dispatchDidBecomeFrameset(bool)
940 {
941 }
942
943 PassRefPtr<FrameNetworkingContext> FrameLoaderClientEfl::createNetworkingContext()
944 {
945     return FrameNetworkingContextEfl::create(EWKPrivate::coreFrame(m_frame));
946 }
947
948 }