WebKitFaviconDatabase.cpp [plain text]
#include "config.h"
#include "WebKitFaviconDatabase.h"
#include "WebKitFaviconDatabasePrivate.h"
#include "WebKitMarshal.h"
#include "WebKitPrivate.h"
#include <WebCore/FileSystem.h>
#include <WebCore/Image.h>
#include <WebCore/IntSize.h>
#include <WebCore/RefPtrCairo.h>
#include <glib/gi18n-lib.h>
#include <wtf/RunLoop.h>
#include <wtf/glib/GRefPtr.h>
#include <wtf/glib/GUniquePtr.h>
#include <wtf/text/CString.h>
using namespace WebKit;
using namespace WebCore;
enum {
FAVICON_CHANGED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0, };
typedef Vector<GRefPtr<GTask> > PendingIconRequestVector;
typedef HashMap<String, PendingIconRequestVector*> PendingIconRequestMap;
struct _WebKitFaviconDatabasePrivate {
RefPtr<WebIconDatabase> iconDatabase;
PendingIconRequestMap pendingIconRequests;
HashMap<String, String> pageURLToIconURLMap;
};
WEBKIT_DEFINE_TYPE(WebKitFaviconDatabase, webkit_favicon_database, G_TYPE_OBJECT)
static void webkitFaviconDatabaseDispose(GObject* object)
{
WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(object);
WebKitFaviconDatabasePrivate* priv = database->priv;
if (priv->iconDatabase->isOpen())
priv->iconDatabase->close();
G_OBJECT_CLASS(webkit_favicon_database_parent_class)->dispose(object);
}
static void webkit_favicon_database_class_init(WebKitFaviconDatabaseClass* faviconDatabaseClass)
{
GObjectClass* gObjectClass = G_OBJECT_CLASS(faviconDatabaseClass);
gObjectClass->dispose = webkitFaviconDatabaseDispose;
signals[FAVICON_CHANGED] =
g_signal_new(
"favicon-changed",
G_TYPE_FROM_CLASS(faviconDatabaseClass),
G_SIGNAL_RUN_LAST,
0, 0, 0,
webkit_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2,
G_TYPE_STRING,
G_TYPE_STRING);
}
struct GetFaviconSurfaceAsyncData {
~GetFaviconSurfaceAsyncData()
{
if (shouldReleaseIconForPageURL)
faviconDatabase->priv->iconDatabase->releaseIconForPageURL(pageURL);
}
GRefPtr<WebKitFaviconDatabase> faviconDatabase;
String pageURL;
RefPtr<cairo_surface_t> icon;
GRefPtr<GCancellable> cancellable;
bool shouldReleaseIconForPageURL;
};
WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetFaviconSurfaceAsyncData)
static PassRefPtr<cairo_surface_t> getIconSurfaceSynchronously(WebKitFaviconDatabase* database, const String& pageURL, GError** error)
{
ASSERT(RunLoop::isMain());
WebCore::Image* iconImage = database->priv->iconDatabase->imageForPageURL(pageURL, WebCore::IntSize(1, 1));
if (!iconImage) {
g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN, _("Unknown favicon for page %s"), pageURL.utf8().data());
return 0;
}
RefPtr<cairo_surface_t> surface = iconImage->nativeImageForCurrentFrame();
if (!surface) {
g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, _("Page %s does not have a favicon"), pageURL.utf8().data());
return 0;
}
return surface.release();
}
static void deletePendingIconRequests(WebKitFaviconDatabase* database, PendingIconRequestVector* requests, const String& pageURL)
{
database->priv->pendingIconRequests.remove(pageURL);
delete requests;
}
static void processPendingIconsForPageURL(WebKitFaviconDatabase* database, const String& pageURL)
{
PendingIconRequestVector* pendingIconRequests = database->priv->pendingIconRequests.get(pageURL);
if (!pendingIconRequests)
return;
GUniqueOutPtr<GError> error;
RefPtr<cairo_surface_t> icon = getIconSurfaceSynchronously(database, pageURL, &error.outPtr());
for (size_t i = 0; i < pendingIconRequests->size(); ++i) {
GTask* task = pendingIconRequests->at(i).get();
if (error)
g_task_return_error(task, error.release().release());
else {
GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_task_get_task_data(task));
data->icon = icon;
data->shouldReleaseIconForPageURL = false;
g_task_return_boolean(task, TRUE);
}
}
deletePendingIconRequests(database, pendingIconRequests, pageURL);
}
static void didChangeIconForPageURLCallback(WKIconDatabaseRef, WKURLRef wkPageURL, const void* clientInfo)
{
WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(clientInfo);
if (!database->priv->iconDatabase->isUrlImportCompleted())
return;
String pageURL = toImpl(wkPageURL)->string();
WebCore::Image* iconImage = database->priv->iconDatabase->imageForPageURL(pageURL, WebCore::IntSize(1, 1));
if (!iconImage || iconImage->isNull())
return;
String currentIconURL;
database->priv->iconDatabase->synchronousIconURLForPageURL(pageURL, currentIconURL);
const String& iconURL = database->priv->pageURLToIconURLMap.get(pageURL);
if (iconURL == currentIconURL)
return;
database->priv->pageURLToIconURLMap.set(pageURL, currentIconURL);
g_signal_emit(database, signals[FAVICON_CHANGED], 0, pageURL.utf8().data(), currentIconURL.utf8().data());
}
static void iconDataReadyForPageURLCallback(WKIconDatabaseRef, WKURLRef wkPageURL, const void* clientInfo)
{
ASSERT(RunLoop::isMain());
processPendingIconsForPageURL(WEBKIT_FAVICON_DATABASE(clientInfo), toImpl(wkPageURL)->string());
}
WebKitFaviconDatabase* webkitFaviconDatabaseCreate(WebIconDatabase* iconDatabase)
{
WebKitFaviconDatabase* faviconDatabase = WEBKIT_FAVICON_DATABASE(g_object_new(WEBKIT_TYPE_FAVICON_DATABASE, NULL));
faviconDatabase->priv->iconDatabase = iconDatabase;
WKIconDatabaseClientV1 wkIconDatabaseClient = {
{
1, faviconDatabase, },
didChangeIconForPageURLCallback,
0, iconDataReadyForPageURLCallback,
};
WKIconDatabaseSetIconDatabaseClient(toAPI(iconDatabase), &wkIconDatabaseClient.base);
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;
}
GQuark webkit_favicon_database_error_quark(void)
{
return g_quark_from_static_string("WebKitFaviconDatabaseError");
}
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);
WebKitFaviconDatabasePrivate* priv = database->priv;
WebIconDatabase* iconDatabaseImpl = priv->iconDatabase.get();
if (!iconDatabaseImpl->isOpen()) {
g_task_report_new_error(database, callback, userData, 0,
WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED, _("Favicons database not initialized yet"));
return;
}
if (g_str_has_prefix(pageURI, "about:")) {
g_task_report_new_error(database, callback, userData, 0,
WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, _("Page %s does not have a favicon"), pageURI);
return;
}
GRefPtr<GTask> task = adoptGRef(g_task_new(database, cancellable, callback, userData));
GetFaviconSurfaceAsyncData* data = createGetFaviconSurfaceAsyncData();
data->faviconDatabase = database;
data->pageURL = String::fromUTF8(pageURI);
g_task_set_task_data(task.get(), data, reinterpret_cast<GDestroyNotify>(destroyGetFaviconSurfaceAsyncData));
priv->iconDatabase->retainIconForPageURL(data->pageURL);
GUniqueOutPtr<GError> error;
data->icon = getIconSurfaceSynchronously(database, data->pageURL, &error.outPtr());
if (data->icon) {
g_task_return_boolean(task.get(), TRUE);
return;
}
data->shouldReleaseIconForPageURL = true;
if (g_error_matches(error.get(), WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND)) {
g_task_return_error(task.get(), error.release().release());
return;
}
String iconURLForPageURL;
iconDatabaseImpl->synchronousIconURLForPageURL(data->pageURL, iconURLForPageURL);
if (!iconURLForPageURL.isEmpty() || !iconDatabaseImpl->isUrlImportCompleted()) {
PendingIconRequestVector* iconRequests = getOrCreatePendingIconRequests(database, data->pageURL);
ASSERT(iconRequests);
iconRequests->append(task);
return;
}
g_task_return_new_error(task.get(), WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN,
_("Unknown favicon for page %s"), pageURI);
}
cairo_surface_t* webkit_favicon_database_get_favicon_finish(WebKitFaviconDatabase* database, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_FAVICON_DATABASE(database), 0);
g_return_val_if_fail(g_task_is_valid(result, database), 0);
GTask* task = G_TASK(result);
if (!g_task_propagate_boolean(task, error))
return 0;
GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_task_get_task_data(task));
return cairo_surface_reference(data->icon.get());
}
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(RunLoop::isMain());
String iconURLForPageURL;
database->priv->iconDatabase->synchronousIconURLForPageURL(String::fromUTF8(pageURL), iconURLForPageURL);
if (iconURLForPageURL.isEmpty())
return 0;
return g_strdup(iconURLForPageURL.utf8().data());
}
void webkit_favicon_database_clear(WebKitFaviconDatabase* database)
{
g_return_if_fail(WEBKIT_IS_FAVICON_DATABASE(database));
database->priv->iconDatabase->removeAllIcons();
}