[GTK] Initial implementation of back forward list for WebKit2 GTK+ API

        https://bugs.webkit.org/show_bug.cgi?id=69343

        Reviewed by NOBODY (OOPS!).

        * GNUmakefile.am: Add new files to compilation.

        * UIProcess/API/gtk/WebKitBackForwardList.cpp: Added.

        (webkitBackForwardListFinalize):

        (webkit_back_forward_list_init):

        (webkit_back_forward_list_class_init):

        (webkitBackForwardListGetOrCreateItem): Helper function that

        creates a new WebKitBackForwardListItem for the given

        WebBackForwardListItem or returns it from the cache if it's

        already cached.

        (webkitBackForwardListCreateList): Helper function to convert a

        WKArray of WebBackForwardListItems into a GList of

        WebKitBackForwardListItems.

        (webkitBackForwardListCreate): Create a new WebKitBackForwardList.

        (webkitBackForwardListChanged): Emits changed signal when the back

        forward list changes.

        (webkit_back_forward_list_get_current_item):

        (webkit_back_forward_list_get_back_item):

        (webkit_back_forward_list_get_forward_item):

        (webkit_back_forward_list_get_nth_item):

        (webkit_back_forward_list_get_length):

        (webkit_back_forward_list_get_back_list):

        (webkit_back_forward_list_get_back_list_with_limit):

        (webkit_back_forward_list_get_forward_list):

        (webkit_back_forward_list_get_forward_list_with_limit):

        * UIProcess/API/gtk/WebKitBackForwardList.h: Added.

        * UIProcess/API/gtk/WebKitBackForwardListItem.cpp: Added.

        (webkitBackForwardListItemFinalize):

        (webkit_back_forward_list_item_init):

        (webkit_back_forward_list_item_class_init):

        (historyItemsMap): Global cache for WebKitBackForwardListItems.

        (webkitBackForwardListItemFinalized):

        (webkitBackForwardListItemGetOrCreate): Helper function that

        creates a new WebKitBackForwardListItem for the given

        WebBackForwardListItem or returns it from the global cache if it's

        already cached.

        (webkit_back_forward_list_item_get_uri):

        (webkit_back_forward_list_item_get_title):

        (webkit_back_forward_list_item_get_original_uri):

        * UIProcess/API/gtk/WebKitBackForwardListItem.h: Added.

        * UIProcess/API/gtk/WebKitBackForwardListPrivate.h:

        * UIProcess/API/gtk/WebKitWebLoaderClient.cpp:

        (didChangeBackForwardList): Call webkitBackForwardListChanged() to

        notify that the list has changed.

        (webkitWebLoaderClientAttachLoaderClientToPage): Add

        implementation for didChangeBackForwardList.

        * UIProcess/API/gtk/WebKitWebView.cpp:

        (webkitWebViewSetLoaderClient): Internal function to set the

        loader client.

        (webkitWebViewConstructed): Create the back forward list for the

        view.

        (webkit_web_view_set_loader_client): Use

        webkitWebViewSetLoaderClient().

        (webkit_web_view_get_back_forward_list): Return the back forward

        list.

        * UIProcess/API/gtk/WebKitWebView.h:

        * UIProcess/API/gtk/WebKitWebViewBase.cpp:

        (webkitWebViewBaseCreateWebPage): Return the newly created

        WebPageProxy to avoid having to call webkitWebViewBaseGetPage()

        after creating it.

        * UIProcess/API/gtk/WebKitWebViewBasePrivate.h:

        * UIProcess/API/gtk/tests/GNUmakefile.am: Add new test.

        * UIProcess/API/gtk/tests/TestBackForwardList.cpp: Added.

        (serverCallback):

        (testBackForwardListNavigation):

        (testBackForwardListLimitAndCache):

        (beforeAll):

        (afterAll):

        * UIProcess/API/gtk/tests/TestMain.h:

        (Test::~Test): Checks there are no objects leaked.

        (Test::objectFinalized): Callback called when a GObject is

        deleted, used to remove the watched object the list.

        (Test::watchObject): Add an object to the list of watched objects

        and add a weak pointer to remove it from the list when the object

        is finalized. If there aren't objects leaked, the list should be

        empty when the test finishes.

        * UIProcess/API/gtk/tests/WebViewTest.cpp:

        (WebViewTest::WebViewTest): Watch the web view to make sure it's

        not leaked.

        * UIProcess/API/gtk/tests/WebViewTest.h: Make WebViewTest inherit

        from Test.

        * UIProcess/API/gtk/webkit2.h: Include WebKitBackForwardList.h and

        WebKitBackForwardListItem.h.

        * UIProcess/API/gtk/webkit2marshal.list:

2011-10-20  Carlos Garcia Campos  <cgarcia@igalia.com>

	$(WebKit2)/UIProcess/API/gtk/WebKitBackForwardList.h \

	$(WebKit2)/UIProcess/API/gtk/WebKitBackForwardListItem.h \

	Source/WebKit2/UIProcess/API/gtk/WebKitBackForwardList.h \

	Source/WebKit2/UIProcess/API/gtk/WebKitBackForwardList.cpp \

	Source/WebKit2/UIProcess/API/gtk/WebKitBackForwardListItem.h \

	Source/WebKit2/UIProcess/API/gtk/WebKitBackForwardListItem.cpp \

	Source/WebKit2/UIProcess/API/gtk/WebKitBackForwardListPrivate.h \

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "WebKitBackForwardList.h"

