Attachment #272111 for bug #150955

View Details Raw Unified Return to Bug 150955

| Differences between



typedef HashMap<uint32_t, GUniquePtr<GdkEvent>> TouchEventsMap;

struct _WebKitWebViewBasePrivate {
    _WebKitWebViewBasePrivate()
        : updateViewStateTimer(RunLoop::main(), this, &_WebKitWebViewBasePrivate::updateViewStateTimerFired)
    {
    }

    void updateViewStateTimerFired()
    {
        if (!pageProxy)
            return;
        pageProxy->viewStateDidChange(viewStateFlagsToUpdate);
        viewStateFlagsToUpdate = ViewState::NoFlags;
    }

    WebKitWebViewChildrenMap children;
    std::unique_ptr<PageClientImpl> pageClient;
    RefPtr<WebPageProxy> pageProxy;

    GtkWindow* toplevelOnScreenWindow;
    unsigned long toplevelFocusInEventID;
    unsigned long toplevelFocusOutEventID;
    unsigned long toplevelWindowStateEventID;

    // View State.
    ViewState::Flags viewState;
    ViewState::Flags viewStateFlagsToUpdate;
    RunLoop::Timer<WebKitWebViewBasePrivate> updateViewStateTimer;
    bool isWindowVisible : 1;

    WebKitWebViewBaseDownloadRequestHandler downloadHandler;



WEBKIT_DEFINE_TYPE(WebKitWebViewBase, webkit_web_view_base, GTK_TYPE_CONTAINER)

static void webkitWebViewBaseScheduleUpdateViewState(WebKitWebViewBase* webViewBase, ViewState::Flags flagsToUpdate)
{
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    priv->viewStateFlagsToUpdate |= flagsToUpdate;
    if (priv->updateViewStateTimer.isActive())
        return;

    priv->updateViewStateTimer.startOneShot(0);
}

static gboolean toplevelWindowFocusInEvent(GtkWidget*, GdkEventFocus*, WebKitWebViewBase* webViewBase)
{
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (priv->viewState & ViewState::WindowIsActive)
        return FALSE;

    priv->viewState |= ViewState::WindowIsActive;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::WindowIsActive);

    return FALSE;
}

static gboolean toplevelWindowFocusOutEvent(GtkWidget*, GdkEventFocus*, WebKitWebViewBase* webViewBase)
{
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (!(priv->viewState & ViewState::WindowIsActive))
        return FALSE;

    priv->viewState &= ~ViewState::WindowIsActive;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::WindowIsActive);

    return FALSE;
}

static gboolean toplevelWindowStateEvent(GtkWidget*, GdkEventWindowState* event, WebKitWebViewBase* webViewBase)
{
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (!(event->changed_mask & GDK_WINDOW_STATE_ICONIFIED))
        return FALSE;

    bool visible = !(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED);
    if ((visible && priv->viewState & ViewState::IsVisible) || (!visible && !(priv->viewState & ViewState::IsVisible)))
        return FALSE;

    if (visible)
        priv->viewState |= ViewState::IsVisible;
    else
        priv->viewState &= ~ViewState::IsVisible;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);

    return FALSE;
}

        g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelFocusOutEventID);
        priv->toplevelFocusOutEventID = 0;
    }
    if (priv->toplevelWindowStateEventID) {
        g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelWindowStateEventID);
        priv->toplevelWindowStateEventID = 0;
    }

    priv->toplevelOnScreenWindow = window;
    if (!(priv->viewState & ViewState::IsInWindow)) {
        priv->viewState |= ViewState::IsInWindow;
        webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsInWindow);
    }
    if (!priv->toplevelOnScreenWindow)
        return;


    priv->toplevelFocusOutEventID =
        g_signal_connect(priv->toplevelOnScreenWindow, "focus-out-event",
                         G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);
    priv->toplevelWindowStateEventID =
        g_signal_connect(priv->toplevelOnScreenWindow, "window-state-event", G_CALLBACK(toplevelWindowStateEvent), webViewBase);
                         G_CALLBACK(toplevelWindowVisibilityEvent), webViewBase);
}

static void webkitWebViewBaseRealize(GtkWidget* widget)


    WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (priv->viewState & ViewState::IsVisible)
        return;

    priv->viewState |= ViewState::IsVisible;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);
}

static void webkitWebViewBaseUnmap(GtkWidget* widget)
{
    GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->unmap(widget);

    WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (!(priv->viewState & ViewState::IsVisible))
        return;

    priv->viewState &= ~ViewState::IsVisible;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);
}

static gboolean webkitWebViewBaseFocusInEvent(GtkWidget* widget, GdkEventFocus* event)

