6 files changed, 167 insertions, 32 deletions

diff --git a/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.cpp b/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.cpp
index ba9780b..f5fbb5c 100644
--- a/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.cpp
+++ b/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.cpp
@@ -135,9 +135,9 @@ void checkPermissionCallback(QObject* receiver, const QUrl& url, NotificationPer
     qobject_cast<DumpRenderTree*>(receiver)->checkPermission(url, permission);
 }
 
-void requestPermissionCallback(QObject* receiver, QWebPage* page, const QString& origin)
+void requestPermissionCallback(QObject* receiver, const QString& origin)
 {
-    qobject_cast<DumpRenderTree*>(receiver)->requestPermission(page, origin);
+    qobject_cast<DumpRenderTree*>(receiver)->requestPermission(origin);
 }
 
 WebPage::WebPage(QObject* parent, DumpRenderTree* drt)
@@ -153,14 +153,13 @@ WebPage::WebPage(QObject* parent, DumpRenderTree* drt)
     globalSettings->setFontSize(QWebSettings::DefaultFixedFontSize, 13);
 
     globalSettings->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);
-    globalSettings->setAttribute(QWebSettings::DOMPasteAllowed, true);
+    globalSettings->setAttribute(QWebSettings::JavascriptCanAccessClipboard, true);
     globalSettings->setAttribute(QWebSettings::LinksIncludedInFocusChain, false);
     globalSettings->setAttribute(QWebSettings::PluginsEnabled, true);
     globalSettings->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, true);
     globalSettings->setAttribute(QWebSettings::JavascriptEnabled, true);
     globalSettings->setAttribute(QWebSettings::PrivateBrowsingEnabled, false);
     globalSettings->setAttribute(QWebSettings::SpatialNavigationEnabled, false);
-    globalSettings->setAttribute(QWebSettings::JavaScriptCanAccessClipboard, true);
 
     connect(this, SIGNAL(geometryChangeRequested(const QRect &)),
             this, SLOT(setViewGeometry(const QRect & )));
@@ -168,7 +167,7 @@ WebPage::WebPage(QObject* parent, DumpRenderTree* drt)
     setNetworkAccessManager(m_drt->networkAccessManager());
     setPluginFactory(new TestPlugin(this));
 
-    DumpRenderTreeSupportQt::setNotificationsReceiver(this, m_drt);
+    DumpRenderTreeSupportQt::setNotificationsReceiver(m_drt);
     DumpRenderTreeSupportQt::setCheckPermissionFunction(checkPermissionCallback);
     DumpRenderTreeSupportQt::setRequestPermissionFunction(requestPermissionCallback);
 
@@ -201,7 +200,7 @@ void WebPage::resetSettings()
     settings()->resetAttribute(QWebSettings::OfflineWebApplicationCacheEnabled);
     settings()->resetAttribute(QWebSettings::LocalContentCanAccessRemoteUrls);
     settings()->resetAttribute(QWebSettings::PluginsEnabled);
-    settings()->resetAttribute(QWebSettings::JavaScriptCanAccessClipboard);
+    settings()->resetAttribute(QWebSettings::JavascriptCanAccessClipboard);
     settings()->resetAttribute(QWebSettings::AutoLoadImages);
 
     m_drt->layoutTestController()->setCaretBrowsingEnabled(false);
@@ -349,24 +348,51 @@ QObject* WebPage::createPlugin(const QString& classId, const QUrl& url, const QS
 #endif
 }
 
+bool WebPage::allowGeolocationRequest(QWebFrame *)
+{
+    return m_drt->layoutTestController()->geolocationPermission();
+}
+
+WebViewGraphicsBased::WebViewGraphicsBased(QWidget* parent)
+    : m_item(new QGraphicsWebView)
+{
+    setScene(new QGraphicsScene(this));
+    scene()->addItem(m_item);
+}
+
 DumpRenderTree::DumpRenderTree()
     : m_dumpPixels(false)
     , m_stdin(0)
     , m_enableTextOutput(false)
     , m_singleFileMode(false)