#include "WebKitBackForwardListPrivate.h"

#include "WebKitMarshal.h"

#include <WebKit2/WKBackForwardList.h>

#include <wtf/gobject/GRefPtr.h>

/**

 * SECTION: WebKitBackForwardList

 * @Short_description: List of visited pages

 * @Title: WebKitBackForwardList

 * @See_also: #WebKitWebView, #WebKitBackForwardListItem

 *

 * WebKitBackForwardList maintains a list of visited pages used to

 * used to navigate to recent pages. Items are inserted in the list

 * in the order they are visited.

 *

 * WebKitBackForwardList also maintains the notion of the current item

 * (which is always at index 0), the preceding item (which is at index -1),

 * and the following item (which is at index 1).

 * Methods webkit_web_view_go_back() and webkit_web_view_go_forward() move

 * the current item backward or forward by one. Method

 * webkit_web_view_go_to_back_forward_list_item() sets the current item to the

 * specified item. All other methods returning #WebKitBackForwardListItem<!-- -->s

 * do not change the value of the current item, they just return the requested

 * item or items.

 */

enum {

    CHANGED,

    LAST_SIGNAL

};

typedef HashMap<WKBackForwardListItemRef, GRefPtr<WebKitBackForwardListItem> > BackForwardListItemsMap;

struct _WebKitBackForwardListPrivate {

    WKBackForwardListRef wkList;

    BackForwardListItemsMap itemsMap;

};

static guint signals[LAST_SIGNAL] = { 0, };

G_DEFINE_TYPE(WebKitBackForwardList, webkit_back_forward_list, G_TYPE_OBJECT)

static void webkitBackForwardListFinalize(GObject* object)

{

    WEBKIT_BACK_FORWARD_LIST(object)->priv->~WebKitBackForwardListPrivate();

    G_OBJECT_CLASS(webkit_back_forward_list_parent_class)->finalize(object);

}

static void webkit_back_forward_list_init(WebKitBackForwardList* list)

{

    WebKitBackForwardListPrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(list, WEBKIT_TYPE_BACK_FORWARD_LIST, WebKitBackForwardListPrivate);

    list->priv = priv;

    new (priv) WebKitBackForwardListPrivate();

}

static void webkit_back_forward_list_class_init(WebKitBackForwardListClass* listClass)

{

    GObjectClass* gObjectClass = G_OBJECT_CLASS(listClass);

    gObjectClass->finalize = webkitBackForwardListFinalize;

    /**

     * WebKitBackForwardList::changed:

     * @back_forward_list: the #WebKitBackForwardList on which the signal was emitted

     * @item_added: (allow-none): the #WebKitBackForwardListItem added or %NULL

     * @items_removed: a #GList of #WebKitBackForwardListItem<!-- -->s

     *

     * This signal is emitted when @back_forward_list changes. This happens

     * when the current item is updated, a new item is added or one or more

     * items are removed. Note that both @item_added and @items_removed can

     * %NULL when only the current item is updated. Items are only removed

     * when the list is cleared or the maximum items limit is reached.

     */

    signals[CHANGED] =

        g_signal_new("changed",

                     G_TYPE_FROM_CLASS(listClass),

                     G_SIGNAL_RUN_LAST,

                     0, 0, 0,

                     webkit_marshal_VOID__OBJECT_POINTER,

                     G_TYPE_NONE, 2,

                     WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM,

                     G_TYPE_POINTER);

    g_type_class_add_private(listClass, sizeof(WebKitBackForwardListPrivate));

}

static WebKitBackForwardListItem* webkitBackForwardListGetOrCreateItem(WebKitBackForwardList* list, WKBackForwardListItemRef wkListItem)

{

    if (!wkListItem)

        return 0;

    WebKitBackForwardListPrivate* priv = list->priv;

    GRefPtr<WebKitBackForwardListItem> listItem = priv->itemsMap.get(wkListItem);

    if (listItem)

        return listItem.get();

    listItem = webkitBackForwardListItemGetOrCreate(wkListItem);

    priv->itemsMap.set(wkListItem, listItem);

    return listItem.get();

}

static GList* webkitBackForwardListCreateList(WKArrayRef wkList)

{

    if (!wkList)

        return 0;

    GList* list = 0;

    for (size_t i = 0; i < WKArrayGetSize(wkList); ++i) {

        WKBackForwardListItemRef wkItem = static_cast<WKBackForwardListItemRef>(WKArrayGetItemAtIndex(wkList, i));

        WebKitBackForwardListItem* item = webkitBackForwardListItemGetOrCreate(wkItem);

        if (!item)

            continue;

        list = g_list_prepend(list, item);

    }

    return list;

}