void webkitWebViewBaseSetFocus(WebKitWebViewBase* webViewBase, bool focused)
{
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if ((focused && priv->viewState & ViewState::IsFocused) || (!focused && !(priv->viewState & ViewState::IsFocused)))
        return;

    ViewState::Flags flagsToUpdate = ViewState::IsFocused;
    if (focused) {
        priv->viewState |= ViewState::IsFocused;

        // If the view has received the focus and the window is not active
        // mark the current window as active now. This can happen if the
        // toplevel window is a GTK_WINDOW_POPUP and the focus has been
        // set programatically like WebKitTestRunner does, because POPUP
        // can't be focused.
        if (!(priv->viewState & ViewState::WindowIsActive)) {
            priv->viewState |= ViewState::WindowIsActive;
            flagsToUpdate |= ViewState::WindowIsActive;
        }
    } else
        priv->viewState &= ~ViewState::IsFocused;

    webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);
}

bool webkitWebViewBaseIsInWindowActive(WebKitWebViewBase* webViewBase)
{
    return webViewBase->priv->viewState & ViewState::WindowIsActive;
}

bool webkitWebViewBaseIsFocused(WebKitWebViewBase* webViewBase)
{
    return webViewBase->priv->viewState & ViewState::IsFocused;
}

bool webkitWebViewBaseIsVisible(WebKitWebViewBase* webViewBase)
{
    return webViewBase->priv->viewState & ViewState::IsVisible;
}

bool webkitWebViewBaseIsInWindow(WebKitWebViewBase* webViewBase)
{
    return webViewBase->priv->viewState & ViewState::IsInWindow;
}

bool webkitWebViewBaseIsWindowVisible(WebKitWebViewBase* webViewBase)
{
    return webViewBase->priv->isWindowVisible;
}

void webkitWebViewBaseSetDownloadRequestHandler(WebKitWebViewBase* webViewBase, WebKitWebViewBaseDownloadRequestHandler downloadHandler)



bool webkitWebViewBaseIsFocused(WebKitWebViewBase*);
bool webkitWebViewBaseIsVisible(WebKitWebViewBase*);
bool webkitWebViewBaseIsInWindow(WebKitWebViewBase*);
bool webkitWebViewBaseIsWindowVisible(WebKitWebViewBase*);

typedef void (*WebKitWebViewBaseDownloadRequestHandler) (WebKitWebViewBase*, WebKit::DownloadProxy*);
void webkitWebViewBaseSetDownloadRequestHandler(WebKitWebViewBase*, WebKitWebViewBaseDownloadRequestHandler);
- 
https://bugs.webkit.org/show_bug.cgi?id=150955
--
Source/WebCore/platform/gtk/GtkUtilities.cpp       |  2 +-
.../UIProcess/API/gtk/WebKitWebViewBase.cpp        | 63 ++++++++++++++++------
.../WebKit2/UIProcess/cairo/BackingStoreCairo.cpp  |  6 +--
3 files changed, 50 insertions(+), 21 deletions(-)

Lines 51-57 IntPoint convertWidgetPointToScreenPoint(GtkWidget* widget, const IntPoint& poin a/Source/WebCore/platform/gtk/GtkUtilities.cpp_sec1
- a/Source/WebCore/platform/gtk/GtkUtilities.cpp -1 / +1 lines
51		51
52	bool widgetIsOnscreenToplevelWindow(GtkWidget* widget)	52	bool widgetIsOnscreenToplevelWindow(GtkWidget* widget)
53	{	53	{
54	return gtk_widget_is_toplevel(widget) && GTK_IS_WINDOW(widget) && !GTK_IS_OFFSCREEN_WINDOW(widget);	54	return widget && gtk_widget_is_toplevel(widget) && GTK_IS_WINDOW(widget) && !GTK_IS_OFFSCREEN_WINDOW(widget);
55	}	55	}
56		56
57	#if ENABLE(DEVELOPER_MODE)	57	#if ENABLE(DEVELOPER_MODE)



    priv->updateViewStateTimer.startOneShot(0);
}

static gboolean toplevelWindowFocusInEvent(GtkWidget* widget, GdkEventFocus*, WebKitWebViewBase* webViewBase)
{
    // Spurious focus in events can occur when the window is hidden.
    if (!gtk_widget_get_visible(widget))
        return FALSE;

    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    if (priv->viewState & ViewState::WindowIsActive)
        return FALSE;

    }

    priv->toplevelOnScreenWindow = window;

    if (!priv->toplevelOnScreenWindow) {
        ViewState::Flags flagsToUpdate = 0;
        if (priv->viewState & ViewState::IsInWindow) {
            priv->viewState &= ~ViewState::IsInWindow;
            flagsToUpdate |= ViewState::IsInWindow;
        }
        if (priv->viewState & ViewState::WindowIsActive) {
            priv->viewState &= ~ViewState::WindowIsActive;
            flagsToUpdate |= ViewState::IsInWindow;
        }
        if (flagsToUpdate)
            webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);

        return;
    }

    priv->toplevelFocusInEventID =
        g_signal_connect(priv->toplevelOnScreenWindow, "focus-in-event",

                         G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);
    priv->toplevelWindowStateEventID =
        g_signal_connect(priv->toplevelOnScreenWindow, "window-state-event", G_CALLBACK(toplevelWindowStateEvent), webViewBase);
    gtk_widget_realize(GTK_WIDGET(webViewBase));
}

