[EFL] Disable REQUEST_ANIMATION_FRAME_TIMER to render a new animation frame.
[WebKit-https.git] / Source / WebKit / efl / WebCoreSupport / ChromeClientEfl.cpp
1 /*
2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
3  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
4  * Copyright (C) 2008 Kenneth Rohde Christiansen
5  * Copyright (C) 2008 Diego Gonzalez
6  * Copyright (C) 2009-2010 ProFUSION embedded systems
7  * Copyright (C) 2009-2012 Samsung Electronics
8  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
9  *
10  * All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
25  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
29  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include "config.h"
35 #include "ChromeClientEfl.h"
36
37 #include "ApplicationCacheStorage.h"
38 #include "FileChooser.h"
39 #include "FileIconLoader.h"
40 #include "FloatRect.h"
41 #include "Frame.h"
42 #include "FrameLoader.h"
43 #include "FrameLoaderClientEfl.h"
44 #include "HitTestResult.h"
45 #include "IntRect.h"
46 #include "KURL.h"
47 #include "NavigationAction.h"
48 #include "NotImplemented.h"
49 #include "PopupMenuEfl.h"
50 #include "SearchPopupMenuEfl.h"
51 #include "SecurityOrigin.h"
52 #include "ViewportArguments.h"
53 #include "WindowFeatures.h"
54 #include "ewk_custom_handler_private.h"
55 #include "ewk_file_chooser_private.h"
56 #include "ewk_frame_private.h"
57 #include "ewk_private.h"
58 #include "ewk_security_origin_private.h"
59 #include "ewk_view_private.h"
60 #include <Ecore_Evas.h>
61 #include <Evas.h>
62 #include <wtf/text/CString.h>
63 #include <wtf/text/WTFString.h>
64
65 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
66 #include "NotificationPresenterClientEfl.h"
67 #endif
68
69 #if ENABLE(SQL_DATABASE)
70 #include "DatabaseDetails.h"
71 #include "DatabaseManager.h"
72 #endif
73
74 #if ENABLE(INPUT_TYPE_COLOR)
75 #include "ColorChooserEfl.h"
76 #endif
77
78 #if ENABLE(FULLSCREEN_API)
79 #include "Settings.h"
80 #endif
81
82 using namespace WebCore;
83
84 static inline Evas_Object* kit(Frame* frame)
85 {
86     if (!frame)
87         return 0;
88
89     FrameLoaderClientEfl* client = static_cast<FrameLoaderClientEfl*>(frame->loader()->client());
90     return client ? client->webFrame() : 0;
91 }
92
93 namespace WebCore {
94
95 ChromeClientEfl::ChromeClientEfl(Evas_Object* view)
96     : m_view(view)
97 {
98     ASSERT(m_view);
99 }
100
101 ChromeClientEfl::~ChromeClientEfl()
102 {
103 }
104
105 void ChromeClientEfl::chromeDestroyed()
106 {
107     delete this;
108 }
109
110 void ChromeClientEfl::focusedNodeChanged(Node*)
111 {
112     notImplemented();
113 }
114
115 void ChromeClientEfl::focusedFrameChanged(Frame*)
116 {
117 }
118
119 FloatRect ChromeClientEfl::windowRect()
120 {
121     int x, y, width, height;
122
123     Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_view));
124     ecore_evas_request_geometry_get(ee, &x, &y, &width, &height);
125
126     return FloatRect(x, y, width, height);
127 }
128
129 void ChromeClientEfl::setWindowRect(const FloatRect& rect)
130 {
131     if (!ewk_view_setting_enable_auto_resize_window_get(m_view) || rect.isEmpty())
132         return;
133
134     Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_view));
135     ecore_evas_move_resize(ee, rect.x(), rect.y(), rect.width(), rect.height());
136 }
137
138 FloatRect ChromeClientEfl::pageRect()
139 {
140     return ewk_view_page_rect_get(m_view);
141 }
142
143 void ChromeClientEfl::focus()
144 {
145     evas_object_focus_set(m_view, EINA_TRUE);
146 }
147
148 void ChromeClientEfl::unfocus()
149 {
150     evas_object_focus_set(m_view, EINA_FALSE);
151 }
152
153 Page* ChromeClientEfl::createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures& features, const NavigationAction&)
154 {
155     Evas_Object* newView = ewk_view_window_create(m_view, EINA_TRUE, &features);
156     if (!newView)
157         return 0;
158
159     return EWKPrivate::corePage(newView);
160 }
161
162 void ChromeClientEfl::show()
163 {
164     ewk_view_ready(m_view);
165 }
166
167 bool ChromeClientEfl::canRunModal()
168 {
169     notImplemented();
170     return false;
171 }
172
173 void ChromeClientEfl::runModal()
174 {
175     notImplemented();
176 }
177
178 void ChromeClientEfl::setToolbarsVisible(bool visible)
179 {
180     ewk_view_toolbars_visible_set(m_view, visible);
181 }
182
183 bool ChromeClientEfl::toolbarsVisible()
184 {
185     bool visible;
186
187     ewk_view_toolbars_visible_get(m_view, &visible);
188     return visible;
189 }
190
191 void ChromeClientEfl::setStatusbarVisible(bool visible)
192 {
193     ewk_view_statusbar_visible_set(m_view, visible);
194 }
195
196 bool ChromeClientEfl::statusbarVisible()
197 {
198     bool visible;
199
200     ewk_view_statusbar_visible_get(m_view, &visible);
201     return visible;
202 }
203
204 void ChromeClientEfl::setScrollbarsVisible(bool visible)
205 {
206     ewk_view_scrollbars_visible_set(m_view, visible);
207 }
208
209 bool ChromeClientEfl::scrollbarsVisible()
210 {
211     bool visible;
212
213     ewk_view_scrollbars_visible_get(m_view, &visible);
214     return visible;
215 }
216
217 void ChromeClientEfl::setMenubarVisible(bool visible)
218 {
219     ewk_view_menubar_visible_set(m_view, visible);
220 }
221
222 bool ChromeClientEfl::menubarVisible()
223 {
224     bool visible;
225
226     ewk_view_menubar_visible_get(m_view, &visible);
227     return visible;
228 }
229
230 void ChromeClientEfl::createSelectPopup(PopupMenuClient* client, int selected, const IntRect& rect)
231 {
232     ewk_view_popup_new(m_view, client, selected, rect);
233 }
234
235 bool ChromeClientEfl::destroySelectPopup()
236 {
237     return ewk_view_popup_destroy(m_view);
238 }
239
240 void ChromeClientEfl::setResizable(bool)
241 {
242     notImplemented();
243 }
244
245 void ChromeClientEfl::closeWindowSoon()
246 {
247     ewk_view_window_close(m_view);
248 }
249
250 bool ChromeClientEfl::canTakeFocus(FocusDirection coreDirection)
251 {
252     // This is called when cycling through links/focusable objects and we
253     // reach the last focusable object.
254     ASSERT(coreDirection == FocusDirectionForward || coreDirection == FocusDirectionBackward);
255
256     Ewk_Focus_Direction direction = static_cast<Ewk_Focus_Direction>(coreDirection);
257
258     return !ewk_view_focus_can_cycle(m_view, direction);
259 }
260
261 void ChromeClientEfl::takeFocus(FocusDirection)
262 {
263     unfocus();
264 }
265
266 bool ChromeClientEfl::canRunBeforeUnloadConfirmPanel()
267 {
268     return true;
269 }
270
271 bool ChromeClientEfl::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
272 {
273     return runJavaScriptConfirm(frame, message);
274 }
275
276 void ChromeClientEfl::addMessageToConsole(MessageSource, MessageLevel, const String& message,
277                                           unsigned int lineNumber, const String& sourceID)
278 {
279     ewk_view_add_console_message(m_view, message.utf8().data(), lineNumber, sourceID.utf8().data());
280 }
281
282 void ChromeClientEfl::runJavaScriptAlert(Frame* frame, const String& message)
283 {
284     ewk_view_run_javascript_alert(m_view, kit(frame), message.utf8().data());
285 }
286
287 bool ChromeClientEfl::runJavaScriptConfirm(Frame* frame, const String& message)
288 {
289     return ewk_view_run_javascript_confirm(m_view, kit(frame), message.utf8().data());
290 }
291
292 bool ChromeClientEfl::runJavaScriptPrompt(Frame* frame, const String& message, const String& defaultValue, String& result)
293 {
294     const char* value = 0;
295     ewk_view_run_javascript_prompt(m_view, kit(frame), message.utf8().data(), defaultValue.utf8().data(), &value);
296     if (value) {
297         result = String::fromUTF8(value);
298         eina_stringshare_del(value);
299         return true;
300     }
301     return false;
302 }
303
304 void ChromeClientEfl::setStatusbarText(const String& string)
305 {
306     ewk_view_statusbar_text_set(m_view, string.utf8().data());
307 }
308
309 bool ChromeClientEfl::shouldInterruptJavaScript()
310 {
311     return ewk_view_should_interrupt_javascript(m_view);
312 }
313
314 KeyboardUIMode ChromeClientEfl::keyboardUIMode()
315 {
316     return ewk_view_setting_include_links_in_focus_chain_get(m_view) ? KeyboardAccessTabsToLinks : KeyboardAccessDefault;
317 }
318
319 IntRect ChromeClientEfl::windowResizerRect() const
320 {
321     notImplemented();
322     // Implementing this function will make repaint being
323     // called during resize, but as this will be done with
324     // a minor delay it adds a weird "filling" effect due
325     // to us using an evas image for showing the cairo
326     // context. So instead of implementing this function
327     // we call paint directly during resize with
328     // the new object size as its argument.
329     return IntRect();
330 }
331
332 void ChromeClientEfl::contentsSizeChanged(Frame* frame, const IntSize& size) const
333 {
334     ewk_frame_contents_size_changed(kit(frame), size.width(), size.height());
335     if (ewk_view_frame_main_get(m_view) == kit(frame))
336         ewk_view_contents_size_changed(m_view, size.width(), size.height());
337 }
338
339 IntRect ChromeClientEfl::rootViewToScreen(const IntRect& rect) const
340 {
341     notImplemented();
342     return rect;
343 }
344
345 IntPoint ChromeClientEfl::screenToRootView(const IntPoint& point) const
346 {
347     notImplemented();
348     return point;
349 }
350
351 PlatformPageClient ChromeClientEfl::platformPageClient() const
352 {
353     return EWKPrivate::corePageClient(m_view);
354 }
355
356 void ChromeClientEfl::scrollbarsModeDidChange() const
357 {
358 }
359
360 void ChromeClientEfl::mouseDidMoveOverElement(const HitTestResult& hit, unsigned /*modifierFlags*/)
361 {
362     // FIXME, compare with old link, look at Qt impl.
363     bool isLink = hit.isLiveLink();
364     if (isLink) {
365         KURL url = hit.absoluteLinkURL();
366         if (!url.isEmpty() && url != m_hoveredLinkURL) {
367             const char* link[2];
368             TextDirection dir;
369             CString urlStr = url.string().utf8();
370             CString titleStr = hit.title(dir).utf8();
371             link[0] = urlStr.data();
372             link[1] = titleStr.data();
373             ewk_view_mouse_link_hover_in(m_view, link);
374             m_hoveredLinkURL = url;
375         }
376     } else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
377         ewk_view_mouse_link_hover_out(m_view);
378         m_hoveredLinkURL = KURL();
379     }
380 }
381
382 void ChromeClientEfl::setToolTip(const String& toolTip, TextDirection)
383 {
384     ewk_view_tooltip_text_set(m_view, toolTip.utf8().data());
385 }
386
387 void ChromeClientEfl::print(Frame*)
388 {
389     notImplemented();
390 }
391
392 void ChromeClientEfl::reachedMaxAppCacheSize(int64_t /*spaceNeeded*/)
393 {
394     // FIXME: Free some space.
395     notImplemented();
396 }
397
398 void ChromeClientEfl::reachedApplicationCacheOriginQuota(SecurityOrigin* origin, int64_t totalSpaceNeeded)
399 {
400     Ewk_Security_Origin* ewkOrigin = ewk_security_origin_new(origin);
401     int64_t defaultOriginQuota = WebCore::cacheStorage().defaultOriginQuota();
402
403     int64_t newQuota = ewk_view_exceeded_application_cache_quota(m_view, ewkOrigin, defaultOriginQuota, totalSpaceNeeded);
404     if (newQuota)
405         ewk_security_origin_application_cache_quota_set(ewkOrigin, newQuota);
406
407     ewk_security_origin_free(ewkOrigin);
408 }
409
410 void ChromeClientEfl::populateVisitedLinks()
411 {
412     evas_object_smart_callback_call(m_view, "populate,visited,links", 0);
413 }
414
415 #if ENABLE(TOUCH_EVENTS)
416 void ChromeClientEfl::needTouchEvents(bool needed)
417 {
418     ewk_view_need_touch_events_set(m_view, needed);
419 }
420 #endif
421
422 #if ENABLE(SQL_DATABASE)
423 void ChromeClientEfl::exceededDatabaseQuota(Frame* frame, const String& databaseName, DatabaseDetails details)
424 {
425     uint64_t quota;
426     SecurityOrigin* origin = frame->document()->securityOrigin();
427
428     quota = ewk_view_exceeded_database_quota(m_view,
429                                              kit(frame), databaseName.utf8().data(),
430                                              details.currentUsage(), details.expectedUsage());
431
432     /* if client did not set quota, and database is being created now, the
433      * default quota is applied
434      */
435     if (!quota && !DatabaseManager::manager().hasEntryForOrigin(origin))
436         quota = ewk_settings_web_database_default_quota_get();
437
438     DatabaseManager::manager().setQuota(origin, quota);
439 }
440 #endif
441
442 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
443 NotificationClient* ChromeClientEfl::notificationPresenter() const
444 {
445     notImplemented();
446     return 0;
447 }
448 #endif
449
450 #if ENABLE(INPUT_TYPE_COLOR)
451 PassOwnPtr<ColorChooser> ChromeClientEfl::createColorChooser(ColorChooserClient* colorChooserClient, const Color& initialColor)
452 {
453     ewk_view_color_chooser_new(m_view, colorChooserClient, initialColor);
454
455     return adoptPtr(new ColorChooserEfl(this));
456 }
457
458 void ChromeClientEfl::removeColorChooser()
459 {
460     ewk_view_color_chooser_destroy(m_view);
461 }
462
463 void ChromeClientEfl::updateColorChooser(const Color& color)
464 {
465     ewk_view_color_chooser_changed(m_view, color);
466 }
467 #endif
468
469 void ChromeClientEfl::runOpenPanel(Frame* frame, PassRefPtr<FileChooser> prpFileChooser)
470 {
471     RefPtr<FileChooser> chooser = prpFileChooser;
472     Eina_List* selectedFilenames = 0;
473     Ewk_File_Chooser* fileChooser = ewk_file_chooser_new(chooser.get());
474     bool confirm = ewk_view_run_open_panel(m_view, kit(frame), fileChooser, &selectedFilenames);
475     ewk_file_chooser_free(fileChooser);
476     if (!confirm)
477         return;
478
479     void* filename;
480     Vector<String> filenames;
481     EINA_LIST_FREE(selectedFilenames, filename) {
482         filenames.append(String::fromUTF8(static_cast<char*>(filename)));
483         free(filename);
484     }
485
486     if (chooser->settings().allowsMultipleFiles)
487         chooser->chooseFiles(filenames);
488     else
489         chooser->chooseFile(filenames[0]);
490 }
491
492 void ChromeClientEfl::formStateDidChange(const Node*)
493 {
494     notImplemented();
495 }
496
497 void ChromeClientEfl::setCursor(const Cursor& cursor)
498 {
499     ewk_view_cursor_set(m_view, cursor);
500 }
501
502 void ChromeClientEfl::setCursorHiddenUntilMouseMoves(bool)
503 {
504     notImplemented();
505 }
506
507 #if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
508 void ChromeClientEfl::scheduleAnimation()
509 {
510     notImplemented();
511 }
512
513 void ChromeClientEfl::serviceScriptedAnimations()
514 {
515     notImplemented();
516 }
517 #endif
518
519 void ChromeClientEfl::cancelGeolocationPermissionForFrame(Frame*, Geolocation*)
520 {
521     notImplemented();
522 }
523
524 void ChromeClientEfl::invalidateContents(const IntRect& /*updateRect*/, bool /*immediate*/)
525 {
526     notImplemented();
527 }
528
529 void ChromeClientEfl::invalidateRootView(const IntRect& updateRect, bool /*immediate*/)
530 {
531 #if USE(TILED_BACKING_STORE)
532     ewk_view_tiled_backing_store_invalidate(m_view, updateRect);
533 #else
534     UNUSED_PARAM(updateRect);
535     notImplemented();
536 #endif
537 }
538
539 void ChromeClientEfl::invalidateContentsAndRootView(const IntRect& updateRect, bool /*immediate*/)
540 {
541     if (updateRect.isEmpty())
542         return;
543
544     Evas_Coord x, y, w, h;
545
546     x = updateRect.x();
547     y = updateRect.y();
548     w = updateRect.width();
549     h = updateRect.height();
550     ewk_view_repaint(m_view, x, y, w, h);
551 }
552
553 void ChromeClientEfl::invalidateContentsForSlowScroll(const IntRect& updateRect, bool immediate)
554 {
555     invalidateContentsAndRootView(updateRect, immediate);
556 }
557
558 void ChromeClientEfl::scroll(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
559 {
560     ewk_view_scroll(m_view, scrollDelta.width(), scrollDelta.height(), rectToScroll.x(), rectToScroll.y(), rectToScroll.width(), rectToScroll.height(), clipRect.x(), clipRect.y(), clipRect.width(), clipRect.height());
561 }
562
563 void ChromeClientEfl::cancelGeolocationPermissionRequestForFrame(Frame*)
564 {
565     notImplemented();
566 }
567
568 void ChromeClientEfl::iconForFiles(const Vector<String, 0u>&, PassRefPtr<FileChooser>)
569 {
570     notImplemented();
571 }
572
573 void ChromeClientEfl::loadIconForFiles(const Vector<String>&, FileIconLoader*)
574 {
575     notImplemented();
576 }
577
578 void ChromeClientEfl::dispatchViewportPropertiesDidChange(const ViewportArguments& arguments) const
579 {
580     ewk_view_viewport_attributes_set(m_view, arguments);
581 }
582
583 bool ChromeClientEfl::selectItemWritingDirectionIsNatural()
584 {
585     return true;
586 }
587
588 bool ChromeClientEfl::selectItemAlignmentFollowsMenuWritingDirection()
589 {
590     return false;
591 }
592
593 bool ChromeClientEfl::hasOpenedPopup() const
594 {
595     notImplemented();
596     return false;
597 }
598
599 PassRefPtr<PopupMenu> ChromeClientEfl::createPopupMenu(PopupMenuClient* client) const
600 {
601     return adoptRef(new PopupMenuEfl(client));
602 }
603
604 PassRefPtr<SearchPopupMenu> ChromeClientEfl::createSearchPopupMenu(PopupMenuClient* client) const
605 {
606     return adoptRef(new SearchPopupMenuEfl(client));
607 }
608
609 #if USE(ACCELERATED_COMPOSITING)
610 void ChromeClientEfl::attachRootGraphicsLayer(Frame*, GraphicsLayer* rootLayer)
611 {
612     ewk_view_root_graphics_layer_set(m_view, rootLayer);
613 }
614
615 void ChromeClientEfl::setNeedsOneShotDrawingSynchronization()
616 {
617     ewk_view_mark_for_sync(m_view);
618 }
619
620 void ChromeClientEfl::scheduleCompositingLayerFlush()
621 {
622     ewk_view_mark_for_sync(m_view);
623 }
624
625 ChromeClient::CompositingTriggerFlags ChromeClientEfl::allowedCompositingTriggers() const
626 {
627     return AllTriggers;
628 }
629 #endif
630
631 #if ENABLE(FULLSCREEN_API)
632 bool ChromeClientEfl::supportsFullScreenForElement(const WebCore::Element* element, bool withKeyboard)
633 {
634     UNUSED_PARAM(withKeyboard);
635
636     if (!element->document()->page())
637         return false;
638     return element->document()->page()->settings()->fullScreenEnabled();
639 }
640
641 void ChromeClientEfl::enterFullScreenForElement(WebCore::Element* element)
642 {
643     // Keep a reference to the element to use it later in
644     // exitFullScreenForElement().
645     m_fullScreenElement = element;
646
647     element->document()->webkitWillEnterFullScreenForElement(element);
648     ewk_view_fullscreen_enter(m_view);
649     element->document()->webkitDidEnterFullScreenForElement(element);
650 }
651
652 void ChromeClientEfl::exitFullScreenForElement(WebCore::Element*)
653 {
654     // The element passed into this function is not reliable, i.e. it could
655     // be null. In addition the parameter may be disappearing in the future.
656     // So we use the reference to the element we saved above.
657     ASSERT(m_fullScreenElement);
658
659     m_fullScreenElement->document()->webkitWillExitFullScreenForElement(m_fullScreenElement.get());
660     ewk_view_fullscreen_exit(m_view);
661     m_fullScreenElement->document()->webkitDidExitFullScreenForElement(m_fullScreenElement.get());
662
663     m_fullScreenElement.clear();
664 }
665 #endif
666
667 #if USE(TILED_BACKING_STORE)
668 void ChromeClientEfl::delegatedScrollRequested(const IntPoint&)
669 {
670     notImplemented();
671 }
672
673 IntRect ChromeClientEfl::visibleRectForTiledBackingStore() const
674 {
675     WebCore::FloatRect rect = ewk_view_page_rect_get(m_view);
676     const Evas_Object* frame = ewk_view_frame_main_get(m_view);
677
678     int x, y;
679     ewk_frame_scroll_pos_get(frame, &x, &y);
680     return IntRect(x, y, rect.width(), rect.height());
681 }
682 #endif
683
684 }