+    , m_graphicsBased(false)
     , m_persistentStoragePath(QString(getenv("DUMPRENDERTREE_TEMP")))
 {
+
+    QByteArray viewMode = getenv("QT_DRT_WEBVIEW_MODE");
+    if (viewMode == "graphics")
+        setGraphicsBased(true);
+
     DumpRenderTreeSupportQt::overwritePluginDirectories();
 
     QWebSettings::enablePersistentStorage(m_persistentStoragePath);
 
     m_networkAccessManager = new NetworkAccessManager(this);
     // create our primary testing page/view.
-    m_mainView = new QWebView(0);
-    m_mainView->resize(QSize(LayoutTestController::maxViewWidth, LayoutTestController::maxViewHeight));
-    m_page = new WebPage(m_mainView, this);
-    m_mainView->setPage(m_page);
+    if (isGraphicsBased()) {
+        WebViewGraphicsBased* view = new WebViewGraphicsBased(0);
+        m_page = new WebPage(view, this);
+        view->setPage(m_page);
+        m_mainView = view;
+    } else {
+        QWebView* view = new QWebView(0);
+        m_page = new WebPage(view, this);
+        view->setPage(m_page);
+        m_mainView = view;
+    }
+
     m_mainView->setContextMenuPolicy(Qt::NoContextMenu);
+    m_mainView->resize(QSize(LayoutTestController::maxViewWidth, LayoutTestController::maxViewHeight));
 
     // clean up cache by resetting quota.
     qint64 quota = webPage()->settings()->offlineWebApplicationCacheQuota();
@@ -687,10 +713,18 @@ static QString dumpHistoryItem(const QWebHistoryItem& item, int indent, bool cur
         result.append(url);
     }
 
-    // FIXME: Wrong, need (private?) API for determining this.
-    result.append(QLatin1String("  **nav target**"));
+    QString target = DumpRenderTreeSupportQt::historyItemTarget(item);
+    if (!target.isEmpty())
+        result.append(QString(QLatin1String(" (in frame \"%1\")")).arg(target));
+
+    if (DumpRenderTreeSupportQt::isTargetItem(item))
+        result.append(QLatin1String("  **nav target**"));
     result.append(QLatin1String("\n"));
 
+    QList<QWebHistoryItem> children = DumpRenderTreeSupportQt::getChildHistoryItems(item);
+    for (int i = 0; i < children.size(); ++i)
+        result += dumpHistoryItem(children.at(i), 12, false);
+
     return result;
 }
 
@@ -920,9 +954,9 @@ void DumpRenderTree::checkPermission(const QUrl& url, NotificationPermission& pe
     permission = m_controller->checkDesktopNotificationPermission(url.scheme() + "://" + url.host()) ? NotificationAllowed : NotificationDenied;
 }
 
-void DumpRenderTree::requestPermission(QWebPage* page, const QString& origin)
+void DumpRenderTree::requestPermission(const QString& origin)
 {
-    DumpRenderTreeSupportQt::allowNotificationForOrigin(page, origin);
+    DumpRenderTreeSupportQt::allowNotificationForOrigin(origin);
 }
 
 #if defined(Q_WS_X11)
diff --git a/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.h b/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.h
index 3fa4485..2ec972a 100644
--- a/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.h
+++ b/WebKitTools/DumpRenderTree/qt/DumpRenderTreeQt.h
@@ -41,6 +41,8 @@
 #endif
 
 #include "../../../WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h"
+#include <qgraphicsview.h>
+#include <qgraphicswebview.h>
 #include <qwebframe.h>
 #include <qwebinspector.h>
 #include <qwebpage.h>
@@ -80,6 +82,9 @@ public:
     void setSingleFileMode(bool flag) { m_singleFileMode = flag; }
     bool isSingleFileMode() { return m_singleFileMode; }
 
+    void setGraphicsBased(bool flag) { m_graphicsBased = flag; }
+    bool isGraphicsBased() { return m_graphicsBased; }
+
     void setDumpPixels(bool);
 
     void closeRemainingWindows();
@@ -115,7 +120,7 @@ public Q_SLOTS:
     void statusBarMessage(const QString& message);
     void windowCloseRequested();
     void checkPermission(const QUrl&, NotificationPermission&);
-    void requestPermission(QWebPage* page, const QString&);
+    void requestPermission(const QString&);
 
 Q_SIGNALS:
     void quit();
@@ -135,7 +140,7 @@ private:
     QString m_expectedHash;
 
     WebPage *m_page;
-    QWebView* m_mainView;
+    QWidget* m_mainView;
 
     EventSender *m_eventSender;
     TextInputController *m_textInputController;
@@ -147,6 +152,7 @@ private:
     QList<QObject*> windows;
     bool m_enableTextOutput;
     bool m_singleFileMode;
+    bool m_graphicsBased;
     QString m_persistentStoragePath;
 };
 