static void webkitWebViewBaseRealize(GtkWidget* widget)

    gtk_style_context_set_background(gtk_widget_get_style_context(widget), window);

    gtk_im_context_set_client_window(priv->inputMethodFilter.context(), window);

    GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
    if (widgetIsOnscreenToplevelWindow(toplevel))
        webkitWebViewBaseSetToplevelOnScreenWindow(webView, GTK_WINDOW(toplevel));
}

static void webkitWebViewBaseUnrealize(GtkWidget* widget)


    WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    ViewState::Flags flagsToUpdate = 0;
    if (!(priv->viewState & ViewState::IsVisible))
        flagsToUpdate |= ViewState::IsVisible;
    if (priv->toplevelOnScreenWindow) {
        if (!(priv->viewState & ViewState::IsInWindow))
            flagsToUpdate |= ViewState::IsInWindow;
        if (gtk_window_is_active(GTK_WINDOW(priv->toplevelOnScreenWindow)) && !(priv->viewState & ViewState::WindowIsActive))
            flagsToUpdate |= ViewState::WindowIsActive;
    }
    if (!flagsToUpdate)
        return;

    priv->viewState |= flagsToUpdate;
    webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);
}

static void webkitWebViewBaseUnmap(GtkWidget* widget)

}
#endif // ENABLE(DRAG_SUPPORT)

static void webkitWebViewBaseHierarchyChanged(GtkWidget* widget, GtkWidget* oldToplevel)
{
    WebKitWebViewBasePrivate* priv = WEBKIT_WEB_VIEW_BASE(widget)->priv;
    if (widgetIsOnscreenToplevelWindow(oldToplevel) && GTK_WINDOW(oldToplevel) == priv->toplevelOnScreenWindow) {
        webkitWebViewBaseSetToplevelOnScreenWindow(WEBKIT_WEB_VIEW_BASE(widget), nullptr);
        return;
    }

    if (!oldToplevel) {
        GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
        if (widgetIsOnscreenToplevelWindow(toplevel))
            webkitWebViewBaseSetToplevelOnScreenWindow(WEBKIT_WEB_VIEW_BASE(widget), GTK_WINDOW(toplevel));
    }
}

static gboolean webkitWebViewBaseFocus(GtkWidget* widget, GtkDirectionType direction)

    widgetClass->drag_data_received = webkitWebViewBaseDragDataReceived;
#endif // ENABLE(DRAG_SUPPORT)
    widgetClass->get_accessible = webkitWebViewBaseGetAccessible;
    widgetClass->hierarchy_changed = webkitWebViewBaseHierarchyChanged;
    widgetClass->destroy = webkitWebViewBaseDestroy;

    GObjectClass* gobjectClass = G_OBJECT_CLASS(webkitWebViewBaseClass);



    scaledSize.scale(m_deviceScaleFactor);

#if PLATFORM(GTK)
    RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(m_webPageProxy.viewWidget()),
    gtk_widget_realize(viewWidget);
    RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(viewWidget),
        CAIRO_CONTENT_COLOR_ALPHA, scaledSize.width(), scaledSize.height()));
#else
    RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, scaledSize.width(), scaledSize.height()));

{
    ASSERT(m_backend);

    cairo_save(context);
    cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);
    cairo_set_source_surface(context, m_backend->surface(), 0, 0);
    cairo_rectangle(context, rect.x(), rect.y(), rect.width(), rect.height());
    cairo_fill(context);
    cairo_restore(context);
}

void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)
- 

Return to Bug 150955

