2012-09-27  Mario Sanchez Prada  <msanchez@igalia.com>

        [WK2][GTK] Implement new Favicons API

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

        Reviewed by NOBODY (OOPS!).

        New object wrapping the internal IconDatabase from WebCore,

        providing a simple asynchronous API to retrieve the favicon

        associated to a page URL, and two more functions to simple query

        the internal database for the URI of the icon associated to a

        page, if any, and to clear the state of the internal database.

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

        (_WebKitFaviconDatabasePrivate):

        (webkit_favicon_database_init):

        (webkitFaviconDatabaseFinalize):

        (webkit_favicon_database_class_init):

        (GetFaviconSurfaceAsyncData): New structure used to pass data

        across the asynchronous implementation of get_favicon().

        (GetFaviconSurfaceAsyncData::~GetFaviconSurfaceAsyncData):

        Disconnects the cancellable if needed.

        (getIconSurfaceSynchronously): Synchronously returns a pointer to

        the cairo_surface with the icon's data, if available.

        (deletePendingIconRequests): Removes the full list of

        icon requests for a page URL.

        (processPendingIconsForURI): Process any icon request that

        might be still pending.

        (iconDataReadyForPageURLCallback): Called from WebIconDatabase

        when new data is ready for a favicon.

        (webkitFaviconDatabaseCreate): Create the WebKitFaviconDatabase

        object and initializes the API client for WKIconDatabaseClient.

        (getOrCreatePendingIconRequests): Returns (if available) or

        creates a new icon request, to be appended to the list of requests

        for the same page URL.

        (getIconSurfaceCancelled): Handle the case of a request being

        cancelled. Must happen on the main thread.

        (getIconSurfaceCancelledCallback): Callback used with

        g_cancellable_connect(), which ensure getIconSurfaceCancelled() is

        called from the main thread.

        (setErrorForAsyncResult): Helper to set errors in the result.

        (webkit_favicon_database_error_quark): New function, providint the

        new error domain for errors of type WebKitFaviconDatabaseError.

        (webkit_favicon_database_get_favicon): New API function, providing

        an asynchronous mechanism to query the favicon for a page URL.

        (webkit_favicon_database_get_favicon_finish): New API function to

        finish the asyncrhonous request started with get_favicon().

        (webkit_favicon_database_get_favicon_uri): New API function

        to easily retrieve, if available, the URI of a favicon.

        (webkit_favicon_database_clear): New API function to clear the

        state of the internal icon database.

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

        (_WebKitFaviconDatabase):

        (_WebKitFaviconDatabaseClass):

        * UIProcess/API/gtk/WebKitFaviconDatabasePrivate.h: Added to

        internally expose webkitFaviconDatabaseCreate() to WebKitWebContext.

        * UIProcess/API/gtk/WebKitPrivate.h: Import WebKit2/WKIconDatabase.h.

        * GNUmakefile.list.am: Added new files.

        Add a new getter in WebIconDatabase for m_urlImportCompleted.

        * UIProcess/WebIconDatabase.cpp:

        (WebKit::WebIconDatabase::isUrlImportCompleted): Added this simple

        getter to allow knowing from WebKitFaviconDatabase whether the

        initial import has finished, needed for making some decisions.

        (WebKit):

        * UIProcess/WebIconDatabase.h:

        (WebIconDatabase):

        New API in WebKitWebContext to allow obtaining a valid instance of

        WebKitFaviconDatabase and to set/get the local path to be used.

        * UIProcess/API/gtk/WebKitWebContext.cpp:

        (_WebKitWebContextPrivate):

        (webkit_web_context_set_favicon_database_path): New API to allow

        setting a path for the icon database, other than the default one.

        (webkit_web_context_get_favicon_database_path): New API to

        retrieve the path for the icon database currently in use.

        (webkit_web_context_get_favicon_database): New API to get a valid

        and properly initialized instance of WebKitFaviconDatabase.

        * UIProcess/API/gtk/WebKitWebContext.h:

        Make sure we have a default path set for the icon database.

        * UIProcess/gtk/WebContextGtk.cpp:

        (WebKit::WebContext::platformDefaultIconDatabasePath): Return the

        default path to be used for the icon database.

        Add unit tests for checking this new API.

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

        (serverCallback): Callback for the test server.

        (testSetDirectory): New unit test, checks the ability to set and

        get a specific directory path for the icon database.

        (testClearDatabase): New unit test, checks the ability to clear

        the data in the icon database.

        (testGetFavicon): New unit test, checks the ability to get a

        favicon from the icon database in different situations.

        (testGetFaviconURI): New unit test, checks the ability to retrieve

        the URI for the favicon, if any, associated to a web page.

        (deleteDatabaseFiles): Helper function to remove temporary files.

        (beforeAll): Initialize the test server and add the unit tests.

        (afterAll): Delete the test server and clean up.

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

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

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

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

