2011-04-11 Alexis Menard <alexis.menard@openbossa.org>
[WebKit-https.git] / Source / WebKit / qt / WebCoreSupport / ChromeClientQt.cpp
1 /*
2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
3  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  *
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "ChromeClientQt.h"
32
33 #include "ApplicationCacheStorage.h"
34 #include "DatabaseTracker.h"
35 #include "FileChooser.h"
36 #include "Frame.h"
37 #include "FrameLoadRequest.h"
38 #include "FrameLoader.h"
39 #include "FrameLoaderClientQt.h"
40 #include "FrameView.h"
41 #include "Geolocation.h"
42 #if USE(ACCELERATED_COMPOSITING)
43 #include "GraphicsLayer.h"
44 #endif
45 #include "HitTestResult.h"
46 #include "Icon.h"
47 #include "NavigationAction.h"
48 #include "NetworkingContext.h"
49 #include "NotImplemented.h"
50 #include "NotificationPresenterClientQt.h"
51 #include "PageClientQt.h"
52 #include "PopupMenuQt.h"
53 #if defined(Q_WS_MAEMO_5)
54 #include "QtMaemoWebPopup.h"
55 #else
56 #include "QtFallbackWebPopup.h"
57 #endif
58 #include "QWebPageClient.h"
59 #include "ScrollbarTheme.h"
60 #include "SearchPopupMenuQt.h"
61 #include "SecurityOrigin.h"
62 #include "ViewportArguments.h"
63 #include "WindowFeatures.h"
64
65 #include "qgraphicswebview.h"
66 #include "qwebframe_p.h"
67 #include "qwebpage.h"
68 #include "qwebpage_p.h"
69 #include "qwebsecurityorigin.h"
70 #include "qwebsecurityorigin_p.h"
71 #include "qwebview.h"
72 #include <qdebug.h>
73 #include <qeventloop.h>
74 #include <qtextdocument.h>
75 #include <qtooltip.h>
76 #include <wtf/OwnPtr.h>
77
78 #if ENABLE(VIDEO) && (USE(GSTREAMER) || USE(QT_MULTIMEDIA))
79 #include "FullScreenVideoQt.h"
80 #include "HTMLMediaElement.h"
81 #include "HTMLNames.h"
82 #include "HTMLVideoElement.h"
83 #if USE(QT_MULTIMEDIA)
84 #include "MediaPlayerPrivateQt.h"
85 #endif
86 #endif
87
88 namespace WebCore {
89
90 bool ChromeClientQt::dumpVisitedLinksCallbacks = false;
91
92 ChromeClientQt::ChromeClientQt(QWebPage* webPage)
93     : m_webPage(webPage)
94     , m_eventLoop(0)
95 #if ENABLE(VIDEO) && (USE(GSTREAMER) || USE(QT_MULTIMEDIA))
96     , m_fullScreenVideo(0)
97 #endif
98 {
99     toolBarsVisible = statusBarVisible = menuBarVisible = true;
100 }
101
102 ChromeClientQt::~ChromeClientQt()
103 {
104     if (m_eventLoop)
105         m_eventLoop->exit();
106
107 #if ENABLE(VIDEO) && (USE(GSTREAMER) || USE(QT_MULTIMEDIA))
108     delete m_fullScreenVideo;
109 #endif
110 }
111
112 void ChromeClientQt::setWindowRect(const FloatRect& rect)
113 {
114     if (!m_webPage)
115         return;
116     emit m_webPage->geometryChangeRequested(QRect(qRound(rect.x()), qRound(rect.y()),
117                             qRound(rect.width()), qRound(rect.height())));
118 }
119
120 /*!
121     windowRect represents the rect of the Window, including all interface elements
122     like toolbars/scrollbars etc. It is used by the viewport meta tag as well as
123     by the DOM Window object: outerHeight(), outerWidth(), screenX(), screenY().
124 */
125 FloatRect ChromeClientQt::windowRect()
126 {
127     if (!platformPageClient())
128         return FloatRect();
129     return platformPageClient()->windowRect();
130 }
131
132 FloatRect ChromeClientQt::pageRect()
133 {
134     if (!m_webPage)
135         return FloatRect();
136     return FloatRect(QRectF(QPointF(0, 0), m_webPage->viewportSize()));
137 }
138
139 float ChromeClientQt::scaleFactor()
140 {
141     if (!m_webPage)
142         return 1;
143     return m_webPage->d->pixelRatio;
144 }
145
146 void ChromeClientQt::focus()
147 {
148     if (!m_webPage)
149         return;
150     QWidget* view = m_webPage->view();
151     if (!view)
152         return;
153
154     view->setFocus();
155 }
156
157
158 void ChromeClientQt::unfocus()
159 {
160     if (!m_webPage)
161         return;
162     QWidget* view = m_webPage->view();
163     if (!view)
164         return;
165     view->clearFocus();
166 }
167
168 bool ChromeClientQt::canTakeFocus(FocusDirection)
169 {
170     // This is called when cycling through links/focusable objects and we
171     // reach the last focusable object. Then we want to claim that we can
172     // take the focus to avoid wrapping.
173     return true;
174 }
175
176 void ChromeClientQt::takeFocus(FocusDirection)
177 {
178     // don't do anything. This is only called when cycling to links/focusable objects,
179     // which in turn is called from focusNextPrevChild. We let focusNextPrevChild
180     // call QWidget::focusNextPrevChild accordingly, so there is no need to do anything
181     // here.
182 }
183
184
185 void ChromeClientQt::focusedNodeChanged(Node*)
186 {
187 }
188
189 void ChromeClientQt::focusedFrameChanged(Frame*)
190 {
191 }
192
193 Page* ChromeClientQt::createWindow(Frame*, const FrameLoadRequest& request, const WindowFeatures& features, const NavigationAction&)
194 {
195     QWebPage* newPage = m_webPage->createWindow(features.dialog ? QWebPage::WebModalDialog : QWebPage::WebBrowserWindow);
196     if (!newPage)
197         return 0;
198
199     // A call to QWebPage::mainFrame() implicitly creates the main frame.
200     // Make sure it exists, as WebCore expects it when returning from this call.
201     newPage->mainFrame();
202     return newPage->d->page;
203 }
204
205 void ChromeClientQt::show()
206 {
207     if (!m_webPage)
208         return;
209     QWidget* view = m_webPage->view();
210     if (!view)
211         return;
212     view->window()->show();
213 }
214
215
216 bool ChromeClientQt::canRunModal()
217 {
218     return true;
219 }
220
221
222 void ChromeClientQt::runModal()
223 {
224     m_eventLoop = new QEventLoop();
225     QEventLoop* eventLoop = m_eventLoop;
226     m_eventLoop->exec();
227     delete eventLoop;
228 }
229
230
231 void ChromeClientQt::setToolbarsVisible(bool visible)
232 {
233     toolBarsVisible = visible;
234     emit m_webPage->toolBarVisibilityChangeRequested(visible);
235 }
236
237
238 bool ChromeClientQt::toolbarsVisible()
239 {
240     return toolBarsVisible;
241 }
242
243
244 void ChromeClientQt::setStatusbarVisible(bool visible)
245 {
246     emit m_webPage->statusBarVisibilityChangeRequested(visible);
247     statusBarVisible = visible;
248 }
249
250
251 bool ChromeClientQt::statusbarVisible()
252 {
253     return statusBarVisible;
254 }
255
256
257 void ChromeClientQt::setScrollbarsVisible(bool)
258 {
259     notImplemented();
260 }
261
262
263 bool ChromeClientQt::scrollbarsVisible()
264 {
265     notImplemented();
266     return true;
267 }
268
269
270 void ChromeClientQt::setMenubarVisible(bool visible)
271 {
272     menuBarVisible = visible;
273     emit m_webPage->menuBarVisibilityChangeRequested(visible);
274 }
275
276 bool ChromeClientQt::menubarVisible()
277 {
278     return menuBarVisible;
279 }
280
281 void ChromeClientQt::setResizable(bool)
282 {
283     notImplemented();
284 }
285
286 void ChromeClientQt::addMessageToConsole(MessageSource, MessageType, MessageLevel, const String& message,
287                                          unsigned int lineNumber, const String& sourceID)
288 {
289     QString x = message;
290     QString y = sourceID;
291     m_webPage->javaScriptConsoleMessage(x, lineNumber, y);
292 }
293
294 void ChromeClientQt::chromeDestroyed()
295 {
296     delete this;
297 }
298
299 bool ChromeClientQt::canRunBeforeUnloadConfirmPanel()
300 {
301     return true;
302 }
303
304 bool ChromeClientQt::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
305 {
306     return runJavaScriptConfirm(frame, message);
307 }
308
309 void ChromeClientQt::closeWindowSoon()
310 {
311     m_webPage->d->page->setGroupName(String());
312     m_webPage->mainFrame()->d->frame->loader()->stopAllLoaders();
313     emit m_webPage->windowCloseRequested();
314 }
315
316 void ChromeClientQt::runJavaScriptAlert(Frame* f, const String& msg)
317 {
318     QString x = msg;
319     QWebFrame* webFrame = qobject_cast<QWebFrame*>(f->loader()->networkingContext()->originatingObject());
320     m_webPage->javaScriptAlert(webFrame, x);
321 }
322
323 bool ChromeClientQt::runJavaScriptConfirm(Frame* f, const String& msg)
324 {
325     QString x = msg;
326     QWebFrame* webFrame = qobject_cast<QWebFrame*>(f->loader()->networkingContext()->originatingObject());
327     return m_webPage->javaScriptConfirm(webFrame, x);
328 }
329
330 bool ChromeClientQt::runJavaScriptPrompt(Frame* f, const String& message, const String& defaultValue, String& result)
331 {
332     QString x = result;
333     QWebFrame* webFrame = qobject_cast<QWebFrame*>(f->loader()->networkingContext()->originatingObject());
334     bool rc = m_webPage->javaScriptPrompt(webFrame, (QString)message, (QString)defaultValue, &x);
335
336     // Fix up a quirk in the QInputDialog class. If no input happened the string should be empty
337     // but it is null. See https://bugs.webkit.org/show_bug.cgi?id=30914.
338     if (rc && x.isNull())
339         result = String("");
340     else
341         result = x;
342
343     return rc;
344 }
345
346 void ChromeClientQt::setStatusbarText(const String& msg)
347 {
348     QString x = msg;
349     emit m_webPage->statusBarMessage(x);
350 }
351
352 bool ChromeClientQt::shouldInterruptJavaScript()
353 {
354     bool shouldInterrupt = false;
355     QMetaObject::invokeMethod(m_webPage, "shouldInterruptJavaScript", Qt::DirectConnection, Q_RETURN_ARG(bool, shouldInterrupt));
356     return shouldInterrupt;
357 }
358
359 KeyboardUIMode ChromeClientQt::keyboardUIMode()
360 {
361     return m_webPage->settings()->testAttribute(QWebSettings::LinksIncludedInFocusChain)
362         ? KeyboardAccessTabsToLinks : KeyboardAccessDefault;
363 }
364
365 IntRect ChromeClientQt::windowResizerRect() const
366 {
367 #if defined(Q_WS_MAC)
368     if (!m_webPage)
369         return IntRect();
370
371     QWebPageClient* pageClient = platformPageClient();
372     if (!pageClient)
373         return IntRect();
374
375     QWidget* ownerWidget = pageClient->ownerWidget();
376     if (!ownerWidget)
377         return IntRect();
378
379     QWidget* topLevelWidget = ownerWidget->window();
380     QRect topLevelGeometry(topLevelWidget->geometry());
381
382     // There's no API in Qt to query for the size of the resizer, so we assume
383     // it has the same width and height as the scrollbar thickness.
384     int scollbarThickness = ScrollbarTheme::nativeTheme()->scrollbarThickness();
385
386     // There's no API in Qt to query for the position of the resizer. Sometimes
387     // it's drawn by the system, and sometimes it's a QSizeGrip. For RTL locales
388     // it might even be on the lower left side of the window, but in WebKit we
389     // always draw scrollbars on the right hand side, so we assume this to be the
390     // location when computing the resize rect to reserve for WebKit.
391     QPoint resizeCornerTopLeft = ownerWidget->mapFrom(topLevelWidget,
392             QPoint(topLevelGeometry.width(), topLevelGeometry.height())
393             - QPoint(scollbarThickness, scollbarThickness));
394
395     QRect resizeCornerRect = QRect(resizeCornerTopLeft, QSize(scollbarThickness, scollbarThickness));
396     return resizeCornerRect.intersected(pageClient->geometryRelativeToOwnerWidget());
397 #else
398     return IntRect();
399 #endif
400 }
401
402 void ChromeClientQt::invalidateWindow(const IntRect& windowRect, bool)
403 {
404 #if ENABLE(TILED_BACKING_STORE)
405     if (platformPageClient()) {
406         WebCore::TiledBackingStore* backingStore = QWebFramePrivate::core(m_webPage->mainFrame())->tiledBackingStore();
407         if (!backingStore)
408             return;
409         backingStore->invalidate(windowRect);
410     }
411 #else
412     Q_UNUSED(windowRect);
413 #endif
414 }
415
416 void ChromeClientQt::invalidateContentsAndWindow(const IntRect& windowRect, bool immediate)
417 {
418     // No double buffer, so only update the QWidget if content changed.
419     if (platformPageClient()) {
420         QRect rect(windowRect);
421         rect = rect.intersected(QRect(QPoint(0, 0), m_webPage->viewportSize()));
422         if (!rect.isEmpty())
423             platformPageClient()->update(rect);
424     }
425     QMetaObject::invokeMethod(m_webPage, "repaintRequested", Qt::QueuedConnection, Q_ARG(QRect, windowRect));
426
427     // FIXME: There is no "immediate" support for window painting.  This should be done always whenever the flag
428     // is set.
429 }
430
431 void ChromeClientQt::invalidateContentsForSlowScroll(const IntRect& windowRect, bool immediate)
432 {
433     invalidateContentsAndWindow(windowRect, immediate);
434 }
435
436 void ChromeClientQt::scroll(const IntSize& delta, const IntRect& scrollViewRect, const IntRect&)
437 {
438     if (platformPageClient())
439         platformPageClient()->scroll(delta.width(), delta.height(), scrollViewRect);
440     emit m_webPage->scrollRequested(delta.width(), delta.height(), scrollViewRect);
441 }
442
443 #if ENABLE(TILED_BACKING_STORE)
444 void ChromeClientQt::delegatedScrollRequested(const IntPoint& point)
445 {
446     QPoint currentPosition(m_webPage->mainFrame()->scrollPosition());
447     emit m_webPage->scrollRequested(point.x() - currentPosition.x(), point.y() - currentPosition.y(), QRect(QPoint(0, 0), m_webPage->viewportSize()));
448 }
449 #endif
450
451 IntRect ChromeClientQt::windowToScreen(const IntRect& rect) const
452 {
453     QWebPageClient* pageClient = platformPageClient();
454     if (!pageClient)
455         return rect;
456
457     QWidget* ownerWidget = pageClient->ownerWidget();
458     if (!ownerWidget)
459        return rect;
460
461     QRect screenRect(rect);
462     screenRect.translate(ownerWidget->mapToGlobal(QPoint(0, 0)));
463
464     return screenRect;
465 }
466
467 IntPoint ChromeClientQt::screenToWindow(const IntPoint& point) const
468 {
469     QWebPageClient* pageClient = platformPageClient();
470     if (!pageClient)
471         return point;
472
473     QWidget* ownerWidget = pageClient->ownerWidget();
474     if (!ownerWidget)
475         return point;
476
477     return ownerWidget->mapFromGlobal(point);
478 }
479
480 PlatformPageClient ChromeClientQt::platformPageClient() const
481 {
482     return m_webPage->d->client.get();
483 }
484
485 void ChromeClientQt::contentsSizeChanged(Frame* frame, const IntSize& size) const
486 {
487     if (frame->loader()->networkingContext())
488         QWebFramePrivate::kit(frame)->contentsSizeChanged(size);
489 }
490
491 void ChromeClientQt::mouseDidMoveOverElement(const HitTestResult& result, unsigned)
492 {
493     TextDirection dir;
494     if (result.absoluteLinkURL() != lastHoverURL
495         || result.title(dir) != lastHoverTitle
496         || result.textContent() != lastHoverContent) {
497         lastHoverURL = result.absoluteLinkURL();
498         lastHoverTitle = result.title(dir);
499         lastHoverContent = result.textContent();
500         emit m_webPage->linkHovered(lastHoverURL.prettyURL(),
501                 lastHoverTitle, lastHoverContent);
502     }
503 }
504
505 void ChromeClientQt::setToolTip(const String &tip, TextDirection)
506 {
507 #ifndef QT_NO_TOOLTIP
508     QWidget* view = m_webPage->view();
509     if (!view)
510         return;
511
512     if (tip.isEmpty()) {
513         view->setToolTip(QString());
514         QToolTip::hideText();
515     } else {
516         QString dtip = QLatin1String("<p>") + Qt::escape(tip) + QLatin1String("</p>");
517         view->setToolTip(dtip);
518     }
519 #else
520     Q_UNUSED(tip);
521 #endif
522 }
523
524 void ChromeClientQt::print(Frame* frame)
525 {
526     emit m_webPage->printRequested(QWebFramePrivate::kit(frame));
527 }
528
529 #if ENABLE(DATABASE)
530 void ChromeClientQt::exceededDatabaseQuota(Frame* frame, const String& databaseName)
531 {
532     quint64 quota = QWebSettings::offlineStorageDefaultQuota();
533
534     if (!DatabaseTracker::tracker().hasEntryForOrigin(frame->document()->securityOrigin()))
535         DatabaseTracker::tracker().setQuota(frame->document()->securityOrigin(), quota);
536
537     emit m_webPage->databaseQuotaExceeded(QWebFramePrivate::kit(frame), databaseName);
538 }
539 #endif
540
541 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
542 void ChromeClientQt::reachedMaxAppCacheSize(int64_t)
543 {
544     // FIXME: Free some space.
545     notImplemented();
546 }
547
548 void ChromeClientQt::reachedApplicationCacheOriginQuota(SecurityOrigin* origin)
549 {
550     int64_t quota;
551     quint64 defaultOriginQuota = WebCore::cacheStorage().defaultOriginQuota();
552
553     QWebSecurityOriginPrivate* priv = new QWebSecurityOriginPrivate(origin);
554     QWebSecurityOrigin* securityOrigin = new QWebSecurityOrigin(priv);
555
556     if (!WebCore::cacheStorage().quotaForOrigin(origin, quota))
557        WebCore::cacheStorage().storeUpdatedQuotaForOrigin(origin, defaultOriginQuota);
558
559     emit m_webPage->applicationCacheQuotaExceeded(securityOrigin, defaultOriginQuota);
560 }
561 #endif
562
563 #if ENABLE(NOTIFICATIONS)
564 NotificationPresenter* ChromeClientQt::notificationPresenter() const
565 {
566     return NotificationPresenterClientQt::notificationPresenter();
567 }
568 #endif
569
570 void ChromeClientQt::runOpenPanel(Frame* frame, PassRefPtr<FileChooser> prpFileChooser)
571 {
572     RefPtr<FileChooser> fileChooser = prpFileChooser;
573     bool supportMulti = m_webPage->supportsExtension(QWebPage::ChooseMultipleFilesExtension);
574
575     if (fileChooser->allowsMultipleFiles() && supportMulti) {
576         QWebPage::ChooseMultipleFilesExtensionOption option;
577         option.parentFrame = QWebFramePrivate::kit(frame);
578
579         if (!fileChooser->filenames().isEmpty())
580             for (unsigned i = 0; i < fileChooser->filenames().size(); ++i)
581                 option.suggestedFileNames += fileChooser->filenames()[i];
582
583         QWebPage::ChooseMultipleFilesExtensionReturn output;
584         m_webPage->extension(QWebPage::ChooseMultipleFilesExtension, &option, &output);
585
586         if (!output.fileNames.isEmpty()) {
587             Vector<String> names;
588             for (int i = 0; i < output.fileNames.count(); ++i)
589                 names.append(output.fileNames.at(i));
590             fileChooser->chooseFiles(names);
591         }
592     } else {
593         QString suggestedFile;
594         if (!fileChooser->filenames().isEmpty())
595             suggestedFile = fileChooser->filenames()[0];
596         QString file = m_webPage->chooseFile(QWebFramePrivate::kit(frame), suggestedFile);
597         if (!file.isEmpty())
598             fileChooser->chooseFile(file);
599     }
600 }
601
602 void ChromeClientQt::chooseIconForFiles(const Vector<String>& filenames, FileChooser* chooser)
603 {
604     chooser->iconLoaded(Icon::createIconForFiles(filenames));
605 }
606
607 void ChromeClientQt::setCursor(const Cursor& cursor)
608 {
609 #ifndef QT_NO_CURSOR
610     QWebPageClient* pageClient = platformPageClient();
611     if (!pageClient)
612         return;
613     pageClient->setCursor(*cursor.platformCursor());
614 #else
615     UNUSED_PARAM(cursor);
616 #endif
617 }
618
619
620 #if USE(ACCELERATED_COMPOSITING)
621 void ChromeClientQt::attachRootGraphicsLayer(Frame* frame, GraphicsLayer* graphicsLayer)
622 {
623     if (platformPageClient())
624         platformPageClient()->setRootGraphicsLayer(graphicsLayer ? graphicsLayer->platformLayer() : 0);
625 }
626
627 void ChromeClientQt::setNeedsOneShotDrawingSynchronization()
628 {
629     // we want the layers to synchronize next time we update the screen anyway
630     if (platformPageClient())
631         platformPageClient()->markForSync(false);
632 }
633
634 void ChromeClientQt::scheduleCompositingLayerSync()
635 {
636     // we want the layers to synchronize ASAP
637     if (platformPageClient())
638         platformPageClient()->markForSync(true);
639 }
640
641 ChromeClient::CompositingTriggerFlags ChromeClientQt::allowedCompositingTriggers() const
642 {
643     if (platformPageClient() && platformPageClient()->allowsAcceleratedCompositing())
644         return AllTriggers;
645
646     return 0;
647 }
648
649 #endif
650
651 #if ENABLE(TILED_BACKING_STORE)
652 IntRect ChromeClientQt::visibleRectForTiledBackingStore() const
653 {
654     if (!platformPageClient() || !m_webPage)
655         return IntRect();
656
657     if (!platformPageClient()->viewResizesToContentsEnabled())
658         return QRect(m_webPage->mainFrame()->scrollPosition(), m_webPage->mainFrame()->geometry().size());
659
660     return enclosingIntRect(FloatRect(platformPageClient()->graphicsItemVisibleRect()));
661 }
662 #endif
663
664 #if ENABLE(VIDEO) && (USE(GSTREAMER) || USE(QT_MULTIMEDIA))
665 FullScreenVideoQt* ChromeClientQt::fullScreenVideo()
666 {
667     if (!m_fullScreenVideo)
668         m_fullScreenVideo = new FullScreenVideoQt(this);
669     return m_fullScreenVideo;
670 }
671
672 bool ChromeClientQt::supportsFullscreenForNode(const Node* node)
673 {
674     ASSERT(node);
675     return node->hasTagName(HTMLNames::videoTag) && fullScreenVideo()->isValid();
676 }
677
678 bool ChromeClientQt::requiresFullscreenForVideoPlayback()
679 {
680     return fullScreenVideo()->requiresFullScreenForVideoPlayback();
681 }
682
683 void ChromeClientQt::enterFullscreenForNode(Node* node)
684 {
685     ASSERT(node && node->hasTagName(HTMLNames::videoTag));
686
687     fullScreenVideo()->enterFullScreenForNode(node);
688 }
689
690 void ChromeClientQt::exitFullscreenForNode(Node* node)
691 {
692     ASSERT(node && node->hasTagName(HTMLNames::videoTag));
693
694     fullScreenVideo()->exitFullScreenForNode(node);
695
696 #endif
697
698 QWebSelectMethod* ChromeClientQt::createSelectPopup() const
699 {
700     QWebSelectMethod* result = m_platformPlugin.createSelectInputMethod();
701     if (result)
702         return result;
703
704 #if defined(Q_WS_MAEMO_5)
705     return new QtMaemoWebPopup;
706 #elif !defined(QT_NO_COMBOBOX)
707     return new QtFallbackWebPopup(this);
708 #else
709     return 0;
710 #endif
711 }
712
713 void ChromeClientQt::dispatchViewportDataDidChange(const ViewportArguments&) const
714 {
715     emit m_webPage->viewportChangeRequested();
716 }
717
718 bool ChromeClientQt::selectItemWritingDirectionIsNatural()
719 {
720     return false;
721 }
722
723 bool ChromeClientQt::selectItemAlignmentFollowsMenuWritingDirection()
724 {
725     return false;
726 }
727
728 PassRefPtr<PopupMenu> ChromeClientQt::createPopupMenu(PopupMenuClient* client) const
729 {
730     return adoptRef(new PopupMenuQt(client, this));
731 }
732
733 PassRefPtr<SearchPopupMenu> ChromeClientQt::createSearchPopupMenu(PopupMenuClient* client) const
734 {
735     return adoptRef(new SearchPopupMenuQt(createPopupMenu(client)));
736 }
737
738 void ChromeClientQt::populateVisitedLinks()
739 {
740     // We don't need to do anything here because history is tied to QWebPage rather than stored
741     // in a separate database
742     if (dumpVisitedLinksCallbacks) {
743         printf("Asked to populate visited links for WebView \"%s\"\n",
744                 qPrintable(m_webPage->mainFrame()->url().toString()));
745     }
746 }
747
748 } // namespace WebCore