Lines 149-154 typedef HashMap<GtkWidget*, IntRect> WebKitWebViewChildrenMap; a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec1
- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp -58 / +93 lines
149	typedef HashMap<uint32_t, GUniquePtr<GdkEvent>> TouchEventsMap;	149	typedef HashMap<uint32_t, GUniquePtr<GdkEvent>> TouchEventsMap;
150		150
151	struct _WebKitWebViewBasePrivate {	151	struct _WebKitWebViewBasePrivate {
		152	_WebKitWebViewBasePrivate()
		153	: updateViewStateTimer(RunLoop::main(), this, &_WebKitWebViewBasePrivate::updateViewStateTimerFired)
		154	{
		155	}
		156
		157	void updateViewStateTimerFired()
		158	{
		159	if (!pageProxy)
		160	return;
		161	pageProxy->viewStateDidChange(viewStateFlagsToUpdate);
		162	viewStateFlagsToUpdate = ViewState::NoFlags;
		163	}
		164
152	WebKitWebViewChildrenMap children;	165	WebKitWebViewChildrenMap children;
153	std::unique_ptr<PageClientImpl> pageClient;	166	std::unique_ptr<PageClientImpl> pageClient;
154	RefPtr<WebPageProxy> pageProxy;	167	RefPtr<WebPageProxy> pageProxy;
Lines 170-182 struct _WebKitWebViewBasePrivate { a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec2
170	GtkWindow* toplevelOnScreenWindow;	183	GtkWindow* toplevelOnScreenWindow;
171	unsigned long toplevelFocusInEventID;	184	unsigned long toplevelFocusInEventID;
172	unsigned long toplevelFocusOutEventID;	185	unsigned long toplevelFocusOutEventID;
173	unsigned long toplevelVisibilityEventID;	186	unsigned long toplevelWindowStateEventID;
174		187
175	// View State.	188	// View State.
176	bool isInWindowActive : 1;	189	ViewState::Flags viewState;
177	bool isFocused : 1;	190	ViewState::Flags viewStateFlagsToUpdate;
178	bool isVisible : 1;	191	RunLoop::Timer<WebKitWebViewBasePrivate> updateViewStateTimer;
179	bool isWindowVisible : 1;
180		192
181	WebKitWebViewBaseDownloadRequestHandler downloadHandler;	193	WebKitWebViewBaseDownloadRequestHandler downloadHandler;
182		194
Lines 204-216 struct _WebKitWebViewBasePrivate { a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec3
204		216
205	WEBKIT_DEFINE_TYPE(WebKitWebViewBase, webkit_web_view_base, GTK_TYPE_CONTAINER)	217	WEBKIT_DEFINE_TYPE(WebKitWebViewBase, webkit_web_view_base, GTK_TYPE_CONTAINER)
206		218
		219	static void webkitWebViewBaseScheduleUpdateViewState(WebKitWebViewBase* webViewBase, ViewState::Flags flagsToUpdate)
		220	{
		221	WebKitWebViewBasePrivate* priv = webViewBase->priv;
		222	priv->viewStateFlagsToUpdate \|= flagsToUpdate;
		223	if (priv->updateViewStateTimer.isActive())
		224	return;
		225
		226	priv->updateViewStateTimer.startOneShot(0);
		227	}
		228
207	static gboolean toplevelWindowFocusInEvent(GtkWidget, GdkEventFocus, WebKitWebViewBase* webViewBase)	229	static gboolean toplevelWindowFocusInEvent(GtkWidget, GdkEventFocus, WebKitWebViewBase* webViewBase)
208	{	230	{
209	WebKitWebViewBasePrivate* priv = webViewBase->priv;	231	WebKitWebViewBasePrivate* priv = webViewBase->priv;
210	if (!priv->isInWindowActive) {	232	if (priv->viewState & ViewState::WindowIsActive)
211	priv->isInWindowActive = true;	233	return FALSE;
212	priv->pageProxy->viewStateDidChange(ViewState::WindowIsActive);	234
213	}	235	priv->viewState \|= ViewState::WindowIsActive;
		236	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::WindowIsActive);
214		237
215	return FALSE;	238	return FALSE;
216	}	239	}
Lines 218-239 static gboolean toplevelWindowFocusInEvent(GtkWidget, GdkEventFocus, WebKitWeb a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec4
218	static gboolean toplevelWindowFocusOutEvent(GtkWidget, GdkEventFocus, WebKitWebViewBase* webViewBase)	241	static gboolean toplevelWindowFocusOutEvent(GtkWidget, GdkEventFocus, WebKitWebViewBase* webViewBase)
219	{	242	{
220	WebKitWebViewBasePrivate* priv = webViewBase->priv;	243	WebKitWebViewBasePrivate* priv = webViewBase->priv;
221	if (priv->isInWindowActive) {	244	if (!(priv->viewState & ViewState::WindowIsActive))
222	priv->isInWindowActive = false;	245	return FALSE;
223	priv->pageProxy->viewStateDidChange(ViewState::WindowIsActive);	246
224	}	247	priv->viewState &= ~ViewState::WindowIsActive;
		248	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::WindowIsActive);
225		249
226	return FALSE;	250	return FALSE;
227	}	251	}
228		252
229	static gboolean toplevelWindowVisibilityEvent(GtkWidget, GdkEventVisibility visibilityEvent, WebKitWebViewBase* webViewBase)	253	static gboolean toplevelWindowStateEvent(GtkWidget, GdkEventWindowState event, WebKitWebViewBase* webViewBase)
230	{	254	{
231	WebKitWebViewBasePrivate* priv = webViewBase->priv;	255	WebKitWebViewBasePrivate* priv = webViewBase->priv;
232	bool isWindowVisible = visibilityEvent->state != GDK_VISIBILITY_FULLY_OBSCURED;	256	if (!(event->changed_mask & GDK_WINDOW_STATE_ICONIFIED))
233	if (priv->isWindowVisible != isWindowVisible) {	257	return FALSE;
234	priv->isWindowVisible = isWindowVisible;	258
235	priv->pageProxy->viewStateDidChange(ViewState::IsVisible);	259	bool visible = !(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED);
236	}	260	if ((visible && priv->viewState & ViewState::IsVisible) \|\| (!visible && !(priv->viewState & ViewState::IsVisible)))
		261	return FALSE;
		262
		263	if (visible)
		264	priv->viewState \|= ViewState::IsVisible;
		265	else
		266	priv->viewState &= ~ViewState::IsVisible;
		267	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);
237		268
238	return FALSE;	269	return FALSE;
239	}	270	}
Lines 252-264 static void webkitWebViewBaseSetToplevelOnScreenWindow(WebKitWebViewBase* webVie a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec5
252	g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelFocusOutEventID);	283	g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelFocusOutEventID);
253	priv->toplevelFocusOutEventID = 0;	284	priv->toplevelFocusOutEventID = 0;
254	}	285	}
255	if (priv->toplevelVisibilityEventID) {	286	if (priv->toplevelWindowStateEventID) {
256	g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelVisibilityEventID);	287	g_signal_handler_disconnect(priv->toplevelOnScreenWindow, priv->toplevelWindowStateEventID);
257	priv->toplevelVisibilityEventID = 0;	288	priv->toplevelWindowStateEventID = 0;
258	}	289	}
259		290
260	priv->toplevelOnScreenWindow = window;	291	priv->toplevelOnScreenWindow = window;
261	priv->pageProxy->viewStateDidChange(ViewState::IsInWindow);	292	if (!(priv->viewState & ViewState::IsInWindow)) {
		293	priv->viewState \|= ViewState::IsInWindow;
		294	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsInWindow);
		295	}