/*

 * Copyright (C) 2012 Igalia S.L.

 *

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

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

 * License as published by the Free Software Foundation; either

 * version 2,1 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 "WebKitFaviconDatabase.h"

#include "WebIconDatabase.h"

#include "WebKitFaviconDatabasePrivate.h"

#include "WebKitPrivate.h"

#include "WebKitWebContext.h"

#include <WebCore/FileSystem.h>

#include <WebCore/Image.h>

#include <WebCore/IntSize.h>

#include <WebCore/RefPtrCairo.h>

#include <glib/gi18n-lib.h>

#include <wtf/MainThread.h>

#include <wtf/gobject/GOwnPtr.h>

#include <wtf/gobject/GRefPtr.h>

#include <wtf/text/CString.h>

using namespace WebKit;

enum {

    ICON_READY,

    LAST_SIGNAL

};

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

typedef Vector<GRefPtr<GSimpleAsyncResult> > PendingIconRequestVector;

typedef HashMap<String, PendingIconRequestVector*> PendingIconRequestMap;

struct _WebKitFaviconDatabasePrivate {

    RefPtr<WebIconDatabase> iconDatabase;

    PendingIconRequestMap pendingIconRequests;

};

G_DEFINE_TYPE(WebKitFaviconDatabase, webkit_favicon_database, G_TYPE_OBJECT)

static void closeIconDatabaseIfNeeded(WebKitFaviconDatabase* database)

{

    WebKitFaviconDatabasePrivate* priv = database->priv;

    if (priv->iconDatabase->isOpen())

        priv->iconDatabase->close();

}

static void webkit_favicon_database_init(WebKitFaviconDatabase* manager)

{

    WebKitFaviconDatabasePrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(manager, WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabasePrivate);

    manager->priv = priv;

    new (priv) WebKitFaviconDatabasePrivate();

}

static void webkitFaviconDatabaseFinalize(GObject* object)

{

    WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(object);

    WebKitFaviconDatabasePrivate* priv = database->priv;

    closeIconDatabaseIfNeeded(database);

    priv->~WebKitFaviconDatabasePrivate();

    G_OBJECT_CLASS(webkit_favicon_database_parent_class)->finalize(object);

}

static void webkit_favicon_database_class_init(WebKitFaviconDatabaseClass* faviconDatabaseClass)

{

    GObjectClass* gObjectClass = G_OBJECT_CLASS(faviconDatabaseClass);

    gObjectClass->finalize = webkitFaviconDatabaseFinalize;

    /**

     * WebKitFaviconDatabase::favicon-ready:

     * @database: the object on which the signal is emitted

     * @page_uri: the URI of the Web page containing the icon.

     *

     * This signal gets emitted when the favicon of @page_uri is

     * ready. This means that the favicon's data is ready to be used

     * by the application, either because it has been loaded from the

     * network, if it's the first time it gets retrieved, or because

     * it has been already imported from the icon database.

     */

    signals[ICON_READY] =

        g_signal_new("favicon-ready",

                     G_TYPE_FROM_CLASS(faviconDatabaseClass),

                     G_SIGNAL_RUN_LAST,

                     0, 0, 0,

                     g_cclosure_marshal_VOID__STRING,

                     G_TYPE_NONE, 1,

                     G_TYPE_STRING);

    g_type_class_add_private(faviconDatabaseClass, sizeof(WebKitFaviconDatabasePrivate));

}

struct GetFaviconSurfaceAsyncData {

    GRefPtr<WebKitFaviconDatabase> faviconDatabase;

    String pageURL;

    RefPtr<cairo_surface_t> icon;

    GRefPtr<GCancellable> cancellable;

    unsigned long cancelledId;

    ~GetFaviconSurfaceAsyncData()

    {

        if (cancelledId)

            g_cancellable_disconnect(cancellable.get(), cancelledId);

    }

};

WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetFaviconSurfaceAsyncData)

static cairo_surface_t* getIconSurfaceSynchronously(WebKitFaviconDatabase* database, const String& pageURL)

{

    ASSERT(isMainThread());

    WebKitFaviconDatabasePrivate* priv = database->priv;

    // The exact size we pass is irrelevant to the iconDatabase code.

    // We must pass something greater than 0x0 to get an icon.

    WebCore::NativeImagePtr icon = priv->iconDatabase->nativeImageForPageURL(pageURL, WebCore::IntSize(1, 1));

    if (!icon)

        return 0;

    return icon ? icon->surface() : 0;

}