@@ -185,6 +191,7 @@ public:
 
 public slots:
     bool shouldInterruptJavaScript() { return false; }
+    bool allowGeolocationRequest(QWebFrame *frame);
 
 protected:
     bool acceptNavigationRequest(QWebFrame* frame, const QNetworkRequest& request, NavigationType type);
@@ -202,6 +209,18 @@ private:
     DumpRenderTree *m_drt;
 };
 
+class WebViewGraphicsBased : public QGraphicsView {
+    Q_OBJECT
+
+public:
+    WebViewGraphicsBased(QWidget* parent);
+    QGraphicsWebView* graphicsView() const { return m_item; }
+    void setPage(QWebPage* page) { m_item->setPage(page); }
+
+private:
+    QGraphicsWebView* m_item;
+};
+
 }
 
 #endif
diff --git a/WebKitTools/DumpRenderTree/qt/EventSenderQt.cpp b/WebKitTools/DumpRenderTree/qt/EventSenderQt.cpp
index a548a63..7ec505f 100644
--- a/WebKitTools/DumpRenderTree/qt/EventSenderQt.cpp
+++ b/WebKitTools/DumpRenderTree/qt/EventSenderQt.cpp
@@ -29,8 +29,7 @@
 #include "config.h"
 #include "EventSenderQt.h"
 
-//#include <QtDebug>
-
+#include <QGraphicsSceneMouseEvent>
 #include <QtTest/QtTest>
 
 #define KEYCODE_DEL         127
@@ -111,10 +110,16 @@ void EventSender::mouseDown(int button)
     m_mouseButtons |= mouseButton;
 
 //     qDebug() << "EventSender::mouseDown" << frame;
-    QMouseEvent* event;
-    event = new QMouseEvent((m_clickCount == 2) ? QEvent::MouseButtonDblClick :
+    QEvent* event;
+    if (isGraphicsBased()) {
+        event = createGraphicsSceneMouseEvent((m_clickCount == 2) ?
+                    QEvent::GraphicsSceneMouseDoubleClick : QEvent::GraphicsSceneMousePress,
+                    m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier);
+    } else {
+        event = new QMouseEvent((m_clickCount == 2) ? QEvent::MouseButtonDblClick :
                     QEvent::MouseButtonPress, m_mousePos, m_mousePos,
                     mouseButton, m_mouseButtons, Qt::NoModifier);
+    }
 
     sendOrQueueEvent(event);
 
@@ -146,7 +151,15 @@ void EventSender::mouseUp(int button)
     m_mouseButtons &= ~mouseButton;
 
 //     qDebug() << "EventSender::mouseUp" << frame;
-    QMouseEvent* event = new QMouseEvent(QEvent::MouseButtonRelease, m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier);
+    QEvent* event;
+    if (isGraphicsBased()) {
+        event = createGraphicsSceneMouseEvent(QEvent::GraphicsSceneMouseRelease,
+                    m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier);
+    } else {
+        event = new QMouseEvent(QEvent::MouseButtonRelease,
+                    m_mousePos, m_mousePos, mouseButton, m_mouseButtons, Qt::NoModifier);
+    }
+
     sendOrQueueEvent(event);
 }
 
@@ -154,7 +167,16 @@ void EventSender::mouseMoveTo(int x, int y)
 {
 //     qDebug() << "EventSender::mouseMoveTo" << x << y;
     m_mousePos = QPoint(x, y);
-    QMouseEvent* event = new QMouseEvent(QEvent::MouseMove, m_mousePos, m_mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier);
+
+    QEvent* event;
+    if (isGraphicsBased()) {
+        event = createGraphicsSceneMouseEvent(QEvent::GraphicsSceneMouseMove,
+                    m_mousePos, m_mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier);
+    } else {
+        event = new QMouseEvent(QEvent::MouseMove,
+                    m_mousePos, m_mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier);
+    }
+
     sendOrQueueEvent(event);
 }
 
@@ -306,19 +328,19 @@ void EventSender::keyDown(const QString& string, const QStringList& modifiers, u
         }
     }
     QKeyEvent event(QEvent::KeyPress, code, modifs, s);
-    QApplication::sendEvent(m_page, &event);
+    sendEvent(m_page, &event);
     QKeyEvent event2(QEvent::KeyRelease, code, modifs, s);