262	if (!priv->toplevelOnScreenWindow)	296	if (!priv->toplevelOnScreenWindow)
263	return;	297	return;
264		298
Lines 268-276 static void webkitWebViewBaseSetToplevelOnScreenWindow(WebKitWebViewBase* webVie a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec6
268	priv->toplevelFocusOutEventID =	302	priv->toplevelFocusOutEventID =
269	g_signal_connect(priv->toplevelOnScreenWindow, "focus-out-event",	303	g_signal_connect(priv->toplevelOnScreenWindow, "focus-out-event",
270	G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);	304	G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);
271	priv->toplevelVisibilityEventID =	305	priv->toplevelWindowStateEventID =
272	g_signal_connect(priv->toplevelOnScreenWindow, "visibility-notify-event",	306	g_signal_connect(priv->toplevelOnScreenWindow, "window-state-event", G_CALLBACK(toplevelWindowStateEvent), webViewBase);
273	G_CALLBACK(toplevelWindowVisibilityEvent), webViewBase);
274	}	307	}
275		308
276	static void webkitWebViewBaseRealize(GtkWidget* widget)	309	static void webkitWebViewBaseRealize(GtkWidget* widget)
Lines 626-646 static void webkitWebViewBaseMap(GtkWidget* widget) a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec7
626		659
627	WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);	660	WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
628	WebKitWebViewBasePrivate* priv = webViewBase->priv;	661	WebKitWebViewBasePrivate* priv = webViewBase->priv;
629	if (!priv->isVisible) {	662	if (priv->viewState & ViewState::IsVisible)
630	priv->isVisible = true;	663	return;
631	priv->pageProxy->viewStateDidChange(ViewState::IsVisible);	664
632	}	665	priv->viewState \|= ViewState::IsVisible;
		666	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);