static void deletePendingIconRequests(WebKitFaviconDatabase* database, PendingIconRequestVector* requests, const String& pageURL)

{

    database->priv->pendingIconRequests.remove(pageURL);

    delete requests;

}

static void processPendingIconsForURI(WebKitFaviconDatabase* database, const String& pageURL)

{

    PendingIconRequestVector* icons = database->priv->pendingIconRequests.get(pageURL);

    if (!icons)

        return;

    for (size_t i = 0; i < icons->size(); ++i) {

        GSimpleAsyncResult* result = icons->at(i).get();

        GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_simple_async_result_get_op_res_gpointer(result));

        data->icon = getIconSurfaceSynchronously(database, pageURL);

        g_simple_async_result_complete(result);

    }

    deletePendingIconRequests(database, icons, pageURL);

}

static void iconDataReadyForPageURLCallback(WKIconDatabaseRef wkIconDatabase, WKURLRef wkPageURL, const void* clientInfo)

{

    ASSERT(isMainThread());

    WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(clientInfo);

    String pageURLString = toImpl(wkPageURL)->string();

    database->priv->iconDatabase->retainIconForPageURL(pageURLString);

    processPendingIconsForURI(database, pageURLString);

    g_signal_emit(database, signals[ICON_READY], 0, pageURLString.utf8().data());

}

WebKitFaviconDatabase* webkitFaviconDatabaseCreate(WebIconDatabase* iconDatabase)

{

    WebKitFaviconDatabase* faviconDatabase = WEBKIT_FAVICON_DATABASE(g_object_new(WEBKIT_TYPE_FAVICON_DATABASE, NULL));

    faviconDatabase->priv->iconDatabase = iconDatabase;

    WKIconDatabaseClient wkIconDatabaseClient = {

        kWKIconDatabaseClientCurrentVersion,

        faviconDatabase, // clientInfo

        0, // didChangeIconForPageURLCallback

        0, // didRemoveAllIconsCallback

        iconDataReadyForPageURLCallback,

    };

    WKIconDatabaseSetIconDatabaseClient(toAPI(iconDatabase), &wkIconDatabaseClient);

    return faviconDatabase;

}

static PendingIconRequestVector* getOrCreatePendingIconRequests(WebKitFaviconDatabase* database, const String& pageURL)

{

    PendingIconRequestVector* icons = database->priv->pendingIconRequests.get(pageURL);

    if (!icons) {

        icons = new PendingIconRequestVector;

        database->priv->pendingIconRequests.set(pageURL, icons);

    }

    return icons;

}

static void getIconSurfaceCancelled(void* userData)

{

    GSimpleAsyncResult* result = static_cast<GSimpleAsyncResult*>(userData);

    // Get the data we might need and complete the request.

    GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_simple_async_result_get_op_res_gpointer(result));

    WebKitFaviconDatabase* database = data->faviconDatabase.get();

    String pageURL = data->pageURL;

    g_simple_async_result_complete(result);

    PendingIconRequestVector* icons = database->priv->pendingIconRequests.get(pageURL);

    if (!icons)

        return;

    size_t itemIndex = icons->find(result);

    if (itemIndex != notFound)

        icons->remove(itemIndex);

    if (icons->isEmpty())

        deletePendingIconRequests(database, icons, pageURL);

}

static void getIconSurfaceCancelledCallback(GCancellable* cancellable, GSimpleAsyncResult* result)

{

    // Handle cancelled in a in idle since it might be called from any thread.

    callOnMainThread(getIconSurfaceCancelled, result);

}

static void setErrorForAsyncResult(GSimpleAsyncResult* result, WebKitFaviconDatabaseError error, const String& pageURL = String())

{

    ASSERT(result);

    switch (error) {

    case WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED:

        g_simple_async_result_set_error(result, WEBKIT_FAVICON_DATABASE_ERROR, error, _("Favicons database not initialized yet"));

        break;

    case WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND:

        g_simple_async_result_set_error(result, WEBKIT_FAVICON_DATABASE_ERROR, error, _("Page %s does not have a favicon"), pageURL.utf8().data());

        break;

    default:

        ASSERT_NOT_REACHED();

    }

}

GQuark webkit_favicon_database_error_quark(void)

{

    return g_quark_from_static_string("WebKitFaviconDatabaseError");

}