WebKitBackForwardList* webkitBackForwardListCreate(WKBackForwardListRef wkList)

{

    WebKitBackForwardList* list = WEBKIT_BACK_FORWARD_LIST(g_object_new(WEBKIT_TYPE_BACK_FORWARD_LIST, NULL));

    list->priv->wkList = wkList;

    return list;

}

void webkitBackForwardListChanged(WebKitBackForwardList* backForwardList, WKBackForwardListItemRef wkAddedItem, WKArrayRef wkRemovedItems)

{

    WebKitBackForwardListItem* addedItem = webkitBackForwardListGetOrCreateItem(backForwardList, wkAddedItem);

    GList* removedItems = 0;

    size_t removedItemsSize = wkRemovedItems ? WKArrayGetSize(wkRemovedItems) : 0;

    WebKitBackForwardListPrivate* priv = backForwardList->priv;

    for (size_t i = 0; i < removedItemsSize; ++i) {

        WKBackForwardListItemRef wkItem = static_cast<WKBackForwardListItemRef>(WKArrayGetItemAtIndex(wkRemovedItems, i));

        removedItems = g_list_prepend(removedItems, g_object_ref(G_OBJECT(priv->itemsMap.get(wkItem).get())));

        priv->itemsMap.remove(wkItem);

    }

    g_signal_emit(backForwardList, signals[CHANGED], 0, addedItem, removedItems, NULL);

    g_list_free_full(removedItems, static_cast<GDestroyNotify>(g_object_unref));

}

/**

 * webkit_back_forward_list_get_current_item:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns the current item in @back_forward_list.

 *

 * Return value: (transfer none): a #WebKitWebHistoryItem

 *    or %NULL if @back_forward_list is empty.

 */

WebKitBackForwardListItem* webkit_back_forward_list_get_current_item(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListGetOrCreateItem(backForwardList, WKBackForwardListGetCurrentItem(backForwardList->priv->wkList));

}

/**

 * webkit_back_forward_list_get_back_item:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns the item that precedes the current item.

 *

 * Returns: (transfer none): the #WebKitBackForwardListItem

 *    preceding the current item or %NULL.

 */

WebKitBackForwardListItem* webkit_back_forward_list_get_back_item(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListGetOrCreateItem(backForwardList, WKBackForwardListGetBackItem(backForwardList->priv->wkList));

}

/**

 * webkit_back_forward_list_get_forward_item:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns the item that succeeds the current item.

 *

 * Returns: (transfer none): the #WebKitBackForwardListItem

 *    following the current item or %NULL.

 */

WebKitBackForwardListItem* webkit_back_forward_list_get_forward_item(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListGetOrCreateItem(backForwardList, WKBackForwardListGetForwardItem(backForwardList->priv->wkList));

}

/**

 * webkit_back_forward_list_get_nth_item:

 * @back_forward_list: a #WebKitBackForwardList

 * @index: the index of the item

 *

 * Returns the item at a given index relative to the current item.

 *

 * Returns: (transfer none): the #WebKitBackForwardListItem

 *    located at the specified index relative to the current item.

 */

WebKitBackForwardListItem* webkit_back_forward_list_get_nth_item(WebKitBackForwardList* backForwardList, gint index)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListGetOrCreateItem(backForwardList, WKBackForwardListGetItemAtIndex(backForwardList->priv->wkList, index));

}

/**

 * webkit_back_forward_list_get_length:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns: the length of @back_forward_list.

 */

guint webkit_back_forward_list_get_length(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    WebKitBackForwardListPrivate* priv = backForwardList->priv;

    guint currentItem = webkit_back_forward_list_get_current_item(backForwardList) ? 1 : 0;

    return WKBackForwardListGetBackListCount(priv->wkList) + WKBackForwardListGetForwardListCount(priv->wkList) + currentItem;

}

/**

 * webkit_back_forward_list_get_back_list:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns: (element-type WebKit.BackForwardListItem) (transfer container): a #GList of

 *    items preceding the current item.

 */

GList* webkit_back_forward_list_get_back_list(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    guint limit = WKBackForwardListGetBackListCount(backForwardList->priv->wkList);

    return webkitBackForwardListCreateList(WKBackForwardListCopyBackListWithLimit(backForwardList->priv->wkList, limit));

}

/**

 * webkit_back_forward_list_get_back_list_with_limit:

 * @back_forward_list: a #WebKitBackForwardList

 * @limit: the number of items to retrieve

 *

 * Returns: (element-type WebKit.BackForwardListItem) (transfer container): a #GList of

 *    items preceding the current item limited by @limit.

 */

GList* webkit_back_forward_list_get_back_list_with_limit(WebKitBackForwardList* backForwardList, guint limit)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListCreateList(WKBackForwardListCopyBackListWithLimit(backForwardList->priv->wkList, limit));

}

/**

 * webkit_back_forward_list_get_forward_list:

 * @back_forward_list: a #WebKitBackForwardList

 *

 * Returns: (element-type WebKit.BackForwardListItem) (transfer container): a #GList of

 *    items following the current item.

 */