633	}	667	}
634		668
635	static void webkitWebViewBaseUnmap(GtkWidget* widget)	669	static void webkitWebViewBaseUnmap(GtkWidget* widget)
636	{	670	{
637	GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->unmap(widget);	671	GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->unmap(widget);
638		672
639	WebKitWebViewBasePrivate* priv = WEBKIT_WEB_VIEW_BASE(widget)->priv;	673	WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
640	if (priv->isVisible) {	674	WebKitWebViewBasePrivate* priv = webViewBase->priv;
641	priv->isVisible = false;	675	if (!(priv->viewState & ViewState::IsVisible))
642	priv->pageProxy->viewStateDidChange(ViewState::IsVisible);	676	return;
643	}	677
		678	priv->viewState &= ~ViewState::IsVisible;
		679	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);
644	}	680	}
645		681
646	static gboolean webkitWebViewBaseFocusInEvent(GtkWidget* widget, GdkEventFocus* event)	682	static gboolean webkitWebViewBaseFocusInEvent(GtkWidget* widget, GdkEventFocus* event)
Lines 1333-1379 GdkEvent* webkitWebViewBaseTakeContextMenuEvent(WebKitWebViewBase* webkitWebView a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec8
1333	void webkitWebViewBaseSetFocus(WebKitWebViewBase* webViewBase, bool focused)	1369	void webkitWebViewBaseSetFocus(WebKitWebViewBase* webViewBase, bool focused)
1334	{	1370	{
1335	WebKitWebViewBasePrivate* priv = webViewBase->priv;	1371	WebKitWebViewBasePrivate* priv = webViewBase->priv;
1336	if (priv->isFocused == focused)	1372	if ((focused && priv->viewState & ViewState::IsFocused) \|\| (!focused && !(priv->viewState & ViewState::IsFocused)))
1337	return;	1373	return;
1338		1374
1339	unsigned viewStateFlags = ViewState::IsFocused;	1375	ViewState::Flags flagsToUpdate = ViewState::IsFocused;
1340	priv->isFocused = focused;	1376	if (focused) {
1341		1377	priv->viewState \|= ViewState::IsFocused;
1342	// If the view has received the focus and the window is not active	1378
1343	// mark the current window as active now. This can happen if the	1379	// If the view has received the focus and the window is not active
1344	// toplevel window is a GTK_WINDOW_POPUP and the focus has been	1380	// mark the current window as active now. This can happen if the
1345	// set programatically like WebKitTestRunner does, because POPUP	1381	// toplevel window is a GTK_WINDOW_POPUP and the focus has been
1346	// can't be focused.	1382	// set programatically like WebKitTestRunner does, because POPUP
1347	if (priv->isFocused && !priv->isInWindowActive) {	1383	// can't be focused.
1348	priv->isInWindowActive = true;	1384	if (!(priv->viewState & ViewState::WindowIsActive)) {
1349	viewStateFlags \|= ViewState::WindowIsActive;	1385	priv->viewState \|= ViewState::WindowIsActive;
1350	}	1386	flagsToUpdate \|= ViewState::WindowIsActive;
1351	priv->pageProxy->viewStateDidChange(viewStateFlags);	1387	}
		1388	} else
		1389	priv->viewState &= ~ViewState::IsFocused;
		1390
		1391	webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);
1352	}	1392	}
1353		1393
1354	bool webkitWebViewBaseIsInWindowActive(WebKitWebViewBase* webViewBase)	1394	bool webkitWebViewBaseIsInWindowActive(WebKitWebViewBase* webViewBase)
1355	{	1395	{
1356	return webViewBase->priv->isInWindowActive;	1396	return webViewBase->priv->viewState & ViewState::WindowIsActive;
1357	}	1397	}
1358		1398
1359	bool webkitWebViewBaseIsFocused(WebKitWebViewBase* webViewBase)	1399	bool webkitWebViewBaseIsFocused(WebKitWebViewBase* webViewBase)
1360	{	1400	{
1361	return webViewBase->priv->isFocused;	1401	return webViewBase->priv->viewState & ViewState::IsFocused;
1362	}	1402	}
1363		1403
1364	bool webkitWebViewBaseIsVisible(WebKitWebViewBase* webViewBase)	1404	bool webkitWebViewBaseIsVisible(WebKitWebViewBase* webViewBase)
1365	{	1405	{
1366	return webViewBase->priv->isVisible;	1406	return webViewBase->priv->viewState & ViewState::IsVisible;
1367	}	1407	}
1368		1408
1369	bool webkitWebViewBaseIsInWindow(WebKitWebViewBase* webViewBase)	1409	bool webkitWebViewBaseIsInWindow(WebKitWebViewBase* webViewBase)
1370	{	1410	{
1371	return webViewBase->priv->toplevelOnScreenWindow;	1411	return webViewBase->priv->viewState & ViewState::IsInWindow;
1372	}
1373
1374	bool webkitWebViewBaseIsWindowVisible(WebKitWebViewBase* webViewBase)
1375	{
1376	return webViewBase->priv->isWindowVisible;
1377	}	1412	}
1378		1413
1379	void webkitWebViewBaseSetDownloadRequestHandler(WebKitWebViewBase* webViewBase, WebKitWebViewBaseDownloadRequestHandler downloadHandler)	1414	void webkitWebViewBaseSetDownloadRequestHandler(WebKitWebViewBase* webViewBase, WebKitWebViewBaseDownloadRequestHandler downloadHandler)