/**

 * webkit_favicon_database_get_favicon:

 * @database: a #WebKitFaviconDatabase

 * @page_uri: URI of the page for which we want to retrieve the favicon

 * @cancellable: (allow-none): A #GCancellable or %NULL.

 * @callback: (scope async): A #GAsyncReadyCallback to call when the request is

 *            satisfied or %NULL if you don't care about the result.

 * @user_data: (closure): The data to pass to @callback.

 *

 * Asynchronously obtains a #cairo_surface_t of the favicon for the

 * given page URI. It returns the cached icon if it's in the database

 * asynchronously waiting for the icon to be read from the database.

 *

 * This is an asynchronous method. When the operation is finished, callback will

 * be invoked. You can then call webkit_favicon_database_get_favicon_finish()

 * to get the result of the operation.

 */

void webkit_favicon_database_get_favicon(WebKitFaviconDatabase* database, const gchar* pageURI, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)

{

    g_return_if_fail(WEBKIT_IS_FAVICON_DATABASE(database));

    g_return_if_fail(pageURI);

    GRefPtr<GSimpleAsyncResult> result = adoptGRef(g_simple_async_result_new(G_OBJECT(database), callback, userData, reinterpret_cast<gpointer>(webkit_favicon_database_get_favicon)));

    GetFaviconSurfaceAsyncData* data = createGetFaviconSurfaceAsyncData();

    g_simple_async_result_set_op_res_gpointer(result.get(), data, reinterpret_cast<GDestroyNotify>(destroyGetFaviconSurfaceAsyncData));

    data->faviconDatabase = database;

    data->pageURL = String::fromUTF8(pageURI);

    data->cancellable = cancellable;

    if (cancellable) {

        data->cancelledId =

            g_cancellable_connect(cancellable, G_CALLBACK(getIconSurfaceCancelledCallback), result.get(), 0);

        g_simple_async_result_set_check_cancellable(result.get(), cancellable);

    }

    WebKitFaviconDatabasePrivate* priv = database->priv;

    WebIconDatabase* iconDatabaseImpl = priv->iconDatabase.get();

    if (!iconDatabaseImpl->isOpen()) {

        setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED);

        g_simple_async_result_complete_in_idle(result.get());

        return;

    }

    if (data->pageURL.isEmpty() || data->pageURL.startsWith("about:")) {

        setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, data->pageURL);

        g_simple_async_result_complete_in_idle(result.get());

        return;

    }

    // We ask for the icon directly. If we don't get the icon data now,

    // we'll be notified later (even if the database is still importing icons).

    data->icon = getIconSurfaceSynchronously(database, data->pageURL);

    // If there's not a valid icon, but there's an iconURL registered,

    // or it's still not registered but the import process hasn't

    // finished yet, we need to wait for iconDataReadyForPage to be

    // called before making and informed decision.

    String iconURLForPageURL;

    iconDatabaseImpl->synchronousIconURLForPageURL(data->pageURL, iconURLForPageURL);

    if (!data->icon && (!iconURLForPageURL.isEmpty() || !iconDatabaseImpl->isUrlImportCompleted())) {

        PendingIconRequestVector* icons = getOrCreatePendingIconRequests(database, data->pageURL);

        ASSERT(icons);

        icons->append(result);

        return;

    }

    // If we reached this point without a valid icon, which means that

    // there's no iconURL registered for this pageURI and the

    // urlImport process has already finished, or do have a valid icon

    // but it's an empty image, that means there's no favicon.

    if (!data->icon || !cairo_image_surface_get_data(data->icon.get()))

        setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, data->pageURL);

    // Complete the asynchronous process;

    g_simple_async_result_complete_in_idle(result.get());

}

/**

 * webkit_favicon_database_get_favicon_finish:

 * @database: a #WebKitFaviconDatabase

 * @result: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to webkit_favicon_database_get_favicon()

 * @error: (allow-none): Return location for error or %NULL.

 *

 * Finishes an operation started with webkit_favicon_database_get_favicon().

 *

 * Returns: (transfer full): a new reference to a #cairo_surface_t, or

 * %NULL in case of error.

 */

cairo_surface_t* webkit_favicon_database_get_favicon_finish(WebKitFaviconDatabase* database, GAsyncResult* result, GError** error)

{

    GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);

    g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkit_favicon_database_get_favicon);

    if (g_simple_async_result_propagate_error(simpleResult, error))

        return 0;

    GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_simple_async_result_get_op_res_gpointer(simpleResult));

    ASSERT(data);

    // Return the icon is we can get it already.

    if (data->icon)

        return cairo_surface_reference(data->icon.get());

    // If the icon is not available at this stage, investigate why

    // and come up with a descriptive, and hopefully helpful, error.

    String iconURLForPageURL;

    database->priv->iconDatabase->synchronousIconURLForPageURL(data->pageURL, iconURLForPageURL);

    if (iconURLForPageURL.isEmpty()) {

        // If there's no icon URL in the database at this point, we can

        // conclude there's no favicon at all for the requested page URL.

        g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND,

                    _("Page %s does not have a favicon"), data->pageURL.utf8().data());

    } else {

        // If the icon URL is known it obviously means that the icon data

        // hasn't been retrieved yet, so report that it's 'unknown'.

        g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN,

                    _("Unknown favicon for page %s"), data->pageURL.utf8().data());

    }

    return 0;

}