GList* webkit_back_forward_list_get_forward_list(WebKitBackForwardList* backForwardList)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    guint limit = WKBackForwardListGetForwardListCount(backForwardList->priv->wkList);

    return webkitBackForwardListCreateList(WKBackForwardListCopyForwardListWithLimit(backForwardList->priv->wkList, limit));

}

/**

 * webkit_back_forward_list_get_forward_list_with_limit:

 * @back_forward_list: a #WebKitBackForwardList

 * @limit: the number of items to retrieve

 *

 * Returns: (element-type WebKit.BackForwardListItem) (transfer container): a #GList of

 *    items following the current item limited by @limit.

 */

GList* webkit_back_forward_list_get_forward_list_with_limit(WebKitBackForwardList* backForwardList, guint limit)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST(backForwardList), 0);

    return webkitBackForwardListCreateList(WKBackForwardListCopyForwardListWithLimit(backForwardList->priv->wkList, limit));

}

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#if !defined(__WEBKIT2_H_INSIDE__) && !defined(WEBKIT2_COMPILATION)

#error "Only <webkit2/webkit2.h> can be included directly."

#endif

#ifndef WebKitBackForwardList_h

#define WebKitBackForwardList_h

#include <glib-object.h>

#include <webkit2/WebKitBackForwardListItem.h>

#include <webkit2/WebKitDefines.h>

G_BEGIN_DECLS

#define WEBKIT_TYPE_BACK_FORWARD_LIST            (webkit_back_forward_list_get_type())

#define WEBKIT_BACK_FORWARD_LIST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_BACK_FORWARD_LIST, WebKitBackForwardList))

#define WEBKIT_BACK_FORWARD_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_BACK_FORWARD_LIST, WebKitBackForwardListClass))

#define WEBKIT_IS_BACK_FORWARD_LIST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_BACK_FORWARD_LIST))

#define WEBKIT_IS_BACK_FORWARD_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_BACK_FORWARD_LIST))

#define WEBKIT_BACK_FORWARD_LIST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_BACK_FORWARD_LIST, WebKitBackForwardListClass))

typedef struct _WebKitBackForwardList        WebKitBackForwardList;

typedef struct _WebKitBackForwardListClass   WebKitBackForwardListClass;

typedef struct _WebKitBackForwardListPrivate WebKitBackForwardListPrivate;

struct _WebKitBackForwardList {

    GObject parent;

    WebKitBackForwardListPrivate *priv;

};

struct _WebKitBackForwardListClass {

    GObjectClass parent_class;

};

WEBKIT_API GType

webkit_back_forward_list_get_type                    (void);

WEBKIT_API WebKitBackForwardListItem *

webkit_back_forward_list_get_current_item            (WebKitBackForwardList *back_forward_list);

WEBKIT_API WebKitBackForwardListItem *

webkit_back_forward_list_get_back_item               (WebKitBackForwardList *back_forward_list);

WEBKIT_API WebKitBackForwardListItem *

webkit_back_forward_list_get_forward_item            (WebKitBackForwardList *back_forward_list);

WEBKIT_API WebKitBackForwardListItem *

webkit_back_forward_list_get_nth_item                (WebKitBackForwardList *back_forward_list,

                                                      gint                   index);

WEBKIT_API guint

webkit_back_forward_list_get_length                  (WebKitBackForwardList *back_forward_list);

WEBKIT_API GList *

webkit_back_forward_list_get_back_list               (WebKitBackForwardList *back_forward_list);

WEBKIT_API GList *

webkit_back_forward_list_get_back_list_with_limit    (WebKitBackForwardList *back_forward_list,

                                                      guint                  limit);

WEBKIT_API GList *

webkit_back_forward_list_get_forward_list            (WebKitBackForwardList *back_forward_list);

WEBKIT_API GList *

webkit_back_forward_list_get_forward_list_with_limit (WebKitBackForwardList *back_forward_list,

                                                      guint                  limit);

G_END_DECLS

#endif

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "WebKitBackForwardListItem.h"

#include "WebKitBackForwardListPrivate.h"

#include <WebKit2/WKBackForwardListItem.h>

#include <WebKit2/WKRetainPtr.h>

#include <wtf/HashMap.h>

#include <wtf/gobject/GRefPtr.h>

#include <wtf/text/CString.h>

using namespace WebKit;

struct _WebKitBackForwardListItemPrivate {

    WKRetainPtr<WKBackForwardListItemRef> wkListItem;

    CString uri;

    CString title;

    CString originalURI;

};

G_DEFINE_TYPE(WebKitBackForwardListItem, webkit_back_forward_list_item, G_TYPE_INITIALLY_UNOWNED)

static void webkitBackForwardListItemFinalize(GObject* object)

{

    WEBKIT_BACK_FORWARD_LIST_ITEM(object)->priv->~WebKitBackForwardListItemPrivate();

    G_OBJECT_CLASS(webkit_back_forward_list_item_parent_class)->finalize(object);

}

static void webkit_back_forward_list_item_init(WebKitBackForwardListItem* listItem)

