Changeset 108527 in webkit


Ignore:
Timestamp:
Feb 22, 2012 11:20:33 AM (12 years ago)
Author:
Philippe Normand
Message:

Unreviewed, rolling out r108522.
​http://trac.webkit.org/changeset/108522
​https://bugs.webkit.org/show_bug.cgi?id=76181

Broke 4 fullscreen tests on GTK.

Source/WebKit/gtk:

  • WebCoreSupport/ChromeClientGtk.cpp:

(WebKit::ChromeClient::supportsFullScreenForElement):
(WebKit::ChromeClient::enterFullScreenForElement):
(WebKit::ChromeClient::exitFullScreenForElement):

  • WebCoreSupport/ChromeClientGtk.h:

(ChromeClient):

  • tests/testwebview.c:
  • webkit/webkitwebview.cpp:

(webkit_web_view_class_init):

  • webkit/webkitwebview.h:

(_WebKitWebViewClass):

Tools:

  • GtkLauncher/main.c:

(createBrowser):
(createWindow):

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/gtk/ChangeLog

    r108522 r108527  
     12012-02-22  Philippe Normand  <pnormand@igalia.com>
     2
     3        Unreviewed, rolling out r108522.
     4        http://trac.webkit.org/changeset/108522
     5        https://bugs.webkit.org/show_bug.cgi?id=76181
     6
     7        Broke 4 fullscreen tests on GTK.
     8
     9        * WebCoreSupport/ChromeClientGtk.cpp:
     10        (WebKit::ChromeClient::supportsFullScreenForElement):
     11        (WebKit::ChromeClient::enterFullScreenForElement):
     12        (WebKit::ChromeClient::exitFullScreenForElement):
     13        * WebCoreSupport/ChromeClientGtk.h:
     14        (ChromeClient):
     15        * tests/testwebview.c:
     16        * webkit/webkitwebview.cpp:
     17        (webkit_web_view_class_init):
     18        * webkit/webkitwebview.h:
     19        (_WebKitWebViewClass):
     20
    1212012-02-20  Philippe Normand  <pnormand@igalia.com>
    222

  • trunk/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp

    r108522 r108527  
    5252#include "SearchPopupMenuGtk.h"
    5353#include "SecurityOrigin.h"
    54 #include "WebKitDOMBinding.h"
    55 #include "WebKitDOMHTMLElementPrivate.h"
    5654#include "WindowFeatures.h"
    5755#include "webkitgeolocationpolicydecision.h"
    … …  
    6462#include "webkitwebviewprivate.h"
    6563#include "webkitwebwindowfeaturesprivate.h"
    66 #include <gdk/gdk.h>
    67 #include <gdk/gdkkeysyms.h>
    6864#include <glib.h>
    6965#include <glib/gi18n-lib.h>
    … …  
    926922bool ChromeClient::supportsFullScreenForElement(const WebCore::Element* element, bool withKeyboard)
    927923{
    928     return !withKeyboard;
    929 }
    930 
    931 static gboolean onFullscreenGtkKeyPressEvent(GtkWidget* widget, GdkEventKey* event, ChromeClient* chromeClient)
    932 {
    933     switch (event->keyval) {
    934     case GDK_KEY_Escape:
    935     case GDK_KEY_f:
    936     case GDK_KEY_F:
    937         chromeClient->cancelFullScreen();
    938         return TRUE;
    939     default:
    940         break;
    941     }
    942 
    943     return FALSE;
    944 }
    945 
    946 void ChromeClient::cancelFullScreen()
    947 {
    948     ASSERT(m_fullScreenElement);
    949     m_fullScreenElement->document()->webkitCancelFullScreen();
     924    return true;
    950925}
    951926
    952927void ChromeClient::enterFullScreenForElement(WebCore::Element* element)
    953928{
    954     gboolean returnValue;
    955     GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(element))));
    956     g_signal_emit_by_name(m_webView, "entering-fullscreen", kitElement.get(), &returnValue);
    957     if (returnValue)
    958         return;
    959 
    960     GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
    961     if (!widgetIsOnscreenToplevelWindow(window))
    962         return;
    963 
    964     g_signal_connect(window, "key-press-event", G_CALLBACK(onFullscreenGtkKeyPressEvent), this);
    965 
    966     m_fullScreenElement = adoptRef(element);
    967 
    968929    element->document()->webkitWillEnterFullScreenForElement(element);
    969930    m_adjustmentWatcher.disableAllScrollbars();
    970     gtk_window_fullscreen(GTK_WINDOW(window));
     931#if ENABLE(VIDEO)
     932    if (element->tagName() == "VIDEO")
     933        enterFullscreenForNode(static_cast<Node*>(element));
     934#endif
    971935    element->document()->webkitDidEnterFullScreenForElement(element);
    972936}
    … …  
    974938void ChromeClient::exitFullScreenForElement(WebCore::Element* element)
    975939{
    976     gboolean returnValue;
    977     GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(element))));
    978     g_signal_emit_by_name(m_webView, "leaving-fullscreen", kitElement.get(), &returnValue);
    979     if (returnValue)
    980         return;
    981 
    982     GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
    983     ASSERT(widgetIsOnscreenToplevelWindow(window));
    984     g_signal_handlers_disconnect_by_func(window, reinterpret_cast<void*>(onFullscreenGtkKeyPressEvent), this);
    985 
    986940    element->document()->webkitWillExitFullScreenForElement(element);
    987     gtk_window_unfullscreen(GTK_WINDOW(window));
    988941    m_adjustmentWatcher.enableAllScrollbars();
     942#if ENABLE(VIDEO)
     943    if (element->tagName() == "VIDEO")
     944        webViewExitFullscreen(m_webView);
     945#endif
    989946    element->document()->webkitDidExitFullScreenForElement(element);
    990     m_fullScreenElement.clear();
    991947}
    992948#endif

  • trunk/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h

    r108522 r108527  
    156156        virtual void enterFullScreenForElement(Element*);
    157157        virtual void exitFullScreenForElement(Element*);
    158         void cancelFullScreen();
    159158#endif
    160159
    … …  
    188187
    189188        void invalidateWidgetRect(const IntRect&);
    190 #if ENABLE(FULLSCREEN_API)
    191         RefPtr<Element> m_fullScreenElement;
    192 #endif
    193189    };
    194190}

  • trunk/Source/WebKit/gtk/tests/testwebview.c

    r108522 r108527  
    417417}
    418418
    419 static gboolean emitKeyStroke(WebKitWebView* webView)
    420 {
    421     GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
    422     pressEvent->key.keyval = GDK_KEY_f;
    423     GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(webView));
    424     pressEvent->key.window = window;
    425     g_object_ref(pressEvent->key.window);
    426 
    427     GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(window));
    428     gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(manager));
    429 
    430     // When synthesizing an event, an invalid hardware_keycode value
    431     // can cause it to be badly processed by Gtk+.
    432     GdkKeymapKey* keys;
    433     gint n_keys;
    434     if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), GDK_KEY_f, &keys, &n_keys)) {
    435         pressEvent->key.hardware_keycode = keys[0].keycode;
    436         g_free(keys);
    437     }
    438 
    439     GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
    440     gtk_main_do_event(pressEvent);
    441     gdk_event_free(pressEvent);
    442     releaseEvent->key.type = GDK_KEY_RELEASE;
    443     gtk_main_do_event(releaseEvent);
    444     gdk_event_free(releaseEvent);
    445 
    446     return FALSE;
    447 }
    448 
    449 static gboolean entering_fullscreen_cb(WebKitWebView* webView, GObject* element, gboolean blocked)
    450 {
    451     if (blocked)
    452         g_main_loop_quit(loop);
    453     else
    454         g_timeout_add(200, (GSourceFunc) emitKeyStroke, webView);
    455     return blocked;
    456 }
    457 
    458 static gboolean leaving_fullscreen_cb(WebKitWebView* webView, GObject* element, gpointer data)
    459 {
    460     g_main_loop_quit(loop);
    461     return FALSE;
    462 }
    463 
    464 static void test_webkit_web_view_fullscreen(gconstpointer blocked)
    465 {
    466     GtkWidget* window;
    467     GtkWidget* web_view;
    468     WebKitWebSettings *settings;
    469 
    470     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    471     web_view = webkit_web_view_new();
    472 
    473     settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(web_view));
    474     g_object_set(settings, "enable-fullscreen", TRUE, NULL);
    475     webkit_web_view_set_settings(WEBKIT_WEB_VIEW(web_view), settings);
    476 
    477     gtk_container_add(GTK_CONTAINER(window), web_view);
    478 
    479     gtk_widget_show_all(window);
    480 
    481     loop = g_main_loop_new(NULL, TRUE);
    482 
    483     g_signal_connect(web_view, "entering-fullscreen", G_CALLBACK(entering_fullscreen_cb), (gpointer) blocked);
    484     g_signal_connect(web_view, "leaving-fullscreen", G_CALLBACK(leaving_fullscreen_cb), NULL);
    485 
    486     webkit_web_view_load_string(WEBKIT_WEB_VIEW(web_view), "<html><body>"
    487                    "<script>"
    488                    "var eventName = 'keypress';"
    489                    "document.addEventListener(eventName, function () {"
    490                    "    document.documentElement.webkitRequestFullScreen();"
    491                    "}, false);"
    492                    "</script></body></html>", NULL, NULL, NULL);
    493 
    494     g_timeout_add(100, (GSourceFunc) emitKeyStroke, WEBKIT_WEB_VIEW(web_view));
    495     g_main_loop_run(loop);
    496 
    497     gtk_widget_destroy(window);
    498 }
    499 
    500419int main(int argc, char** argv)
    501420{
    … …  
    527446    g_test_add_func("/webkit/webview/webview-in-offscreen-window-does-not-crash", test_webkit_web_view_in_offscreen_window_does_not_crash);
    528447    g_test_add_func("/webkit/webview/webview-does-not-steal-focus", test_webkit_web_view_does_not_steal_focus);
    529     g_test_add_data_func("/webkit/webview/fullscreen", GINT_TO_POINTER(FALSE), test_webkit_web_view_fullscreen);
    530     g_test_add_data_func("/webkit/webview/fullscreen-blocked", GINT_TO_POINTER(TRUE), test_webkit_web_view_fullscreen);
    531448
    532449    return g_test_run ();

  • trunk/Source/WebKit/gtk/webkit/webkitwebview.cpp

    r108522 r108527  
    213213    RESOURCE_CONTENT_LENGTH_RECEIVED,
    214214    RESOURCE_LOAD_FAILED,
    215     ENTERING_FULLSCREEN,
    216     LEAVING_FULLSCREEN,
    217215
    218216    LAST_SIGNAL
    … …  
    13031301}
    13041302
    1305 static gboolean webkit_web_view_real_entering_fullscreen(WebKitWebView* webView)
    1306 {
    1307     return FALSE;
    1308 }
    1309 
    1310 static gboolean webkit_web_view_real_leaving_fullscreen(WebKitWebView* webView)
    1311 {
    1312     return FALSE;
    1313 }
    1314 
    13151303static void webkit_web_view_dispose(GObject* object)
    13161304{
    … …  
    26672655            G_TYPE_NONE, 1,
    26682656            WEBKIT_TYPE_VIEWPORT_ATTRIBUTES);
    2669 
    2670     /**
    2671      * WebKitWebView::entering-fullscreen:
    2672      * @web_view: the #WebKitWebView on which the signal is emitted.
    2673      * @element: the #WebKitDOMHTMLElement which has requested full screen display.
    2674      *
    2675      * Emitted when JavaScript code calls
    2676      * <function>element.webkitRequestFullScreen</function>. If the
    2677      * signal is not handled the WebView will proceed to full screen
    2678      * its top level window. This signal can be used by client code to
    2679      * request permission to the user prior doing the full screen
    2680      * transition and eventually prepare the top-level window
    2681      * (e.g. hide some widgets that would otherwise be part of the
    2682      * full screen window).
    2683      *
    2684      * Returns: %TRUE to stop other handlers from being invoked for the event.
    2685      *    %FALSE to continue emission of the event.
    2686      *
    2687      * Since: 1.9.0
    2688      */
    2689     webkit_web_view_signals[ENTERING_FULLSCREEN] =
    2690             g_signal_new("entering-fullscreen",
    2691                          G_TYPE_FROM_CLASS(webViewClass),
    2692                          G_SIGNAL_RUN_LAST,
    2693                          G_STRUCT_OFFSET(WebKitWebViewClass, entering_fullscreen),
    2694                          g_signal_accumulator_true_handled, 0,
    2695                          webkit_marshal_BOOLEAN__OBJECT,
    2696                          G_TYPE_BOOLEAN, 1, WEBKIT_TYPE_DOM_HTML_ELEMENT);
    2697 
    2698 
    2699     /**
    2700      * WebKitWebView::leaving-fullscreen:
    2701      * @web_view: the #WebKitWebView on which the signal is emitted.
    2702      * @element: the #WebKitDOMHTMLElement which is currently displayed full screen.
    2703      *
    2704      * Emitted when the WebView is about to restore its top level
    2705      * window out of its full screen state. This signal can be used by
    2706      * client code to restore widgets hidden during the
    2707      * entering-fullscreen stage for instance.
    2708      *
    2709      * Returns: %TRUE to stop other handlers from being invoked for the event.
    2710      *    %FALSE to continue emission of the event.
    2711      *
    2712      * Since: 1.9.0
    2713      */
    2714     webkit_web_view_signals[LEAVING_FULLSCREEN] =
    2715             g_signal_new("leaving-fullscreen",
    2716                          G_TYPE_FROM_CLASS(webViewClass),
    2717                          G_SIGNAL_RUN_LAST,
    2718                          G_STRUCT_OFFSET(WebKitWebViewClass, leaving_fullscreen),
    2719                          g_signal_accumulator_true_handled, 0,
    2720                          webkit_marshal_BOOLEAN__OBJECT,
    2721                          G_TYPE_BOOLEAN, 1, WEBKIT_TYPE_DOM_HTML_ELEMENT);
    27222657
    27232658    /*
    … …  
    28292764    webViewClass->move_cursor = webkit_web_view_real_move_cursor;
    28302765    webViewClass->should_allow_editing_action = webkit_web_view_real_should_allow_editing_action;
    2831     webViewClass->entering_fullscreen = webkit_web_view_real_entering_fullscreen;
    2832     webViewClass->leaving_fullscreen = webkit_web_view_real_leaving_fullscreen;
    28332766
    28342767    GObjectClass* objectClass = G_OBJECT_CLASS(webViewClass);

  • trunk/Source/WebKit/gtk/webkit/webkitwebview.h

    r108522 r108527  
    177177    void                       (* redo)                   (WebKitWebView        *web_view);
    178178    gboolean                   (* should_allow_editing_action) (WebKitWebView   *web_view);
    179     gboolean                   (* entering_fullscreen) (WebKitWebView   *web_view);
    180     gboolean                   (* leaving_fullscreen) (WebKitWebView   *web_view);
    181179
    182180    /* Padding for future expansion */
    183181    void (*_webkit_reserved0) (void);
     182    void (*_webkit_reserved1) (void);
     183    void (*_webkit_reserved2) (void);
    184184};
    185185

  • trunk/Tools/ChangeLog

    r108522 r108527  
     12012-02-22  Philippe Normand  <pnormand@igalia.com>
     2
     3        Unreviewed, rolling out r108522.
     4        http://trac.webkit.org/changeset/108522
     5        https://bugs.webkit.org/show_bug.cgi?id=76181
     6
     7        Broke 4 fullscreen tests on GTK.
     8
     9        * GtkLauncher/main.c:
     10        (createBrowser):
     11        (createWindow):
     12
    1132012-02-20  Philippe Normand  <pnormand@igalia.com>
    214

  • trunk/Tools/GtkLauncher/main.c

    r108522 r108527  
    124124}
    125125
    126 static gboolean webViewFullscreenMessageWindowClose(GtkWidget *dialog)
    127 {
    128     if (GTK_IS_WIDGET(dialog))
    129         gtk_widget_destroy(dialog);
    130     return FALSE;
    131 }
    132 
    133 static gboolean webViewWindowStateEvent(GtkWidget *widget, GdkEventWindowState *event, WebKitWebView *webView)
    134 {
    135     if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
    136         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
    137         const gchar *uri = webkit_web_frame_get_uri(frame);
    138         GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
    139         if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
    140             window = 0;
    141 
    142         GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
    143                                                     GTK_DIALOG_MODAL,
    144                                                     GTK_MESSAGE_INFO,
    145                                                     GTK_BUTTONS_CLOSE,
    146                                                     "%s is now full screen. Press ESC or f to exit.", uri);
    147         g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
    148         g_timeout_add(1500, (GSourceFunc) webViewFullscreenMessageWindowClose, dialog);
    149         gtk_dialog_run(GTK_DIALOG(dialog));
    150     }
    151     return TRUE;
    152 }
    153 
    154 static void hideWidget(GtkWidget* widget, gpointer data)
    155 {
    156     if (!GTK_IS_SCROLLED_WINDOW(widget))
    157         gtk_widget_hide(widget);
    158 }
    159 
    160 static void showWidget(GtkWidget* widget, gpointer data)
    161 {
    162     if (!GTK_IS_SCROLLED_WINDOW(widget))
    163         gtk_widget_show(widget);
    164 }
    165 
    166 static gboolean webViewEnteringFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
    167 {
    168     WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
    169     const gchar *uri = webkit_web_frame_get_uri(frame);
    170     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
    171     if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
    172         window = 0;
    173 
    174     GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
    175                                                GTK_DIALOG_MODAL,
    176                                                GTK_MESSAGE_INFO,
    177                                                GTK_BUTTONS_YES_NO,
    178                                                "Allow full screen display of %s ?", uri);
    179     gint result = gtk_dialog_run(GTK_DIALOG(dialog));
    180     if (result == GTK_RESPONSE_YES) {
    181         gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) hideWidget, NULL);
    182         gtk_widget_destroy(GTK_WIDGET(dialog));
    183         return FALSE;
    184     }
    185     gtk_widget_destroy(GTK_WIDGET(dialog));
    186     return TRUE;
    187 }
    188 
    189 static gboolean webViewLeavingFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
    190 {
    191     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
    192     if (gtk_widget_is_toplevel(window) && GTK_IS_WINDOW(window) && !GTK_IS_OFFSCREEN_WINDOW(window))
    193         g_signal_handlers_disconnect_by_func(window, G_CALLBACK(webViewWindowStateEvent), webView);
    194     gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) showWidget, NULL);
    195     return FALSE;
    196 }
    197 
    198 static GtkWidget* createBrowser(GtkWidget* window, GtkWidget* uriEntry, GtkWidget* statusbar, WebKitWebView* webView, GtkWidget* vbox)
     126static GtkWidget* createBrowser(GtkWidget* window, GtkWidget* uriEntry, GtkWidget* statusbar, WebKitWebView* webView)
    199127{
    200128    GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
    … …  
    210138    g_signal_connect(webView, "web-view-ready", G_CALLBACK(webViewReadyCb), window);
    211139    g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), window);
    212     g_signal_connect(webView, "entering-fullscreen", G_CALLBACK(webViewEnteringFullScreen), vbox);
    213     g_signal_connect(webView, "leaving-fullscreen", G_CALLBACK(webViewLeavingFullScreen), vbox);
    214140
    215141    return scrolledWindow;
    … …  
    289215    statusbar = createStatusbar(webView);
    290216    gtk_box_pack_start(GTK_BOX(vbox), createToolbar(uriEntry, webView), FALSE, FALSE, 0);
    291     gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView, vbox), TRUE, TRUE, 0);
     217    gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView), TRUE, TRUE, 0);
    292218    gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
    293219
Note: See TracChangeset for help on using the changeset viewer.