/**

 * webkit_favicon_database_get_favicon_uri:

 * @database: a #WebKitFaviconDatabase

 * @page_uri: URI of the page containing the icon

 *

 * Obtains the URI of the favicon for the given @page_uri.

 *

 * Returns: a newly allocated URI for the favicon, or %NULL if the

 * database doesn't have a favicon for @page_uri.

 */

gchar* webkit_favicon_database_get_favicon_uri(WebKitFaviconDatabase* database, const gchar* pageURL)

{

    g_return_val_if_fail(WEBKIT_IS_FAVICON_DATABASE(database), 0);

    g_return_val_if_fail(pageURL, 0);

    ASSERT(isMainThread());

    String iconURLForPageURL;

    database->priv->iconDatabase->synchronousIconURLForPageURL(String::fromUTF8(pageURL), iconURLForPageURL);

    if (iconURLForPageURL.isEmpty())

        return 0;

    return g_strdup(iconURLForPageURL.utf8().data());

}

/**

 * webkit_favicon_database_clear:

 * @database: a #WebKitFaviconDatabase

 *

 * Clears all icons from the database.

 */

void webkit_favicon_database_clear(WebKitFaviconDatabase* database)

{

    g_return_if_fail(WEBKIT_IS_FAVICON_DATABASE(database));

    database->priv->iconDatabase->removeAllIcons();

}

/*

 * Copyright (C) 2012 Igalia S.L.

 *

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

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

 * License as published by the Free Software Foundation; either

 * version 2,1 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 WebKitFaviconDatabase_h

#define WebKitFaviconDatabase_h

#include <cairo.h>

#include <gio/gio.h>

#include <glib-object.h>

#include <webkit2/WebKitDefines.h>

G_BEGIN_DECLS

#define WEBKIT_TYPE_FAVICON_DATABASE            (webkit_favicon_database_get_type())

#define WEBKIT_FAVICON_DATABASE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabase))

#define WEBKIT_IS_FAVICON_DATABASE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_FAVICON_DATABASE))

#define WEBKIT_FAVICON_DATABASE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabaseClass))

#define WEBKIT_IS_FAVICON_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_FAVICON_DATABASE))

#define WEBKIT_FAVICON_DATABASE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabaseClass))

#define WEBKIT_FAVICON_DATABASE_ERROR           (webkit_favicon_database_error_quark())

typedef struct _WebKitFaviconDatabase        WebKitFaviconDatabase;

typedef struct _WebKitFaviconDatabaseClass   WebKitFaviconDatabaseClass;

typedef struct _WebKitFaviconDatabasePrivate WebKitFaviconDatabasePrivate;

struct _WebKitFaviconDatabase {

    GObject parent;

    WebKitFaviconDatabasePrivate *priv;

};

struct _WebKitFaviconDatabaseClass {

    GObjectClass parent_class;

};

/**

 * WebKitFaviconDatabaseError:

 * @WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED: The #WebKitFaviconDatabase has not been initialized yet

 * @WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND: There is not an icon available for the requested URL

 * @WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN: There might be an icon for the requested URL, but its data is unknown at the moment

 *

 * Enum values used to denote the various errors related to the #WebKitFaviconDatabase.

 **/

typedef enum {

    WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED,

    WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND,

    WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN

} WebKitFaviconDatabaseError;

WEBKIT_API GQuark

webkit_favicon_database_error_quark               (void);

WEBKIT_API GType

webkit_favicon_database_get_type                  (void);

WEBKIT_API void

webkit_favicon_database_get_favicon               (WebKitFaviconDatabase *database,

                                                   const gchar           *page_uri,

                                                   GCancellable          *cancellable,

                                                   GAsyncReadyCallback    callback,

                                                   gpointer               user_data);

WEBKIT_API cairo_surface_t *

webkit_favicon_database_get_favicon_finish        (WebKitFaviconDatabase *database,

                                                   GAsyncResult          *result,

                                                   GError               **error);

WEBKIT_API gchar *

webkit_favicon_database_get_favicon_uri           (WebKitFaviconDatabase *database,

                                                   const gchar           *page_uri);

WEBKIT_API void

webkit_favicon_database_clear                     (WebKitFaviconDatabase *database);