{

    WebKitBackForwardListItemPrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(listItem, WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM, WebKitBackForwardListItemPrivate);

    listItem->priv = priv;

    new (priv) WebKitBackForwardListItemPrivate();

}

static void webkit_back_forward_list_item_class_init(WebKitBackForwardListItemClass* listItemClass)

{

    GObjectClass* gObjectClass = G_OBJECT_CLASS(listItemClass);

    gObjectClass->finalize = webkitBackForwardListItemFinalize;

    g_type_class_add_private(listItemClass, sizeof(WebKitBackForwardListItemPrivate));

}

typedef HashMap<WKBackForwardListItemRef, WebKitBackForwardListItem* > HistoryItemsMap;

static HistoryItemsMap& historyItemsMap()

{

    DEFINE_STATIC_LOCAL(HistoryItemsMap, itemsMap, ());

    return itemsMap;

}

static void webkitBackForwardListItemFinalized(gpointer wkListItem, GObject* finalizedListItem)

{

    ASSERT(G_OBJECT(historyItemsMap().get(static_cast<WKBackForwardListItemRef>(wkListItem))) == finalizedListItem);

    historyItemsMap().remove(static_cast<WKBackForwardListItemRef>(wkListItem));

}

WebKitBackForwardListItem* webkitBackForwardListItemGetOrCreate(WKBackForwardListItemRef wkListItem)

{

    if (!wkListItem)

        return 0;

    WebKitBackForwardListItem* listItem = historyItemsMap().get(wkListItem);

    if (listItem)

        return listItem;

    listItem = WEBKIT_BACK_FORWARD_LIST_ITEM(g_object_new(WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM, NULL));

    listItem->priv->wkListItem = wkListItem;

    g_object_weak_ref(G_OBJECT(listItem), webkitBackForwardListItemFinalized,

                      static_cast<gpointer>(const_cast<OpaqueWKBackForwardListItem*>(wkListItem)));

    historyItemsMap().set(wkListItem, listItem);

    return listItem;

}

/**

 * webkit_back_forward_list_item_get_uri:

 * @back_forward_list_item: a #WebKitBackForwardListItem

 *

 * This URI may differ from the original URI if the page was,

 * for example, redirected to a new location.

 * See also webkit_back_forward_list_item_get_original_uri().

 *

 * Returns: the URI of @back_forward_list_item.

 */

const gchar* webkit_back_forward_list_item_get_uri(WebKitBackForwardListItem* listItem)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(listItem), 0);

    WebKitBackForwardListItemPrivate* priv = listItem->priv;

    WKRetainPtr<WKURLRef> wkURI(AdoptWK, WKBackForwardListItemCopyURL(priv->wkListItem.get()));

    if (toImpl(wkURI.get())->string().isEmpty())

        return 0;

    priv->uri = toImpl(wkURI.get())->string().utf8();

    return priv->uri.data();

}

/**

 * webkit_back_forward_list_item_get_title:

 * @back_forward_list_item: a #WebKitBackForwardListItem

 *

 * Returns: the page title of @back_forward_list_item.

 */

const gchar* webkit_back_forward_list_item_get_title(WebKitBackForwardListItem* listItem)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(listItem), 0);

    WebKitBackForwardListItemPrivate* priv = listItem->priv;

    WKRetainPtr<WKStringRef> wkTitle(AdoptWK, WKBackForwardListItemCopyTitle(priv->wkListItem.get()));

    if (toImpl(wkTitle.get())->string().isEmpty())

        return 0;

    priv->title = toImpl(wkTitle.get())->string().utf8();

    return priv->title.data();

}

/**

 * webkit_back_forward_list_item_get_original_uri:

 * @back_forward_list_item: a #WebKitWebHistoryItem

 *

 * See also webkit_back_forward_list_item_get_uri().

 *

 * Returns: the original URI of @back_forward_list_item.

 */

const gchar* webkit_back_forward_list_item_get_original_uri(WebKitBackForwardListItem* listItem)

{

    g_return_val_if_fail(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(listItem), 0);

    WebKitBackForwardListItemPrivate* priv = listItem->priv;

    WKRetainPtr<WKURLRef> wkOriginalURI(AdoptWK, WKBackForwardListItemCopyOriginalURL(priv->wkListItem.get()));

    if (toImpl(wkOriginalURI.get())->string().isEmpty())

        return 0;

    priv->originalURI = toImpl(wkOriginalURI.get())->string().utf8();

    return priv->originalURI.data();

}

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#if !defined(__WEBKIT2_H_INSIDE__) && !defined(WEBKIT2_COMPILATION)

#error "Only <webkit2/webkit2.h> can be included directly."

#endif

#ifndef WebKitBackForwardListItem_h

#define WebKitBackForwardListItem_h

#include <glib-object.h>

#include <webkit2/WebKitDefines.h>

G_BEGIN_DECLS

#define WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM            (webkit_back_forward_list_item_get_type())

#define WEBKIT_BACK_FORWARD_LIST_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM, WebKitBackForwardListItem))

#define WEBKIT_BACK_FORWARD_LIST_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM, WebKitBackForwardListItemClass))