Lines 226-233 static void webkitWebViewBaseScheduleUpdateViewState(WebKitWebViewBase* webViewB a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec1
- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp -17 / +46 lines
226	priv->updateViewStateTimer.startOneShot(0);	226	priv->updateViewStateTimer.startOneShot(0);
227	}	227	}
228		228
229	static gboolean toplevelWindowFocusInEvent(GtkWidget, GdkEventFocus, WebKitWebViewBase* webViewBase)	229	static gboolean toplevelWindowFocusInEvent(GtkWidget* widget, GdkEventFocus, WebKitWebViewBase webViewBase)
230	{	230	{
		231	// Spurious focus in events can occur when the window is hidden.
		232	if (!gtk_widget_get_visible(widget))
		233	return FALSE;
		234
231	WebKitWebViewBasePrivate* priv = webViewBase->priv;	235	WebKitWebViewBasePrivate* priv = webViewBase->priv;
232	if (priv->viewState & ViewState::WindowIsActive)	236	if (priv->viewState & ViewState::WindowIsActive)
233	return FALSE;	237	return FALSE;
Lines 289-300 static void webkitWebViewBaseSetToplevelOnScreenWindow(WebKitWebViewBase* webVie a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec2
289	}	293	}
290		294
291	priv->toplevelOnScreenWindow = window;	295	priv->toplevelOnScreenWindow = window;
292	if (!(priv->viewState & ViewState::IsInWindow)) {	296
293	priv->viewState \|= ViewState::IsInWindow;	297	if (!priv->toplevelOnScreenWindow) {
294	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsInWindow);	298	ViewState::Flags flagsToUpdate = 0;
295	}	299	if (priv->viewState & ViewState::IsInWindow) {
296	if (!priv->toplevelOnScreenWindow)	300	priv->viewState &= ~ViewState::IsInWindow;
		301	flagsToUpdate \|= ViewState::IsInWindow;
		302	}
		303	if (priv->viewState & ViewState::WindowIsActive) {
		304	priv->viewState &= ~ViewState::WindowIsActive;
		305	flagsToUpdate \|= ViewState::IsInWindow;
		306	}
		307	if (flagsToUpdate)
		308	webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);
		309
297	return;	310	return;
		311	}
298		312
299	priv->toplevelFocusInEventID =	313	priv->toplevelFocusInEventID =
300	g_signal_connect(priv->toplevelOnScreenWindow, "focus-in-event",	314	g_signal_connect(priv->toplevelOnScreenWindow, "focus-in-event",
Lines 304-309 static void webkitWebViewBaseSetToplevelOnScreenWindow(WebKitWebViewBase* webVie a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec3
304	G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);	318	G_CALLBACK(toplevelWindowFocusOutEvent), webViewBase);
305	priv->toplevelWindowStateEventID =	319	priv->toplevelWindowStateEventID =
306	g_signal_connect(priv->toplevelOnScreenWindow, "window-state-event", G_CALLBACK(toplevelWindowStateEvent), webViewBase);	320	g_signal_connect(priv->toplevelOnScreenWindow, "window-state-event", G_CALLBACK(toplevelWindowStateEvent), webViewBase);
		321	gtk_widget_realize(GTK_WIDGET(webViewBase));
307	}	322	}
308		323
309	static void webkitWebViewBaseRealize(GtkWidget* widget)	324	static void webkitWebViewBaseRealize(GtkWidget* widget)
Lines 372-381 static void webkitWebViewBaseRealize(GtkWidget* widget) a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec4
372	gtk_style_context_set_background(gtk_widget_get_style_context(widget), window);	387	gtk_style_context_set_background(gtk_widget_get_style_context(widget), window);
373		388
374	gtk_im_context_set_client_window(priv->inputMethodFilter.context(), window);	389	gtk_im_context_set_client_window(priv->inputMethodFilter.context(), window);
375
376	GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
377	if (widgetIsOnscreenToplevelWindow(toplevel))
378	webkitWebViewBaseSetToplevelOnScreenWindow(webView, GTK_WINDOW(toplevel));
379	}	390	}
380		391
381	static void webkitWebViewBaseUnrealize(GtkWidget* widget)	392	static void webkitWebViewBaseUnrealize(GtkWidget* widget)
Lines 659-669 static void webkitWebViewBaseMap(GtkWidget* widget) a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec5
659		670
660	WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);	671	WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
661	WebKitWebViewBasePrivate* priv = webViewBase->priv;	672	WebKitWebViewBasePrivate* priv = webViewBase->priv;
662	if (priv->viewState & ViewState::IsVisible)	673	ViewState::Flags flagsToUpdate = 0;
		674	if (!(priv->viewState & ViewState::IsVisible))
		675	flagsToUpdate \|= ViewState::IsVisible;
		676	if (priv->toplevelOnScreenWindow) {
		677	if (!(priv->viewState & ViewState::IsInWindow))
		678	flagsToUpdate \|= ViewState::IsInWindow;
		679	if (gtk_window_is_active(GTK_WINDOW(priv->toplevelOnScreenWindow)) && !(priv->viewState & ViewState::WindowIsActive))
		680	flagsToUpdate \|= ViewState::WindowIsActive;
		681	}
		682	if (!flagsToUpdate)