G_END_DECLS

#endif

/*

 * Copyright (C) 2012 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.

 */

#ifndef WebKitFaviconDatabasePrivate_h

#define WebKitFaviconDatabasePrivate_h

#include "WebIconDatabase.h"

#include "WebKitFaviconDatabase.h"

using namespace WebKit;

WebKitFaviconDatabase* webkitFaviconDatabaseCreate(WebIconDatabase*);

#endif // WebKitFaviconDatabasePrivate_h

#include <WebKit2/WKIconDatabase.h>

#include "WebKitFaviconDatabasePrivate.h"

#include <WebCore/IconDatabase.h>

    GRefPtr<WebKitFaviconDatabase> faviconDatabase;

    CString faviconDatabasePath;

 * webkit_web_context_set_favicon_database_directory:

 * @context: a #WebKitWebContext

 * @path: (allow-none): an absolute path to the icon database

 * directory or %NULL to use the defaults

 *

 * Set the directory path to be used to store the favicons database

 * for @context on disk. Passing %NULL as @path means using the

 * default directory for the platform (see g_get_user_data_dir()).

 *

 * If you want to use a different path for the favicon database, this

 * method must be called before the database is created by

 * webkit_web_context_get_favicon_database(). Note that a

 * #WebKitWebView could use the favicon database, so this should also

 * be called before loading any web page.

 *

 * This function is expected to be called only once, further calls for

 * the same instance of #WebKitWebContext after calling

 * webkit_web_context_get_favicon_database() won't cause any effect.

 */

void webkit_web_context_set_favicon_database_directory(WebKitWebContext* context, const gchar* path)

{

    g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));

    // Calling this method twice is a programming error.

    g_return_if_fail(!context->priv->faviconDatabase);

    if (path)

        context->priv->faviconDatabasePath = WebCore::filenameToString(path).utf8();

}

/**

 * webkit_web_context_get_favicon_database_path:

 * @context: a #WebKitWebContext

 *

 * Get the directory path being used to store the favicons database

 * for @context. This function will always return the same path after

 * having called webkit_web_context_get_favicon_database() for the

 * first time. See webkit_web_context_set_favicon_database_directory()

 * for more details.

 *

 * Returns: (transfer none): the path of the directory of the favicons

 * database associated with @context.

 */

const gchar* webkit_web_context_get_favicon_database_directory(WebKitWebContext *context)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);

    WebKitWebContextPrivate* priv = context->priv;

    // Use default if a different path has not been previously set.

    if (priv->faviconDatabasePath.isNull())

        priv->faviconDatabasePath = toImpl(priv->context.get())->iconDatabasePath().utf8();

    return priv->faviconDatabasePath.data();

}

/**

 * webkit_web_context_get_favicon_database:

 * @context: a #WebKitWebContext

 *

 * Get the #WebKitFaviconDatabase associated with @context. If you

 * want the database to be stored in a directory other than the default

 * one, you need to call

 * webkit_web_context_set_favicon_database_directory() before the first

 * time you use this function.

 *

 * Returns: (transfer none): the #WebKitFaviconDatabase of @context.

 */

WebKitFaviconDatabase* webkit_web_context_get_favicon_database(WebKitWebContext* context)

{

    g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);

    WebKitWebContextPrivate* priv = context->priv;

    if (priv->faviconDatabase)

        return priv->faviconDatabase.get();

    // Build the full path to the icon database file on disk.

    GOwnPtr<gchar> faviconDatabasePath(g_build_filename(webkit_web_context_get_favicon_database_directory(context),

                                                        WebCore::IconDatabase::defaultDatabaseFilename().utf8().data(),

                                                        NULL));

    // Calling the setter in WebContext will cause the icon database to be opened.

    WebContext* webContext = toImpl(priv->context.get());

    webContext->setIconDatabasePath(WebCore::filenameToString(faviconDatabasePath.get()));

    priv->faviconDatabase = adoptGRef(webkitFaviconDatabaseCreate(webContext->iconDatabase()));

    return priv->faviconDatabase.get();

}