#define WEBKIT_IS_BACK_FORWARD_LIST_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM))

#define WEBKIT_IS_BACK_FORWARD_LIST_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM))

#define WEBKIT_BACK_FORWARD_LIST_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_BACK_FORWARD_LIST_ITEM, WebKitBackForwardListItemClass))

typedef struct _WebKitBackForwardListItem        WebKitBackForwardListItem;

typedef struct _WebKitBackForwardListItemClass   WebKitBackForwardListItemClass;

typedef struct _WebKitBackForwardListItemPrivate WebKitBackForwardListItemPrivate;

struct _WebKitBackForwardListItem {

    GInitiallyUnowned parent;

    WebKitBackForwardListItemPrivate *priv;

};

struct _WebKitBackForwardListItemClass {

    GInitiallyUnownedClass parent_class;

};

WEBKIT_API GType

webkit_back_forward_list_item_get_type         (void);

WEBKIT_API const gchar *

webkit_back_forward_list_item_get_uri          (WebKitBackForwardListItem* list_item);

WEBKIT_API const gchar *

webkit_back_forward_list_item_get_title        (WebKitBackForwardListItem* list_item);

WEBKIT_API const gchar *

webkit_back_forward_list_item_get_original_uri (WebKitBackForwardListItem* list_item);

G_END_DECLS

#endif

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef WebKitBackForwardListPrivate_h

#define WebKitBackForwardListPrivate_h

#include "WebBackForwardList.h"

#include "WebKitBackForwardList.h"

#include <WebKit2/WebKit2.h>

WebKitBackForwardList* webkitBackForwardListCreate(WKBackForwardListRef);

WebKitBackForwardListItem* webkitBackForwardListItemGetOrCreate(WKBackForwardListItemRef);

void webkitBackForwardListChanged(WebKitBackForwardList*, WKBackForwardListItemRef wkAddedItem, WKArrayRef wkRemovedItems);

#endif // WebKitBackForwardListPrivate_h

#include "WebKitBackForwardListPrivate.h"

static void didChangeBackForwardList(WKPageRef page, WKBackForwardListItemRef addedItem, WKArrayRef removedItems, const void* clientInfo)

{

    WebKitWebView* webView = WEBKIT_WEB_VIEW(toImpl(page)->viewWidget());

    webkitBackForwardListChanged(webkit_web_view_get_back_forward_list(webView), addedItem, removedItems);

}

#include "WebKitBackForwardListPrivate.h"

    GRefPtr<WebKitBackForwardList> backForwardList;

static void webkitWebViewSetLoaderClient(WebKitWebView* webView, WebKitWebLoaderClient* loaderClient, WKPageRef wkPage)

{

    webView->priv->loaderClient = loaderClient;

    webkitWebLoaderClientAttachLoaderClientToPage(loaderClient, wkPage);

}

/**

 * webkit_web_view_get_back_forward_list:

 * @web_view: a #WebKitWebView

 *

 * Obtains the #WebKitBackForwardList associated with the given #WebKitWebView. The

 * #WebKitBackForwardList is owned by the #WebKitWebView.

 *

 * Returns: (transfer none): the #WebKitBackForwardList

 */

WebKitBackForwardList* webkit_web_view_get_back_forward_list(WebKitWebView* webView)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);

    return webView->priv->backForwardList.get();

}

#include <webkit2/WebKitBackForwardList.h>

WEBKIT_API WebKitBackForwardList *

webkit_web_view_get_back_forward_list       (WebKitWebView         *web_view);

    return priv->pageProxy.get();

Programs_WebKit2APITests_TestBackForwardList_SOURCES = \

        Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp

Programs_WebKit2APITests_TestBackForwardList_CPPFLAGS = $(webkit2_tests_cppflags)

Programs_WebKit2APITests_TestBackForwardList_LDADD = $(webkit2_tests_ldadd)

Programs_WebKit2APITests_TestBackForwardList_LDFLAGS = $(webkit2_tests_ldflags)