-    QApplication::sendEvent(m_page, &event2);
+    sendEvent(m_page, &event2);
 }
 
 void EventSender::contextClick()
 {
     QMouseEvent event(QEvent::MouseButtonPress, m_mousePos, Qt::RightButton, Qt::RightButton, Qt::NoModifier);
-    QApplication::sendEvent(m_page, &event);
+    sendEvent(m_page, &event);
     QMouseEvent event2(QEvent::MouseButtonRelease, m_mousePos, Qt::RightButton, Qt::RightButton, Qt::NoModifier);
-    QApplication::sendEvent(m_page, &event2);
+    sendEvent(m_page, &event2);
     QContextMenuEvent event3(QContextMenuEvent::Mouse, m_mousePos);
-    QApplication::sendEvent(m_page->view(), &event3);
+    sendEvent(m_page->view(), &event3);
 }
 
 void EventSender::scheduleAsynchronousClick()
@@ -431,7 +453,7 @@ void EventSender::sendTouchEvent(QEvent::Type type)
 #if QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)
     QTouchEvent event(type, QTouchEvent::TouchScreen, m_touchModifiers);
     event.setTouchPoints(m_touchPoints);
-    QApplication::sendEvent(m_page, &event);
+    sendEvent(m_page, &event);
     QList<QTouchEvent::TouchPoint>::Iterator it = m_touchPoints.begin();
     while (it != m_touchPoints.end()) {
         if (it->state() == Qt::TouchPointReleased)
@@ -493,7 +515,7 @@ void EventSender::sendOrQueueEvent(QEvent* event)
     // 3. A call to mouseMoveTo while the mouse button is pressed could initiate a drag operation, and that does not return until mouseUp is processed. 
     // To be safe and avoid a deadlock, this event is queued.
     if (endOfQueue == startOfQueue && !eventQueue[endOfQueue].m_delay && (!(m_mouseButtonPressed && (m_eventLoop && event->type() == QEvent::MouseButtonRelease)))) {
-        QApplication::sendEvent(m_page->view(), event);
+        sendEvent(m_page->view(), event);
         delete event;
         return;
     }
@@ -541,13 +563,16 @@ bool EventSender::eventFilter(QObject* watched, QEvent* event)
     case QEvent::Leave:
         return true;
     case QEvent::MouseButtonPress:
+    case QEvent::GraphicsSceneMousePress:
         m_mouseButtonPressed = true;
         break;
     case QEvent::MouseMove:
+    case QEvent::GraphicsSceneMouseMove:
         if (m_mouseButtonPressed)
             m_drag = true;
         break;
     case QEvent::MouseButtonRelease:
+    case QEvent::GraphicsSceneMouseRelease:
         m_mouseButtonPressed = false;
         m_drag = false;
         break;
@@ -562,3 +587,24 @@ void EventSender::timerEvent(QTimerEvent* ev)
 {
     m_clickTimer.stop();
 }
+
+QGraphicsSceneMouseEvent* EventSender::createGraphicsSceneMouseEvent(QEvent::Type type, const QPoint& pos, const QPoint& screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
+{
+    QGraphicsSceneMouseEvent* event;
+    event = new QGraphicsSceneMouseEvent(type);
+    event->setPos(pos);
+    event->setScreenPos(screenPos);
+    event->setButton(button);
+    event->setButtons(buttons);
+    event->setModifiers(modifiers);
+
+    return event;
+}
+
+void EventSender::sendEvent(QObject* receiver, QEvent* event)
+{
+    if (WebCore::WebViewGraphicsBased* view = qobject_cast<WebCore::WebViewGraphicsBased*>(receiver))
+        view->scene()->sendEvent(view->graphicsView(), event);
+    else
+        QApplication::sendEvent(receiver, event);
+}
diff --git a/WebKitTools/DumpRenderTree/qt/EventSenderQt.h b/WebKitTools/DumpRenderTree/qt/EventSenderQt.h
index d5b45ac..51c8325 100644
--- a/WebKitTools/DumpRenderTree/qt/EventSenderQt.h
+++ b/WebKitTools/DumpRenderTree/qt/EventSenderQt.h
@@ -29,6 +29,9 @@
 #ifndef EventSenderQt_h
 #define EventSenderQt_h
 
+
+#include "DumpRenderTreeQt.h"
+
 #include <QApplication>
 #include <QBasicTimer>
 #include <QEvent>
@@ -83,6 +86,11 @@ protected:
     void timerEvent(QTimerEvent*);
 
 private:
+    bool isGraphicsBased() const { return qobject_cast<WebCore::WebViewGraphicsBased*>(m_page->view()); }
+    QGraphicsSceneMouseEvent* createGraphicsSceneMouseEvent(QEvent::Type, const QPoint& pos, const QPoint& screenPos, Qt::MouseButton, Qt::MouseButtons, Qt::KeyboardModifiers);
+    void sendEvent(QObject* receiver, QEvent* event);
+
+private:
     void sendTouchEvent(QEvent::Type);
     void sendOrQueueEvent(QEvent*);
     void replaySavedEvents(bool flush);
diff --git a/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.cpp b/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.cpp
index 9079be2..8450376 100644
--- a/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.cpp
+++ b/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.cpp
@@ -410,7 +410,7 @@ void LayoutTestController::setMainFrameIsFirstResponder(bool isFirst)
 
 void LayoutTestController::setJavaScriptCanAccessClipboard(bool enable)
 {
-    m_drt->webPage()->settings()->setAttribute(QWebSettings::JavaScriptCanAccessClipboard, enable);
+    m_drt->webPage()->settings()->setAttribute(QWebSettings::JavascriptCanAccessClipboard, enable);
 }
 
 void LayoutTestController::setXSSAuditorEnabled(bool enable)
@@ -513,6 +513,8 @@ void LayoutTestController::overridePreference(const QString& name, const QVarian
         setCaretBrowsingEnabled(value.toBool());
     else if (name == "WebKitPluginsEnabled")
         settings->setAttribute(QWebSettings::PluginsEnabled, value.toBool());
+    else if (name == "WebKitWebGLEnabled")
+        settings->setAttribute(QWebSettings::WebGLEnabled, value.toBool());
     else
         printf("ERROR: LayoutTestController::overridePreference() does not support the '%s' preference\n",
             name.toLatin1().data());
@@ -564,8 +566,7 @@ int LayoutTestController::numberOfPages(float width, float height)
 
 bool LayoutTestController::callShouldCloseOnWebView()
 {
-    // FIXME: Implement for testing fix for https://bugs.webkit.org/show_bug.cgi?id=27481
-    return false;
+    return DumpRenderTreeSupportQt::shouldClose(m_drt->webPage()->mainFrame());
 }
 
 void LayoutTestController::setScrollbarPolicy(const QString& orientation, const QString& policy)
@@ -645,5 +646,21 @@ void LayoutTestController::setEditingBehavior(const QString& editingBehavior)
     DumpRenderTreeSupportQt::setEditingBehavior(m_drt->webPage(), editingBehavior);
 }
 
+void LayoutTestController::setGeolocationPermission(bool allow)
+{
+     m_isGeolocationPermissionSet = true;
+     m_geolocationPermission = allow;
+}
+
+void LayoutTestController::setMockGeolocationError(int code, const QString& message)
+{
+    DumpRenderTreeSupportQt::setMockGeolocationError(code, message);
+}
+
+void LayoutTestController::setMockGeolocationPosition(double latitude, double longitude, double accuracy)
+{
+    DumpRenderTreeSupportQt::setMockGeolocationPosition(latitude, longitude, accuracy);
+}
+
 const unsigned LayoutTestController::maxViewWidth = 800;
 const unsigned LayoutTestController::maxViewHeight = 600;
diff --git a/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.h b/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.h
index d7bb839..a041ad0 100644
--- a/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.h
+++ b/WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.h
@@ -180,6 +180,15 @@ public slots:
     int pageNumberForElementById(const QString& id, float width = 0, float height = 0);
     int numberOfPages(float width = maxViewWidth, float height = maxViewHeight);
     bool callShouldCloseOnWebView();
+    // For now, this is a no-op. This may change depending on outcome of
+    // https://bugs.webkit.org/show_bug.cgi?id=33333
+    void setCallCloseOnWebViews() {}
+
+    void setMockGeolocationError(int code, const QString& message);
+    void setMockGeolocationPosition(double latitude, double longitude, double accuracy);
+    void setGeolocationPermission(bool allow);
+    bool isGeolocationPermissionSet() const { return m_isGeolocationPermissionSet; }
+    bool geolocationPermission() const { return m_geolocationPermission; }
 
     /*
         Policy values: 'on', 'auto' or 'off'.
@@ -212,6 +221,8 @@ private:
     bool m_handleErrorPages;
     bool m_loadFinished;
     bool m_globalFlag;
+    bool m_isGeolocationPermissionSet;
+    bool m_geolocationPermission;
 
     QUrl m_userStyleSheetLocation;
     QBasicTimer m_timeoutTimer;