/**

#include <webkit2/WebKitFaviconDatabase.h>

WEBKIT_API WebKitFaviconDatabase *

webkit_web_context_get_favicon_database             (WebKitWebContext              *context);

WEBKIT_API void

webkit_web_context_set_favicon_database_directory   (WebKitWebContext              *context,

                                                     const gchar                   *path);

WEBKIT_API const gchar *

webkit_web_context_get_favicon_database_directory   (WebKitWebContext              *context);

    <xi:include href="xml/WebKitFaviconDatabase.xml"/>

webkit_web_context_get_favicon_database

webkit_web_context_set_favicon_database_directory

webkit_web_context_get_favicon_database_directory

<FILE>WebKitFaviconDatabase</FILE>

WebKitFaviconDatabase

WEBKIT_FAVICON_DATABASE_ERROR

WebKitFaviconDatabaseError

webkit_favicon_database_get_favicon

webkit_favicon_database_get_favicon_finish

webkit_favicon_database_get_favicon_uri

webkit_favicon_database_clear

<SUBSECTION Standard>

WebKitFaviconDatabaseClass

WEBKIT_TYPE_FAVICON_DATABASE

WEBKIT_FAVICON_DATABASE

WEBKIT_IS_FAVICON_DATABASE

WEBKIT_FAVICON_DATABASE_CLASS

WEBKIT_IS_FAVICON_DATABASE_CLASS

WEBKIT_FAVICON_DATABASE_GET_CLASS

<SUBSECTION Private>

WebKitFaviconDatabasePrivate

webkit_favicon_database_get_type

webkit_favicon_database_error_quark

</SECTION>

<SECTION>

	Programs/WebKit2APITests/TestWebKitFaviconDatabase \

Programs_WebKit2APITests_TestWebKitFaviconDatabase_SOURCES = \

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

Programs_WebKit2APITests_TestWebKitFaviconDatabase_CPPFLAGS = $(webkit2_tests_cppflags)

Programs_WebKit2APITests_TestWebKitFaviconDatabase_LDADD = $(webkit2_tests_ldadd)

Programs_WebKit2APITests_TestWebKitFaviconDatabase_LDFLAGS = $(webkit2_tests_ldflags)

/*

 * Copyright (C) 2012 Igalia S.L.

 *

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

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

 * License as published by the Free Software Foundation; either

 * version 2,1 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 "WebKitTestServer.h"

#include "WebViewTest.h"

#include <glib/gstdio.h>

#include <libsoup/soup.h>

#include <wtf/gobject/GOwnPtr.h>

static WebKitTestServer* kServer;

static char* kTempDirectory;

class FaviconDatabaseTest: public WebViewTest {

public:

    MAKE_GLIB_TEST_FIXTURE(FaviconDatabaseTest);

    FaviconDatabaseTest()

        : m_webContext(webkit_web_context_get_default())

        , m_iconReadySignalReceived(false)

        , m_iconIsValid(false)

    {

    }

    ~FaviconDatabaseTest()

    {

        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);

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

    }

    static void iconReadyCallback(WebKitFaviconDatabase* database, const char* pageURI, FaviconDatabaseTest* test)

    {

        g_assert_cmpstr(webkit_web_view_get_uri(test->m_webView), ==, pageURI);

        test->m_iconReadySignalReceived = true;

    }

    static void getFaviconCallback(GObject* sourceObject, GAsyncResult* result, void* data)

    {

        FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);

        cairo_surface_t* favicon = webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(sourceObject), result, 0);

        if (favicon)

            cairo_surface_destroy(favicon);

        g_main_loop_quit(test->m_mainLoop);

    }

    static void askForIconAfterLoad(FaviconDatabaseTest* test)

    {

        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);

        webkit_favicon_database_get_favicon(database, kServer->getURIForPath("/").data(), 0, getFaviconCallback, test);

        g_signal_connect(database, "favicon-ready", G_CALLBACK(iconReadyCallback), test);

    }

    static void loadChangedCallback(WebKitWebView*, WebKitLoadEvent loadEvent, FaviconDatabaseTest* test)

    {

        if (loadEvent == WEBKIT_LOAD_FINISHED)

            askForIconAfterLoad(test);

    }

    static void loadFailedCallback(WebKitWebView*, WebKitLoadEvent, const char*, GError*, FaviconDatabaseTest* test)

    {

        askForIconAfterLoad(test);

    }

    void askForIconAndWaitForIconReadySignal()

    {

        g_signal_connect(m_webView, "load-changed", G_CALLBACK(loadChangedCallback), this);

        g_signal_connect(m_webView, "load-failed", G_CALLBACK(loadFailedCallback), this);

        webkit_web_view_load_uri(m_webView, kServer->getURIForPath("/").data());

        g_main_loop_run(m_mainLoop);

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

    }

    static void getValidFaviconCallback(GObject* sourceObject, GAsyncResult* result, void* data)

    {

        FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);

        GError* error = 0;

        cairo_surface_t* favicon = webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(sourceObject), result, &error);

        g_assert(favicon);

        g_assert(!error);

        test->m_iconIsValid = true;

        cairo_surface_destroy(favicon);

        g_main_loop_quit(test->m_mainLoop);

    }

    static void getInvalidFaviconCallback(GObject* sourceObject, GAsyncResult* result, void* data)

    {

        FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);

        GError* error = 0;

        cairo_surface_t* favicon = webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(sourceObject), result, &error);

        g_assert(!favicon);

        g_assert(error && WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND);

        test->m_iconIsValid = false;

        g_main_loop_quit(test->m_mainLoop);

    }

    void askAndWaitForValidFavicon()

    {

        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);

        webkit_favicon_database_get_favicon(database, kServer->getURIForPath("/").data(), 0, getValidFaviconCallback, this);

        g_main_loop_run(m_mainLoop);

    }

    void askAndWaitForInvalidFavicon()

    {

        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);

        webkit_favicon_database_get_favicon(database, "http://www.webkitgtk.org/", 0, getInvalidFaviconCallback, this);

        g_main_loop_run(m_mainLoop);

    }

    WebKitWebContext* m_webContext;

    bool m_iconReadySignalReceived;

    bool m_iconIsValid;

};

static void

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

{

    if (message->method != SOUP_METHOD_GET) {

        soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);

        return;

    }

    soup_message_set_status(message, SOUP_STATUS_OK);

    char* contents;

    gsize length;

    if (g_str_equal(path, "/favicon.ico")) {

        GOwnPtr<char> pathToFavicon(g_build_filename(Test::getWebKit1TestResoucesDir().data(), "blank.ico", NULL));

        gboolean result = g_file_get_contents(pathToFavicon.get(), &contents, &length, 0);

        g_assert(result);

    } else {

        contents = g_strdup("<html><body>test</body></html>");

        length = strlen(contents);

    }

    soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);

    soup_message_body_complete(message->response_body);

}

static void testSetDirectory(FaviconDatabaseTest* test, gconstpointer)

{

    webkit_web_context_set_favicon_database_directory(test->m_webContext, kTempDirectory);

    g_assert_cmpstr(kTempDirectory, ==, webkit_web_context_get_favicon_database_directory(test->m_webContext));

}

static void testClearDatabase(FaviconDatabaseTest* test, gconstpointer)

{

    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);

    webkit_favicon_database_clear(database);

    GOwnPtr<char> iconURI(webkit_favicon_database_get_favicon_uri(database, kServer->getURIForPath("/").data()));

    g_assert(!iconURI);

}

static void testGetFavicon(FaviconDatabaseTest* test, gconstpointer)

{

    test->m_iconReadySignalReceived = false;

    test->askForIconAndWaitForIconReadySignal();

    g_assert(test->m_iconReadySignalReceived);

    test->m_iconIsValid = false;

    test->askAndWaitForValidFavicon();

    g_assert(test->m_iconIsValid);

    test->askAndWaitForInvalidFavicon();

    g_assert(!test->m_iconIsValid);

}

static void testGetFaviconURI(FaviconDatabaseTest* test, gconstpointer)

{

    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);

    const char* baseURI = kServer->getURIForPath("/").data();

    GOwnPtr<char> iconURI(webkit_favicon_database_get_favicon_uri(database, baseURI));

    g_assert_cmpstr(iconURI.get(), ==, kServer->getURIForPath("/favicon.ico").data());

}

static void deleteDatabaseFiles()

{

    if (!g_file_test(kTempDirectory, G_FILE_TEST_IS_DIR))

        return;

    GOwnPtr<char> filename(g_build_filename(kTempDirectory, "WebpageIcons.db", NULL));

    g_unlink(filename.get());

    filename.set(g_build_filename(kTempDirectory, "WebpageIcons.db-journal", NULL));

    g_unlink(filename.get());

    g_rmdir(kTempDirectory);

}

void beforeAll()

{

    // Start a soup server for testing.

    kServer = new WebKitTestServer();

    kServer->run(serverCallback);

    kTempDirectory = g_dir_make_tmp("WebKit2Tests-XXXXXX", 0);

    g_assert(kTempDirectory);

    // Add tests to the suite.

    FaviconDatabaseTest::add("WebKitFaviconDatabase", "set-directory", testSetDirectory);

    FaviconDatabaseTest::add("WebKitFaviconDatabase", "get-favicon", testGetFavicon);

    FaviconDatabaseTest::add("WebKitFaviconDatabase", "get-favicon-uri", testGetFaviconURI);

    FaviconDatabaseTest::add("WebKitFaviconDatabase", "clear-database", testClearDatabase);

}

void afterAll()

{

    delete kServer;

    deleteDatabaseFiles();

}

#include <webkit2/WebKitFaviconDatabase.h>

bool WebIconDatabase::isUrlImportCompleted()

{

    return m_urlImportCompleted;

}

    bool isUrlImportCompleted();