/*

 * Copyright (C) 2011 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "LoadTrackingTest.h"

#include "WebKitTestServer.h"

#include <gtk/gtk.h>

#include <libsoup/soup.h>

#include <string.h>

#include <webkit2/webkit2.h>

// Back forward list limit is 100 by default.

static const size_t wkBackForwardListLimit = 100;

static WebKitTestServer* kServer;

static void serverCallback(SoupServer* server, SoupMessage* msg, const char* path, GHashTable* query, SoupClientContext* context, gpointer data)

{

    if (msg->method != SOUP_METHOD_GET) {

        soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);

        return;

    }

    soup_message_set_status(msg, SOUP_STATUS_OK);

    char* body = g_strdup_printf("<html><title>%s</title><body>%s</body></html>", path + 1, path + 1);

    soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, body, strlen(body));

    soup_message_body_complete(msg->response_body);

}

class BackForwardListTest: public LoadTrackingTest {

public:

    MAKE_GLIB_TEST_FIXTURE(BackForwardListTest);

    enum {

        Backward,

        Forward

    };

    enum {

        CurrentItem  = 1 << 0,

        AddedItem    = 1 << 1,

        RemovedItems = 1 << 2

    };

    static void checkItem(WebKitBackForwardListItem* item, const gchar* title, const gchar* uri, const gchar* originalURI)

    {

        g_assert(item);

        g_assert_cmpstr(webkit_back_forward_list_item_get_uri(item), ==, uri);

        g_assert_cmpstr(webkit_back_forward_list_item_get_title(item), == , title);

        g_assert_cmpstr(webkit_back_forward_list_item_get_original_uri(item), ==, originalURI);

    }

    static void checkItemIndex(WebKitBackForwardList* list)

    {

        g_assert(webkit_back_forward_list_get_nth_item(list, -1) == webkit_back_forward_list_get_back_item(list));

        g_assert(webkit_back_forward_list_get_nth_item(list, 0) == webkit_back_forward_list_get_current_item(list));

        g_assert(webkit_back_forward_list_get_nth_item(list, 1) == webkit_back_forward_list_get_forward_item(list));

    }

    static void checkList(WebKitBackForwardList* list, guint type, WebKitBackForwardListItem** items, guint nItems)

    {

        GList* listItems = type == BackForwardListTest::Backward ? webkit_back_forward_list_get_back_list(list) :

            webkit_back_forward_list_get_forward_list(list);

        g_assert(listItems);

        guint i = 0;

        for (GList* listItem = listItems; listItem; listItem = g_list_next(listItem), i++) {

            g_assert_cmpuint(i, <, nItems);

            g_assert(listItem->data == items[i]);

        }

        g_list_free(listItems);

    }

    static void backForwardListChanged(WebKitBackForwardList* list, WebKitBackForwardListItem* addedItem, GList* removedItems, BackForwardListTest* test)

    {

        test->m_hasChanged = true;

        if (test->m_changedFlags & BackForwardListTest::AddedItem) {

            g_assert(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(addedItem));

            test->watchObject(G_OBJECT(addedItem));

        } else

            g_assert(!addedItem);

        if (test->m_changedFlags & BackForwardListTest::RemovedItems) {

            g_assert(removedItems);

            for (GList* iter = removedItems; iter; iter = iter->next) {

                g_assert(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(iter->data));

                if (test->m_expectedRemovedItems)

                    g_assert(g_list_find(test->m_expectedRemovedItems, iter->data));

            }

        } else

            g_assert(!removedItems);

    }

    BackForwardListTest()

        : m_list(webkit_web_view_get_back_forward_list(m_webView))

        , m_changedFlags(0)

        , m_hasChanged(false)

        , m_expectedRemovedItems(0)

    {

        g_signal_connect(m_list, "changed", G_CALLBACK(backForwardListChanged), this);

        watchObject(G_OBJECT(m_list));

    }

    ~BackForwardListTest()

    {

        g_signal_handlers_disconnect_matched(m_list, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);

    }

    void waitUntilLoadFinished()

    {

        m_hasChanged = false;

        LoadTrackingTest::waitUntilLoadFinished();

        g_assert(m_hasChanged);

    }

    void waitUntilLoadFinishedAndCheckRemovedItems(GList* removedItems)

    {

        m_expectedRemovedItems = removedItems;

        waitUntilLoadFinished();

        m_expectedRemovedItems = 0;

    }

    WebKitBackForwardList* m_list;

    gulong m_changedFlags;

    bool m_hasChanged;

    GList* m_expectedRemovedItems;

};

static void testBackForwardListNavigation(BackForwardListTest* test, gconstpointer)

{

    WebKitBackForwardListItem* items[1];

    g_assert(!webkit_web_view_can_go_back(test->m_webView));

    g_assert(!webkit_web_view_can_go_forward(test->m_webView));

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 0);

    g_assert(!webkit_back_forward_list_get_current_item(test->m_list));

    g_assert(!webkit_back_forward_list_get_back_item(test->m_list));

    g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));

    BackForwardListTest::checkItemIndex(test->m_list);

    g_assert(!webkit_back_forward_list_get_back_list(test->m_list));

    g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));

    CString uriPage1 = kServer->getURIForPath("/Page1");

    test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;

    webkit_web_view_load_uri(test->m_webView, uriPage1.data());

    test->waitUntilLoadFinished();

    g_assert(!webkit_web_view_can_go_back(test->m_webView));

    g_assert(!webkit_web_view_can_go_forward(test->m_webView));

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 1);

    WebKitBackForwardListItem* itemPage1 = webkit_back_forward_list_get_current_item(test->m_list);

    BackForwardListTest::checkItem(itemPage1, "Page1", uriPage1.data(), uriPage1.data());

    g_assert(!webkit_back_forward_list_get_back_item(test->m_list));

    g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));

    BackForwardListTest::checkItemIndex(test->m_list);

    g_assert(!webkit_back_forward_list_get_back_list(test->m_list));

    g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));

    CString uriPage2 = kServer->getURIForPath("/Page2");

    test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;

    webkit_web_view_load_uri(test->m_webView, uriPage2.data());

    test->waitUntilLoadFinished();

    g_assert(webkit_web_view_can_go_back(test->m_webView));

    g_assert(!webkit_web_view_can_go_forward(test->m_webView));

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);

    WebKitBackForwardListItem* itemPage2 = webkit_back_forward_list_get_current_item(test->m_list);

    BackForwardListTest::checkItem(itemPage2, "Page2", uriPage2.data(), uriPage2.data());

    g_assert(webkit_back_forward_list_get_back_item(test->m_list) == itemPage1);

    g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));

    BackForwardListTest::checkItemIndex(test->m_list);

    items[0] = itemPage1;

    BackForwardListTest::checkList(test->m_list, BackForwardListTest::Backward, items, 1);

    g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));

    test->m_changedFlags = BackForwardListTest::CurrentItem;

    webkit_web_view_go_back(test->m_webView);

    test->waitUntilLoadFinished();

    g_assert(!webkit_web_view_can_go_back(test->m_webView));

    g_assert(webkit_web_view_can_go_forward(test->m_webView));

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);

    g_assert(itemPage1 == webkit_back_forward_list_get_current_item(test->m_list));

    BackForwardListTest::checkItem(webkit_back_forward_list_get_current_item(test->m_list), "Page1", uriPage1.data(), uriPage1.data());

    g_assert(!webkit_back_forward_list_get_back_item(test->m_list));

    g_assert(webkit_back_forward_list_get_forward_item(test->m_list) == itemPage2);

    BackForwardListTest::checkItemIndex(test->m_list);

    g_assert(!webkit_back_forward_list_get_back_list(test->m_list));

    items[0] = itemPage2;

    BackForwardListTest::checkList(test->m_list, BackForwardListTest::Forward, items, 1);

    test->m_changedFlags = BackForwardListTest::CurrentItem;

    webkit_web_view_go_forward(test->m_webView);

    test->waitUntilLoadFinished();

    g_assert(webkit_web_view_can_go_back(test->m_webView));

    g_assert(!webkit_web_view_can_go_forward(test->m_webView));

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, 2);

    g_assert(itemPage2 == webkit_back_forward_list_get_current_item(test->m_list));

    BackForwardListTest::checkItem(webkit_back_forward_list_get_current_item(test->m_list), "Page2", uriPage2.data(), uriPage2.data());

    g_assert(webkit_back_forward_list_get_back_item(test->m_list) == itemPage1);

    g_assert(!webkit_back_forward_list_get_forward_item(test->m_list));

    BackForwardListTest::checkItemIndex(test->m_list);

    items[0] = itemPage1;

    BackForwardListTest::checkList(test->m_list, BackForwardListTest::Backward, items, 1);

    g_assert(!webkit_back_forward_list_get_forward_list(test->m_list));

}

static void testBackForwardListLimitAndCache(BackForwardListTest* test, gconstpointer)

{

    for (size_t i = 0; i < wkBackForwardListLimit; i++) {

        GOwnPtr<char> path(g_strdup_printf("/Page%d", i));

        test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem;

        webkit_web_view_load_uri(test->m_webView, kServer->getURIForPath(path.get()).data());

        test->waitUntilLoadFinished();

    }

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, wkBackForwardListLimit);

    WebKitBackForwardListItem* itemPageFirst = webkit_back_forward_list_get_nth_item(test->m_list, -(wkBackForwardListLimit - 1));

    GOwnPtr<GList> removedItems(g_list_prepend(0, itemPageFirst));

    GOwnPtr<char> path(g_strdup_printf("/Page%d", wkBackForwardListLimit));

    test->m_changedFlags = BackForwardListTest::CurrentItem | BackForwardListTest::AddedItem | BackForwardListTest::RemovedItems;

    webkit_web_view_load_uri(test->m_webView, kServer->getURIForPath(path.get()).data());

    test->waitUntilLoadFinishedAndCheckRemovedItems(removedItems.get());

    g_assert_cmpuint(webkit_back_forward_list_get_length(test->m_list), ==, wkBackForwardListLimit);

}

void beforeAll()

{

    kServer = new WebKitTestServer();

    kServer->run(serverCallback);

    BackForwardListTest::add("BackForwardList", "navigation", testBackForwardListNavigation);

    BackForwardListTest::add("BackForwardList", "list-limit-and-cache", testBackForwardListLimitAndCache);

}

void afterAll()

{

    delete kServer;

}

#include <JavaScriptCore/HashSet.h>

    ~Test()

    {

        g_assert(m_watchedObjects.isEmpty());

    }

    static void objectFinalized(Test* test, GObject* finalizedObject)

    {

        test->m_watchedObjects.remove(finalizedObject);

    }

    void watchObject(GObject* object)

    {

        m_watchedObjects.add(object);

        g_object_weak_ref(object, reinterpret_cast<GWeakNotify>(objectFinalized), this);

    }

    HashSet<GObject*> m_watchedObjects;

    watchObject(G_OBJECT(m_webView));

#include <webkit2/WebKitBackForwardList.h>

#include <webkit2/WebKitBackForwardListItem.h>

VOID:OBJECT,POINTER