663	return;	683	return;
664		684
665	priv->viewState \|= ViewState::IsVisible;	685	priv->viewState \|= flagsToUpdate;
666	webkitWebViewBaseScheduleUpdateViewState(webViewBase, ViewState::IsVisible);	686	webkitWebViewBaseScheduleUpdateViewState(webViewBase, flagsToUpdate);
667	}	687	}
668		688
669	static void webkitWebViewBaseUnmap(GtkWidget* widget)	689	static void webkitWebViewBaseUnmap(GtkWidget* widget)
Lines 1061-1070 static gboolean webkitWebViewBaseDragDrop(GtkWidget* widget, GdkDragContext* con a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec6
1061	}	1081	}
1062	#endif // ENABLE(DRAG_SUPPORT)	1082	#endif // ENABLE(DRAG_SUPPORT)
1063		1083
1064	static void webkitWebViewBaseParentSet(GtkWidget* widget, GtkWidget* /* oldParent */)	1084	static void webkitWebViewBaseHierarchyChanged(GtkWidget* widget, GtkWidget* oldToplevel)
1065	{	1085	{
1066	if (!gtk_widget_get_parent(widget))	1086	WebKitWebViewBasePrivate* priv = WEBKIT_WEB_VIEW_BASE(widget)->priv;
1067	webkitWebViewBaseSetToplevelOnScreenWindow(WEBKIT_WEB_VIEW_BASE(widget), 0);	1087	if (widgetIsOnscreenToplevelWindow(oldToplevel) && GTK_WINDOW(oldToplevel) == priv->toplevelOnScreenWindow) {
		1088	webkitWebViewBaseSetToplevelOnScreenWindow(WEBKIT_WEB_VIEW_BASE(widget), nullptr);
		1089	return;
		1090	}
		1091
		1092	if (!oldToplevel) {
		1093	GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
		1094	if (widgetIsOnscreenToplevelWindow(toplevel))
		1095	webkitWebViewBaseSetToplevelOnScreenWindow(WEBKIT_WEB_VIEW_BASE(widget), GTK_WINDOW(toplevel));
		1096	}
1068	}	1097	}
1069		1098
1070	static gboolean webkitWebViewBaseFocus(GtkWidget* widget, GtkDirectionType direction)	1099	static gboolean webkitWebViewBaseFocus(GtkWidget* widget, GtkDirectionType direction)
Lines 1123-1129 static void webkit_web_view_base_class_init(WebKitWebViewBaseClass* webkitWebVie a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp_sec7
1123	widgetClass->drag_data_received = webkitWebViewBaseDragDataReceived;	1152	widgetClass->drag_data_received = webkitWebViewBaseDragDataReceived;
1124	#endif // ENABLE(DRAG_SUPPORT)	1153	#endif // ENABLE(DRAG_SUPPORT)
1125	widgetClass->get_accessible = webkitWebViewBaseGetAccessible;	1154	widgetClass->get_accessible = webkitWebViewBaseGetAccessible;
1126	widgetClass->parent_set = webkitWebViewBaseParentSet;	1155	widgetClass->hierarchy_changed = webkitWebViewBaseHierarchyChanged;
1127	widgetClass->destroy = webkitWebViewBaseDestroy;	1156	widgetClass->destroy = webkitWebViewBaseDestroy;
1128		1157
1129	GObjectClass* gobjectClass = G_OBJECT_CLASS(webkitWebViewBaseClass);	1158	GObjectClass* gobjectClass = G_OBJECT_CLASS(webkitWebViewBaseClass);

Lines 67-75 std::unique_ptr<BackingStoreBackendCairo> BackingStore::createBackend() a/Source/WebKit2/UIProcess/cairo/BackingStoreCairo.cpp_sec1
- a/Source/WebKit2/UIProcess/cairo/BackingStoreCairo.cpp -4 / +3 lines
67	scaledSize.scale(m_deviceScaleFactor);	67	scaledSize.scale(m_deviceScaleFactor);
68		68
69	#if PLATFORM(GTK)	69	#if PLATFORM(GTK)
70	GtkWidget* viewWidget = m_webPageProxy.viewWidget();	70	RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(m_webPageProxy.viewWidget()),
71	gtk_widget_realize(viewWidget);
72	RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(viewWidget),
73	CAIRO_CONTENT_COLOR_ALPHA, scaledSize.width(), scaledSize.height()));	71	CAIRO_CONTENT_COLOR_ALPHA, scaledSize.width(), scaledSize.height()));
74	#else	72	#else
75	RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, scaledSize.width(), scaledSize.height()));	73	RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, scaledSize.width(), scaledSize.height()));
Lines 83-92 void BackingStore::paint(cairo_t* context, const IntRect& rect) a/Source/WebKit2/UIProcess/cairo/BackingStoreCairo.cpp_sec2
83	{	81	{
84	ASSERT(m_backend);	82	ASSERT(m_backend);
85		83
		84	cairo_save(context);
86	cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);	85	cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);
87	cairo_set_source_surface(context, m_backend->surface(), 0, 0);	86	cairo_set_source_surface(context, m_backend->surface(), 0, 0);
88	cairo_rectangle(context, rect.x(), rect.y(), rect.width(), rect.height());	87	cairo_rectangle(context, rect.x(), rect.y(), rect.width(), rect.height());
89	cairo_fill(context);	88	cairo_fill(context);
		89	cairo_restore(context);
90	}	90	}
91		91
92	void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)	92	void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)
93	-