--- /dev/null
+From fb41f028badb4dfddfc47fb2a1a68c1aa90dcef5 Mon Sep 17 00:00:00 2001
+From: Robert Bragg <robert@linux.intel.com>
+Date: Fri, 8 May 2009 13:57:22 +0100
+Subject: [PATCH] Adds initial Gtk clipboard support to moz-headless
+
+If build with MOZ_X11 enabled then this now builds the clipboard code taken
+from the gtk2 backend. This doesn't provide any embedding API yet to expose
+the clipboard.
+---
+ widget/src/headless/Makefile.in | 6 +
+ widget/src/headless/nsClipboard.cpp | 948 +++++++++++++++++++++++++++++++
+ widget/src/headless/nsClipboard.h | 93 +++
+ widget/src/headless/nsIImageToPixbuf.h | 62 ++
+ widget/src/headless/nsImageToPixbuf.cpp | 196 +++++++
+ widget/src/headless/nsImageToPixbuf.h | 71 +++
+ widget/src/headless/nsWidgetFactory.cpp | 18 +
+ 7 files changed, 1394 insertions(+), 0 deletions(-)
+ create mode 100644 widget/src/headless/nsClipboard.cpp
+ create mode 100644 widget/src/headless/nsClipboard.h
+ create mode 100644 widget/src/headless/nsIImageToPixbuf.h
+ create mode 100644 widget/src/headless/nsImageToPixbuf.cpp
+ create mode 100644 widget/src/headless/nsImageToPixbuf.h
+
+diff --git a/widget/src/headless/Makefile.in b/widget/src/headless/Makefile.in
+index c8727d9..cbdf900 100644
+--- a/widget/src/headless/Makefile.in
++++ b/widget/src/headless/Makefile.in
+@@ -95,6 +95,12 @@ CPPSRCS = \
+ nsScreenManagerHeadless.cpp \
+ $(NULL)
+
++ifdef MOZ_X11
++CPPSRCS += nsClipboard.cpp \
++ nsImageToPixbuf.cpp \
++ $(NULL)
++endif
++
+ # build our subdirs, too
+ SHARED_LIBRARY_LIBS = ../xpwidgets/libxpwidgets_s.a
+
+diff --git a/widget/src/headless/nsClipboard.cpp b/widget/src/headless/nsClipboard.cpp
+new file mode 100644
+index 0000000..72a37fc
+--- /dev/null
++++ b/widget/src/headless/nsClipboard.cpp
+@@ -0,0 +1,948 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is Christopher Blizzard
++ * <blizzard@mozilla.org>. Portions created by the Initial Developer
++ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#include "nsClipboard.h"
++#include "nsSupportsPrimitives.h"
++#include "nsString.h"
++#include "nsReadableUtils.h"
++#include "nsXPIDLString.h"
++#include "nsPrimitiveHelpers.h"
++#include "nsICharsetConverterManager.h"
++#include "nsIServiceManager.h"
++#include "nsIImage.h"
++#include "nsImageToPixbuf.h"
++#include "nsStringStream.h"
++
++#include <gtk/gtk.h>
++
++// For manipulation of the X event queue
++#include <X11/Xlib.h>
++#include <gdk/gdkx.h>
++#include <sys/time.h>
++#include <sys/types.h>
++#include <unistd.h>
++
++#ifdef POLL_WITH_XCONNECTIONNUMBER
++#include <poll.h>
++#endif
++
++// Callback when someone asks us for the selection
++void
++invisible_selection_get_cb (GtkWidget *aWidget,
++ GtkSelectionData *aSelectionData,
++ guint aTime,
++ guint aInfo,
++ nsClipboard *aClipboard);
++
++gboolean
++selection_clear_event_cb (GtkWidget *aWidget,
++ GdkEventSelection *aEvent,
++ nsClipboard *aClipboard);
++
++static void
++ConvertHTMLtoUCS2 (guchar *data,
++ PRInt32 dataLength,
++ PRUnichar **unicodeData,
++ PRInt32 &outUnicodeLen);
++
++static void
++GetHTMLCharset (guchar * data, PRInt32 dataLength, nsCString& str);
++
++
++// Our own versions of gtk_clipboard_wait_for_contents and
++// gtk_clipboard_wait_for_text, which don't run the event loop while
++// waiting for the data. This prevents a lot of problems related to
++// dispatching events at unexpected times.
++
++static GtkSelectionData *
++wait_for_contents (GtkClipboard *clipboard, GdkAtom target);
++
++static gchar *
++wait_for_text (GtkClipboard *clipboard);
++
++static Bool
++checkEventProc(Display *display, XEvent *event, XPointer arg);
++
++struct retrieval_context
++{
++ PRBool completed;
++ void *data;
++
++ retrieval_context() : completed(PR_FALSE), data(nsnull) { }
++};
++
++static void
++wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *transferData);
++
++static void
++clipboard_contents_received(GtkClipboard *clipboard,
++ GtkSelectionData *selection_data,
++ gpointer data);
++
++static void
++clipboard_text_received(GtkClipboard *clipboard,
++ const gchar *text,
++ gpointer data);
++
++nsClipboard::nsClipboard()
++{
++ mWidget = nsnull;
++}
++
++nsClipboard::~nsClipboard()
++{
++ if (mWidget)
++ gtk_widget_destroy(mWidget);
++}
++
++NS_IMPL_ISUPPORTS1(nsClipboard, nsIClipboard)
++
++nsresult
++nsClipboard::Init(void)
++{
++ mWidget = gtk_invisible_new();
++ if (!mWidget)
++ return NS_ERROR_FAILURE;
++
++ g_signal_connect(G_OBJECT(mWidget), "selection_get",
++ G_CALLBACK(invisible_selection_get_cb), this);
++
++ g_signal_connect(G_OBJECT(mWidget), "selection_clear_event",
++ G_CALLBACK(selection_clear_event_cb), this);
++
++ // XXX make sure to set up the selection_clear event
++
++ return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::SetData(nsITransferable *aTransferable,
++ nsIClipboardOwner *aOwner, PRInt32 aWhichClipboard)
++{
++ // See if we can short cut
++ if ((aWhichClipboard == kGlobalClipboard &&
++ aTransferable == mGlobalTransferable.get() &&
++ aOwner == mGlobalOwner.get()) ||
++ (aWhichClipboard == kSelectionClipboard &&
++ aTransferable == mSelectionTransferable.get() &&
++ aOwner == mSelectionOwner.get())) {
++ return NS_OK;
++ }
++
++ nsresult rv;
++ if (!mPrivacyHandler) {
++ rv = NS_NewClipboardPrivacyHandler(getter_AddRefs(mPrivacyHandler));
++ NS_ENSURE_SUCCESS(rv, rv);
++ }
++ rv = mPrivacyHandler->PrepareDataForClipboard(aTransferable);
++ NS_ENSURE_SUCCESS(rv, rv);
++
++ // Clear out the clipboard in order to set the new data
++ EmptyClipboard(aWhichClipboard);
++
++ if (aWhichClipboard == kSelectionClipboard) {
++ mSelectionOwner = aOwner;
++ mSelectionTransferable = aTransferable;
++ }
++ else {
++ mGlobalOwner = aOwner;
++ mGlobalTransferable = aTransferable;
++ }
++
++ // Which selection are we about to claim, CLIPBOARD or PRIMARY?
++ GdkAtom selectionAtom = GetSelectionAtom(aWhichClipboard);
++
++ // Make ourselves the owner. If we fail to, return.
++ if (!gtk_selection_owner_set(mWidget, selectionAtom, GDK_CURRENT_TIME))
++ return NS_ERROR_FAILURE;
++
++ // Clear the old selection target list.
++ gtk_selection_clear_targets(mWidget, selectionAtom);
++
++ // Get the types of supported flavors
++ nsCOMPtr<nsISupportsArray> flavors;
++
++ rv = aTransferable->FlavorsTransferableCanExport(getter_AddRefs(flavors));
++ if (!flavors || NS_FAILED(rv))
++ return NS_ERROR_FAILURE;
++
++ // Add all the flavors to this widget's supported type.
++ PRUint32 count;
++ flavors->Count(&count);
++ for (PRUint32 i=0; i < count; i++) {
++ nsCOMPtr<nsISupports> tastesLike;
++ flavors->GetElementAt(i, getter_AddRefs(tastesLike));
++ nsCOMPtr<nsISupportsCString> flavor = do_QueryInterface(tastesLike);
++
++ if (flavor) {
++ nsXPIDLCString flavorStr;
++ flavor->ToString(getter_Copies(flavorStr));
++
++ // special case text/unicode since we can handle all of
++ // the string types
++ if (!strcmp(flavorStr, kUnicodeMime)) {
++ AddTarget(gdk_atom_intern("UTF8_STRING", FALSE),
++ selectionAtom);
++ AddTarget(gdk_atom_intern("COMPOUND_TEXT", FALSE),
++ selectionAtom);
++ AddTarget(gdk_atom_intern("TEXT", FALSE), selectionAtom);
++ AddTarget(GDK_SELECTION_TYPE_STRING, selectionAtom);
++ // next loop iteration
++ continue;
++ }
++
++ // very special case for this one. since our selection mechanism doesn't work for images,
++ // we must use GTK's clipboard utility functions
++ if (!strcmp(flavorStr, kNativeImageMime) || !strcmp(flavorStr, kPNGImageMime) ||
++ !strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
++ nsCOMPtr<nsISupports> item;
++ PRUint32 len;
++ rv = aTransferable->GetTransferData(flavorStr, getter_AddRefs(item), &len);
++ nsCOMPtr<nsISupportsInterfacePointer> ptrPrimitive(do_QueryInterface(item));
++ if (!ptrPrimitive)
++ continue;
++
++ nsCOMPtr<nsISupports> primitiveData;
++ ptrPrimitive->GetData(getter_AddRefs(primitiveData));
++ nsCOMPtr<nsIImage> image(do_QueryInterface(primitiveData));
++ if (!image) // Not getting an image for an image mime type!?
++ continue;
++
++ if (NS_FAILED(image->LockImagePixels(PR_FALSE)))
++ continue;
++ GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
++ if (!pixbuf) {
++ image->UnlockImagePixels(PR_FALSE);
++ continue;
++ }
++
++ GtkClipboard *aClipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
++ gtk_clipboard_set_image(aClipboard, pixbuf);
++ g_object_unref(pixbuf);
++ image->UnlockImagePixels(PR_FALSE);
++ continue;
++ }
++
++ // Add this to our list of valid targets
++ GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
++ AddTarget(atom, selectionAtom);
++ }
++ }
++
++ return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::GetData(nsITransferable *aTransferable, PRInt32 aWhichClipboard)
++{
++ if (!aTransferable)
++ return NS_ERROR_FAILURE;
++
++ GtkClipboard *clipboard;
++ clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
++
++ guchar *data = NULL;
++ gint length = 0;
++ PRBool foundData = PR_FALSE;
++ nsCAutoString foundFlavor;
++
++ // Get a list of flavors this transferable can import
++ nsCOMPtr<nsISupportsArray> flavors;
++ nsresult rv;
++ rv = aTransferable->FlavorsTransferableCanImport(getter_AddRefs(flavors));
++ if (!flavors || NS_FAILED(rv))
++ return NS_ERROR_FAILURE;
++
++ PRUint32 count;
++ flavors->Count(&count);
++ for (PRUint32 i=0; i < count; i++) {
++ nsCOMPtr<nsISupports> genericFlavor;
++ flavors->GetElementAt(i, getter_AddRefs(genericFlavor));
++
++ nsCOMPtr<nsISupportsCString> currentFlavor;
++ currentFlavor = do_QueryInterface(genericFlavor);
++
++ if (currentFlavor) {
++ nsXPIDLCString flavorStr;
++ currentFlavor->ToString(getter_Copies(flavorStr));
++
++ // Special case text/unicode since we can convert any
++ // string into text/unicode
++ if (!strcmp(flavorStr, kUnicodeMime)) {
++ gchar* new_text = wait_for_text(clipboard);
++ if (new_text) {
++ // Convert utf-8 into our unicode format.
++ NS_ConvertUTF8toUTF16 ucs2string(new_text);
++ data = (guchar *)ToNewUnicode(ucs2string);
++ length = ucs2string.Length() * 2;
++ g_free(new_text);
++ foundData = PR_TRUE;
++ foundFlavor = kUnicodeMime;
++ break;
++ }
++ // If the type was text/unicode and we couldn't get
++ // text off the clipboard, run the next loop
++ // iteration.
++ continue;
++ }
++
++ // For images, we must wrap the data in an nsIInputStream then return instead of break,
++ // because that code below won't help us.
++ if (!strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kPNGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
++ GdkAtom atom;
++ if (!strcmp(flavorStr, kJPEGImageMime)) // This is image/jpg, but X only understands image/jpeg
++ atom = gdk_atom_intern("image/jpeg", FALSE);
++ else
++ atom = gdk_atom_intern(flavorStr, FALSE);
++
++ GtkSelectionData *selectionData = wait_for_contents(clipboard, atom);
++ if (!selectionData)
++ continue;
++
++ nsCOMPtr<nsIInputStream> byteStream;
++ NS_NewByteInputStream(getter_AddRefs(byteStream), (const char*)selectionData->data,
++ selectionData->length, NS_ASSIGNMENT_COPY);
++ aTransferable->SetTransferData(flavorStr, byteStream, sizeof(nsIInputStream*));
++ gtk_selection_data_free(selectionData);
++ return NS_OK;
++ }
++
++ // Get the atom for this type and try to request it off
++ // the clipboard.
++ GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
++ GtkSelectionData *selectionData;
++ selectionData = wait_for_contents(clipboard, atom);
++ if (selectionData) {
++ length = selectionData->length;
++ // Special case text/html since we can convert into UCS2
++ if (!strcmp(flavorStr, kHTMLMime)) {
++ PRUnichar* htmlBody= nsnull;
++ PRInt32 htmlBodyLen = 0;
++ // Convert text/html into our unicode format
++ ConvertHTMLtoUCS2((guchar *)selectionData->data, length,
++ &htmlBody, htmlBodyLen);
++ if (!htmlBodyLen)
++ break;
++ data = (guchar *)htmlBody;
++ length = htmlBodyLen * 2;
++ } else {
++ data = (guchar *)nsMemory::Alloc(length);
++ if (!data)
++ break;
++ memcpy(data, selectionData->data, length);
++ }
++ foundData = PR_TRUE;
++ foundFlavor = flavorStr;
++ break;
++ }
++ }
++ }
++
++ if (foundData) {
++ nsCOMPtr<nsISupports> wrapper;
++ nsPrimitiveHelpers::CreatePrimitiveForData(foundFlavor.get(),
++ data, length,
++ getter_AddRefs(wrapper));
++ aTransferable->SetTransferData(foundFlavor.get(),
++ wrapper, length);
++ }
++
++ if (data)
++ nsMemory::Free(data);
++
++ return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::EmptyClipboard(PRInt32 aWhichClipboard)
++{
++ if (aWhichClipboard == kSelectionClipboard) {
++ if (mSelectionOwner) {
++ mSelectionOwner->LosingOwnership(mSelectionTransferable);
++ mSelectionOwner = nsnull;
++ }
++ mSelectionTransferable = nsnull;
++ }
++ else {
++ if (mGlobalOwner) {
++ mGlobalOwner->LosingOwnership(mGlobalTransferable);
++ mGlobalOwner = nsnull;
++ }
++ mGlobalTransferable = nsnull;
++ }
++
++ return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::HasDataMatchingFlavors(const char** aFlavorList, PRUint32 aLength,
++ PRInt32 aWhichClipboard, PRBool *_retval)
++{
++ if (!aFlavorList || !_retval)
++ return NS_ERROR_NULL_POINTER;
++
++ *_retval = PR_FALSE;
++
++ GtkSelectionData *selection_data =
++ GetTargets(GetSelectionAtom(aWhichClipboard));
++ if (!selection_data)
++ return NS_OK;
++
++ gint n_targets = 0;
++ GdkAtom *targets = NULL;
++
++ if (!gtk_selection_data_get_targets(selection_data,
++ &targets, &n_targets) ||
++ !n_targets)
++ return NS_OK;
++
++ // Walk through the provided types and try to match it to a
++ // provided type.
++ for (PRUint32 i = 0; i < aLength && !*_retval; i++) {
++ // We special case text/unicode here.
++ if (!strcmp(aFlavorList[i], kUnicodeMime) &&
++ gtk_selection_data_targets_include_text(selection_data)) {
++ *_retval = PR_TRUE;
++ break;
++ }
++
++ for (PRInt32 j = 0; j < n_targets; j++) {
++ gchar *atom_name = gdk_atom_name(targets[j]);
++ if (!strcmp(atom_name, aFlavorList[i]))
++ *_retval = PR_TRUE;
++
++ // X clipboard wants image/jpeg, not image/jpg
++ if (!strcmp(aFlavorList[i], kJPEGImageMime) && !strcmp(atom_name, "image/jpeg"))
++ *_retval = PR_TRUE;
++
++ g_free(atom_name);
++
++ if (*_retval)
++ break;
++ }
++ }
++ gtk_selection_data_free(selection_data);
++ g_free(targets);
++
++ return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::SupportsSelectionClipboard(PRBool *_retval)
++{
++ *_retval = PR_TRUE; // yeah, unix supports the selection clipboard
++ return NS_OK;
++}
++
++/* static */
++GdkAtom
++nsClipboard::GetSelectionAtom(PRInt32 aWhichClipboard)
++{
++ if (aWhichClipboard == kGlobalClipboard)
++ return GDK_SELECTION_CLIPBOARD;
++
++ return GDK_SELECTION_PRIMARY;
++}
++
++/* static */
++GtkSelectionData *
++nsClipboard::GetTargets(GdkAtom aWhichClipboard)
++{
++ GtkClipboard *clipboard = gtk_clipboard_get(aWhichClipboard);
++ return wait_for_contents(clipboard, gdk_atom_intern("TARGETS", FALSE));
++}
++
++nsITransferable *
++nsClipboard::GetTransferable(PRInt32 aWhichClipboard)
++{
++ nsITransferable *retval;
++
++ if (aWhichClipboard == kSelectionClipboard)
++ retval = mSelectionTransferable.get();
++ else
++ retval = mGlobalTransferable.get();
++
++ return retval;
++}
++
++void
++nsClipboard::AddTarget(GdkAtom aName, GdkAtom aClipboard)
++{
++ gtk_selection_add_target(mWidget, aClipboard, aName, 0);
++}
++
++void
++nsClipboard::SelectionGetEvent (GtkWidget *aWidget,
++ GtkSelectionData *aSelectionData,
++ guint aTime)
++{
++ // Someone has asked us to hand them something. The first thing
++ // that we want to do is see if that something includes text. If
++ // it does, try to give it text/unicode after converting it to
++ // utf-8.
++
++ PRInt32 whichClipboard;
++
++ // which clipboard?
++ if (aSelectionData->selection == GDK_SELECTION_PRIMARY)
++ whichClipboard = kSelectionClipboard;
++ else if (aSelectionData->selection == GDK_SELECTION_CLIPBOARD)
++ whichClipboard = kGlobalClipboard;
++ else
++ return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
++
++ nsCOMPtr<nsITransferable> trans = GetTransferable(whichClipboard);
++
++ nsresult rv;
++ nsCOMPtr<nsISupports> item;
++ PRUint32 len;
++
++ // Check to see if the selection data includes any of the string
++ // types that we support.
++ if (aSelectionData->target == gdk_atom_intern ("STRING", FALSE) ||
++ aSelectionData->target == gdk_atom_intern ("TEXT", FALSE) ||
++ aSelectionData->target == gdk_atom_intern ("COMPOUND_TEXT", FALSE) ||
++ aSelectionData->target == gdk_atom_intern ("UTF8_STRING", FALSE)) {
++ // Try to convert our internal type into a text string. Get
++ // the transferable for this clipboard and try to get the
++ // text/unicode type for it.
++ rv = trans->GetTransferData("text/unicode", getter_AddRefs(item),
++ &len);
++ if (!item || NS_FAILED(rv))
++ return;
++
++ nsCOMPtr<nsISupportsString> wideString;
++ wideString = do_QueryInterface(item);
++ if (!wideString)
++ return;
++
++ nsAutoString ucs2string;
++ wideString->GetData(ucs2string);
++ char *utf8string = ToNewUTF8String(ucs2string);
++ if (!utf8string)
++ return;
++
++ gtk_selection_data_set_text (aSelectionData, utf8string,
++ strlen(utf8string));
++
++ nsMemory::Free(utf8string);
++ return;
++ }
++
++ // Try to match up the selection data target to something our
++ // transferable provides.
++ gchar *target_name = gdk_atom_name(aSelectionData->target);
++ if (!target_name)
++ return;
++
++ rv = trans->GetTransferData(target_name, getter_AddRefs(item), &len);
++ // nothing found?
++ if (!item || NS_FAILED(rv)) {
++ g_free(target_name);
++ return;
++ }
++
++ void *primitive_data = nsnull;
++ nsPrimitiveHelpers::CreateDataFromPrimitive(target_name, item,
++ &primitive_data, len);
++
++ if (primitive_data) {
++ // Check to see if the selection data is text/html
++ if (aSelectionData->target == gdk_atom_intern (kHTMLMime, FALSE)) {
++ /*
++ * "text/html" can be encoded UCS2. It is recommended that
++ * documents transmitted as UCS2 always begin with a ZERO-WIDTH
++ * NON-BREAKING SPACE character (hexadecimal FEFF, also called
++ * Byte Order Mark (BOM)). Adding BOM can help other app to
++ * detect mozilla use UCS2 encoding when copy-paste.
++ */
++ guchar *buffer = (guchar *)
++ nsMemory::Alloc((len * sizeof(guchar)) + sizeof(PRUnichar));
++ if (!buffer)
++ return;
++ PRUnichar prefix = 0xFEFF;
++ memcpy(buffer, &prefix, sizeof(prefix));
++ memcpy(buffer + sizeof(prefix), primitive_data, len);
++ nsMemory::Free((guchar *)primitive_data);
++ primitive_data = (guchar *)buffer;
++ len += sizeof(prefix);
++ }
++
++ gtk_selection_data_set(aSelectionData, aSelectionData->target,
++ 8, /* 8 bits in a unit */
++ (const guchar *)primitive_data, len);
++ nsMemory::Free(primitive_data);
++ }
++
++ g_free(target_name);
++
++}
++
++void
++nsClipboard::SelectionClearEvent (GtkWidget *aWidget,
++ GdkEventSelection *aEvent)
++{
++ PRInt32 whichClipboard;
++
++ // which clipboard?
++ if (aEvent->selection == GDK_SELECTION_PRIMARY)
++ whichClipboard = kSelectionClipboard;
++ else if (aEvent->selection == GDK_SELECTION_CLIPBOARD)
++ whichClipboard = kGlobalClipboard;
++ else
++ return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
++
++ EmptyClipboard(whichClipboard);
++}
++
++void
++invisible_selection_get_cb (GtkWidget *aWidget,
++ GtkSelectionData *aSelectionData,
++ guint aTime,
++ guint aInfo,
++ nsClipboard *aClipboard)
++{
++ aClipboard->SelectionGetEvent(aWidget, aSelectionData, aTime);
++}
++
++gboolean
++selection_clear_event_cb (GtkWidget *aWidget,
++ GdkEventSelection *aEvent,
++ nsClipboard *aClipboard)
++{
++ aClipboard->SelectionClearEvent(aWidget, aEvent);
++ return TRUE;
++}
++
++/*
++ * when copy-paste, mozilla wants data encoded using UCS2,
++ * other app such as StarOffice use "text/html"(RFC2854).
++ * This function convert data(got from GTK clipboard)
++ * to data mozilla wanted.
++ *
++ * data from GTK clipboard can be 3 forms:
++ * 1. From current mozilla
++ * "text/html", charset = utf-16
++ * 2. From old version mozilla or mozilla-based app
++ * content("body" only), charset = utf-16
++ * 3. From other app who use "text/html" when copy-paste
++ * "text/html", has "charset" info
++ *
++ * data : got from GTK clipboard
++ * dataLength: got from GTK clipboard
++ * body : pass to Mozilla
++ * bodyLength: pass to Mozilla
++ */
++void ConvertHTMLtoUCS2(guchar * data, PRInt32 dataLength,
++ PRUnichar** unicodeData, PRInt32& outUnicodeLen)
++{
++ nsCAutoString charset;
++ GetHTMLCharset(data, dataLength, charset);// get charset of HTML
++ if (charset.EqualsLiteral("UTF-16")) {//current mozilla
++ outUnicodeLen = (dataLength / 2) - 1;
++ *unicodeData = reinterpret_cast<PRUnichar*>
++ (nsMemory::Alloc((outUnicodeLen + sizeof('\0')) *
++ sizeof(PRUnichar)));
++ if (*unicodeData) {
++ memcpy(*unicodeData, data + sizeof(PRUnichar),
++ outUnicodeLen * sizeof(PRUnichar));
++ (*unicodeData)[outUnicodeLen] = '\0';
++ }
++ } else if (charset.EqualsLiteral("UNKNOWN")) {
++ outUnicodeLen = 0;
++ return;
++ } else {
++ // app which use "text/html" to copy&paste
++ nsCOMPtr<nsIUnicodeDecoder> decoder;
++ nsresult rv;
++ // get the decoder
++ nsCOMPtr<nsICharsetConverterManager> ccm =
++ do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
++ if (NS_FAILED(rv)) {
++#ifdef DEBUG_CLIPBOARD
++ g_print(" can't get CHARSET CONVERTER MANAGER service\n");
++#endif
++ outUnicodeLen = 0;
++ return;
++ }
++ rv = ccm->GetUnicodeDecoder(charset.get(), getter_AddRefs(decoder));
++ if (NS_FAILED(rv)) {
++#ifdef DEBUG_CLIPBOARD
++ g_print(" get unicode decoder error\n");
++#endif
++ outUnicodeLen = 0;
++ return;
++ }
++ // converting
++ decoder->GetMaxLength((const char *)data, dataLength, &outUnicodeLen);
++ // |outUnicodeLen| is number of chars
++ if (outUnicodeLen) {
++ *unicodeData = reinterpret_cast<PRUnichar*>
++ (nsMemory::Alloc((outUnicodeLen + sizeof('\0')) *
++ sizeof(PRUnichar)));
++ if (*unicodeData) {
++ PRInt32 numberTmp = dataLength;
++ decoder->Convert((const char *)data, &numberTmp,
++ *unicodeData, &outUnicodeLen);
++#ifdef DEBUG_CLIPBOARD
++ if (numberTmp != dataLength)
++ printf("didn't consume all the bytes\n");
++#endif
++ // null terminate. Convert() doesn't do it for us
++ (*unicodeData)[outUnicodeLen] = '\0';
++ }
++ } // if valid length
++ }
++}
++
++/*
++ * get "charset" information from clipboard data
++ * return value can be:
++ * 1. "UTF-16": mozilla or "text/html" with "charset=utf-16"
++ * 2. "UNKNOWN": mozilla can't detect what encode it use
++ * 3. other: "text/html" with other charset than utf-16
++ */
++void GetHTMLCharset(guchar * data, PRInt32 dataLength, nsCString& str)
++{
++ // if detect "FFFE" or "FEFF", assume UTF-16
++ PRUnichar* beginChar = (PRUnichar*)data;
++ if ((beginChar[0] == 0xFFFE) || (beginChar[0] == 0xFEFF)) {
++ str.AssignLiteral("UTF-16");
++ return;
++ }
++ // no "FFFE" and "FEFF", assume ASCII first to find "charset" info
++ const nsDependentCString htmlStr((const char *)data, dataLength);
++ nsACString::const_iterator start, end;
++ htmlStr.BeginReading(start);
++ htmlStr.EndReading(end);
++ nsACString::const_iterator valueStart(start), valueEnd(start);
++
++ if (CaseInsensitiveFindInReadable(
++ NS_LITERAL_CSTRING("CONTENT=\"text/html;"),
++ start, end)) {
++ start = end;
++ htmlStr.EndReading(end);
++
++ if (CaseInsensitiveFindInReadable(
++ NS_LITERAL_CSTRING("charset="),
++ start, end)) {
++ valueStart = end;
++ start = end;
++ htmlStr.EndReading(end);
++
++ if (FindCharInReadable('"', start, end))
++ valueEnd = start;
++ }
++ }
++ // find "charset" in HTML
++ if (valueStart != valueEnd) {
++ str = Substring(valueStart, valueEnd);
++ ToUpperCase(str);
++#ifdef DEBUG_CLIPBOARD
++ printf("Charset of HTML = %s\n", charsetUpperStr.get());
++#endif
++ return;
++ }
++ str.AssignLiteral("UNKNOWN");
++}
++
++static void
++DispatchSelectionNotifyEvent(GtkWidget *widget, XEvent *xevent)
++{
++ GdkEvent event;
++ event.selection.type = GDK_SELECTION_NOTIFY;
++ event.selection.window = widget->window;
++ event.selection.selection = gdk_x11_xatom_to_atom(xevent->xselection.selection);
++ event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target);
++ event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property);
++ event.selection.time = xevent->xselection.time;
++
++ gtk_widget_event(widget, &event);
++}
++
++static void
++DispatchPropertyNotifyEvent(GtkWidget *widget, XEvent *xevent)
++{
++ if (((GdkWindowObject *) widget->window)->event_mask & GDK_PROPERTY_CHANGE_MASK) {
++ GdkEvent event;
++ event.property.type = GDK_PROPERTY_NOTIFY;
++ event.property.window = widget->window;
++ event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom);
++ event.property.time = xevent->xproperty.time;
++ event.property.state = xevent->xproperty.state;
++
++ gtk_widget_event(widget, &event);
++ }
++}
++
++struct checkEventContext
++{
++ GtkWidget *cbWidget;
++ Atom selAtom;
++};
++
++static Bool
++checkEventProc(Display *display, XEvent *event, XPointer arg)
++{
++ checkEventContext *context = (checkEventContext *) arg;
++
++ if (event->xany.type == SelectionNotify ||
++ (event->xany.type == PropertyNotify &&
++ event->xproperty.atom == context->selAtom)) {
++
++ GdkWindow *cbWindow = gdk_window_lookup(event->xany.window);
++ if (cbWindow) {
++ GtkWidget *cbWidget = NULL;
++ gdk_window_get_user_data(cbWindow, (gpointer *)&cbWidget);
++ if (cbWidget && GTK_IS_WIDGET(cbWidget)) {
++ context->cbWidget = cbWidget;
++ return True;
++ }
++ }
++ }
++
++ return False;
++}
++
++// Idle timeout for receiving selection and property notify events (microsec)
++static const int kClipboardTimeout = 500000;
++
++static void
++wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *r_context)
++{
++ if (r_context->completed) // the request completed synchronously
++ return;
++
++ Display *xDisplay = GDK_DISPLAY();
++ checkEventContext context;
++ context.cbWidget = NULL;
++ context.selAtom = gdk_x11_atom_to_xatom(gdk_atom_intern("GDK_SELECTION",
++ FALSE));
++
++ // Send X events which are relevant to the ongoing selection retrieval
++ // to the clipboard widget. Wait until either the operation completes, or
++ // we hit our timeout. All other X events remain queued.
++
++ int select_result;
++
++#ifdef POLL_WITH_XCONNECTIONNUMBER
++ struct pollfd fds[1];
++ fds[0].fd = XConnectionNumber(xDisplay);
++ fds[0].events = POLLIN;
++#else
++ int cnumber = ConnectionNumber(xDisplay);
++ fd_set select_set;
++ FD_ZERO(&select_set);
++ FD_SET(cnumber, &select_set);
++ ++cnumber;
++ struct timeval tv;
++#endif
++
++ do {
++ XEvent xevent;
++
++ while (XCheckIfEvent(xDisplay, &xevent, checkEventProc,
++ (XPointer) &context)) {
++
++ if (xevent.xany.type == SelectionNotify)
++ DispatchSelectionNotifyEvent(context.cbWidget, &xevent);
++ else
++ DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
++
++ if (r_context->completed)
++ return;
++ }
++
++#ifdef POLL_WITH_XCONNECTIONNUMBER
++ select_result = poll(fds, 1, kClipboardTimeout / 1000);
++#else
++ tv.tv_sec = 0;
++ tv.tv_usec = kClipboardTimeout;
++ select_result = select(cnumber, &select_set, NULL, NULL, &tv);
++#endif
++ } while (select_result == 1);
++
++#ifdef DEBUG_CLIPBOARD
++ printf("exceeded clipboard timeout\n");
++#endif
++}
++
++static void
++clipboard_contents_received(GtkClipboard *clipboard,
++ GtkSelectionData *selection_data,
++ gpointer data)
++{
++ retrieval_context *context = static_cast<retrieval_context *>(data);
++ context->completed = PR_TRUE;
++
++ if (selection_data->length >= 0)
++ context->data = gtk_selection_data_copy(selection_data);
++}
++
++
++static GtkSelectionData *
++wait_for_contents(GtkClipboard *clipboard, GdkAtom target)
++{
++ retrieval_context context;
++ gtk_clipboard_request_contents(clipboard, target,
++ clipboard_contents_received,
++ &context);
++
++ wait_for_retrieval(clipboard, &context);
++ return static_cast<GtkSelectionData *>(context.data);
++}
++
++static void
++clipboard_text_received(GtkClipboard *clipboard,
++ const gchar *text,
++ gpointer data)
++{
++ retrieval_context *context = static_cast<retrieval_context *>(data);
++ context->completed = PR_TRUE;
++ context->data = g_strdup(text);
++}
++
++static gchar *
++wait_for_text(GtkClipboard *clipboard)
++{
++ retrieval_context context;
++ gtk_clipboard_request_text(clipboard, clipboard_text_received, &context);
++
++ wait_for_retrieval(clipboard, &context);
++ return static_cast<gchar *>(context.data);
++}
+diff --git a/widget/src/headless/nsClipboard.h b/widget/src/headless/nsClipboard.h
+new file mode 100644
+index 0000000..dc690c0
+--- /dev/null
++++ b/widget/src/headless/nsClipboard.h
+@@ -0,0 +1,93 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is Christopher Blizzard
++ * <blizzard@mozilla.org>. Portions created by the Initial Developer
++ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#ifndef __nsClipboard_h_
++#define __nsClipboard_h_
++
++#include "nsIClipboard.h"
++#include "nsClipboardPrivacyHandler.h"
++#include "nsAutoPtr.h"
++#include <gtk/gtk.h>
++
++class nsClipboard : public nsIClipboard
++{
++public:
++ nsClipboard();
++ virtual ~nsClipboard();
++
++ NS_DECL_ISUPPORTS
++
++ NS_DECL_NSICLIPBOARD
++
++ // Make sure we are initialized, called from the factory
++ // constructor
++ nsresult Init (void);
++ // Someone requested the selection from the hidden widget
++ void SelectionGetEvent (GtkWidget *aWidget,
++ GtkSelectionData *aSelectionData,
++ guint aTime);
++ void SelectionClearEvent (GtkWidget *aWidget,
++ GdkEventSelection *aEvent);
++
++
++private:
++ // Utility methods
++ static GdkAtom GetSelectionAtom (PRInt32 aWhichClipboard);
++ static GtkSelectionData *GetTargets (GdkAtom aWhichClipboard);
++
++ // Get our hands on the correct transferable, given a specific
++ // clipboard
++ nsITransferable *GetTransferable (PRInt32 aWhichClipboard);
++
++ // Add a target type to the hidden widget
++ void AddTarget (GdkAtom aName,
++ GdkAtom aClipboard);
++
++ // The hidden widget where we do all of our operations
++ GtkWidget *mWidget;
++ // Hang on to our owners and transferables so we can transfer data
++ // when asked.
++ nsCOMPtr<nsIClipboardOwner> mSelectionOwner;
++ nsCOMPtr<nsIClipboardOwner> mGlobalOwner;
++ nsCOMPtr<nsITransferable> mSelectionTransferable;
++ nsCOMPtr<nsITransferable> mGlobalTransferable;
++ nsRefPtr<nsClipboardPrivacyHandler> mPrivacyHandler;
++
++};
++
++#endif /* __nsClipboard_h_ */
+diff --git a/widget/src/headless/nsIImageToPixbuf.h b/widget/src/headless/nsIImageToPixbuf.h
+new file mode 100644
+index 0000000..1c46015
+--- /dev/null
++++ b/widget/src/headless/nsIImageToPixbuf.h
+@@ -0,0 +1,62 @@
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org widget code.
++ *
++ * The Initial Developer of the Original Code is
++ * Christian Biesinger <cbiesinger@web.de>.
++ * Portions created by the Initial Developer are Copyright (C) 2006
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#ifndef NSIIMAGETOPIXBUF_H_
++#define NSIIMAGETOPIXBUF_H_
++
++#include "nsISupports.h"
++
++// dfa4ac93-83f2-4ab8-9b2a-0ff7022aebe2
++#define NSIIMAGETOPIXBUF_IID \
++{ 0xdfa4ac93, 0x83f2, 0x4ab8, \
++ { 0x9b, 0x2a, 0x0f, 0xf7, 0x02, 0x2a, 0xeb, 0xe2 } }
++
++class nsIImage;
++typedef struct _GdkPixbuf GdkPixbuf;
++
++/**
++ * An interface that allows converting an nsIImage to a GdkPixbuf*.
++ */
++class nsIImageToPixbuf : public nsISupports {
++ public:
++ NS_DECLARE_STATIC_IID_ACCESSOR(NSIIMAGETOPIXBUF_IID)
++
++ NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(nsIImage* aImage) = 0;
++};
++
++NS_DEFINE_STATIC_IID_ACCESSOR(nsIImageToPixbuf, NSIIMAGETOPIXBUF_IID)
++
++#endif
+diff --git a/widget/src/headless/nsImageToPixbuf.cpp b/widget/src/headless/nsImageToPixbuf.cpp
+new file mode 100644
+index 0000000..496815c
+--- /dev/null
++++ b/widget/src/headless/nsImageToPixbuf.cpp
+@@ -0,0 +1,196 @@
++/* vim:set sw=4 sts=4 et cin: */
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org widget code.
++ *
++ * The Initial Developer of the Original Code is
++ * Christian Biesinger <cbiesinger@web.de>.
++ * Portions created by the Initial Developer are Copyright (C) 2006
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#include <gdk-pixbuf/gdk-pixbuf.h>
++
++#include "gfxASurface.h"
++#include "gfxImageSurface.h"
++#include "gfxContext.h"
++
++#include "nsIImage.h"
++
++#include "nsAutoPtr.h"
++
++#include "nsImageToPixbuf.h"
++
++NS_IMPL_ISUPPORTS1(nsImageToPixbuf, nsIImageToPixbuf)
++
++inline unsigned char
++unpremultiply (unsigned char color,
++ unsigned char alpha)
++{
++ if (alpha == 0)
++ return 0;
++ // plus alpha/2 to round instead of truncate
++ return (color * 255 + alpha / 2) / alpha;
++}
++
++NS_IMETHODIMP_(GdkPixbuf*)
++nsImageToPixbuf::ConvertImageToPixbuf(nsIImage* aImage)
++{
++ return ImageToPixbuf(aImage);
++}
++
++GdkPixbuf*
++nsImageToPixbuf::ImageToPixbuf(nsIImage* aImage)
++{
++ PRInt32 width = aImage->GetWidth(),
++ height = aImage->GetHeight();
++
++ nsRefPtr<gfxPattern> pattern;
++ aImage->GetPattern(getter_AddRefs(pattern));
++
++ return PatternToPixbuf(pattern, width, height);
++}
++
++GdkPixbuf*
++nsImageToPixbuf::ImgSurfaceToPixbuf(gfxImageSurface* aImgSurface, PRInt32 aWidth, PRInt32 aHeight)
++{
++ GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, PR_TRUE, 8,
++ aWidth, aHeight);
++ if (!pixbuf)
++ return nsnull;
++
++ PRUint32 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
++ guchar* pixels = gdk_pixbuf_get_pixels (pixbuf);
++
++ long cairoStride = aImgSurface->Stride();
++ unsigned char* cairoData = aImgSurface->Data();
++
++ gfxASurface::gfxImageFormat format = aImgSurface->Format();
++
++ for (PRInt32 row = 0; row < aHeight; ++row) {
++ for (PRInt32 col = 0; col < aWidth; ++col) {
++ guchar* pixel = pixels + row * rowstride + 4 * col;
++
++ PRUint32* cairoPixel = reinterpret_cast<PRUint32*>
++ ((cairoData + row * cairoStride + 4 * col));
++
++ if (format == gfxASurface::ImageFormatARGB32) {
++ const PRUint8 a = (*cairoPixel >> 24) & 0xFF;
++ const PRUint8 r = unpremultiply((*cairoPixel >> 16) & 0xFF, a);
++ const PRUint8 g = unpremultiply((*cairoPixel >> 8) & 0xFF, a);
++ const PRUint8 b = unpremultiply((*cairoPixel >> 0) & 0xFF, a);
++
++ *pixel++ = r;
++ *pixel++ = g;
++ *pixel++ = b;
++ *pixel++ = a;
++ } else {
++ NS_ASSERTION(format == gfxASurface::ImageFormatRGB24,
++ "unexpected format");
++ const PRUint8 r = (*cairoPixel >> 16) & 0xFF;
++ const PRUint8 g = (*cairoPixel >> 8) & 0xFF;
++ const PRUint8 b = (*cairoPixel >> 0) & 0xFF;
++
++ *pixel++ = r;
++ *pixel++ = g;
++ *pixel++ = b;
++ *pixel++ = 0xFF; // A
++ }
++ }
++ }
++
++ return pixbuf;
++}
++
++GdkPixbuf*
++nsImageToPixbuf::SurfaceToPixbuf(gfxASurface* aSurface, PRInt32 aWidth, PRInt32 aHeight)
++{
++ if (aSurface->CairoStatus()) {
++ NS_ERROR("invalid surface");
++ return nsnull;
++ }
++
++ nsRefPtr<gfxImageSurface> imgSurface;
++ if (aSurface->GetType() == gfxASurface::SurfaceTypeImage) {
++ imgSurface = static_cast<gfxImageSurface*>
++ (static_cast<gfxASurface*>(aSurface));
++ } else {
++ imgSurface = new gfxImageSurface(gfxIntSize(aWidth, aHeight),
++ gfxImageSurface::ImageFormatARGB32);
++
++ if (!imgSurface)
++ return nsnull;
++
++ nsRefPtr<gfxContext> context = new gfxContext(imgSurface);
++ if (!context)
++ return nsnull;
++
++ context->SetOperator(gfxContext::OPERATOR_SOURCE);
++ context->SetSource(aSurface);
++ context->Paint();
++ }
++
++ return ImgSurfaceToPixbuf(imgSurface, aWidth, aHeight);
++}
++
++GdkPixbuf*
++nsImageToPixbuf::PatternToPixbuf(gfxPattern* aPattern, PRInt32 aWidth, PRInt32 aHeight)
++{
++ if (aPattern->CairoStatus()) {
++ NS_ERROR("invalid pattern");
++ return nsnull;
++ }
++
++ nsRefPtr<gfxImageSurface> imgSurface;
++ if (aPattern->GetType() == gfxPattern::PATTERN_SURFACE) {
++ nsRefPtr<gfxASurface> surface = aPattern->GetSurface();
++ if (surface->GetType() == gfxASurface::SurfaceTypeImage) {
++ imgSurface = static_cast<gfxImageSurface*>
++ (static_cast<gfxASurface*>(surface.get()));
++ }
++ }
++
++ if (!imgSurface) {
++ imgSurface = new gfxImageSurface(gfxIntSize(aWidth, aHeight),
++ gfxImageSurface::ImageFormatARGB32);
++
++ if (!imgSurface)
++ return nsnull;
++
++ nsRefPtr<gfxContext> context = new gfxContext(imgSurface);
++ if (!context)
++ return nsnull;
++
++ context->SetOperator(gfxContext::OPERATOR_SOURCE);
++ context->SetPattern(aPattern);
++ context->Paint();
++ }
++
++ return ImgSurfaceToPixbuf(imgSurface, aWidth, aHeight);
++}
+diff --git a/widget/src/headless/nsImageToPixbuf.h b/widget/src/headless/nsImageToPixbuf.h
+new file mode 100644
+index 0000000..0e3f516
+--- /dev/null
++++ b/widget/src/headless/nsImageToPixbuf.h
+@@ -0,0 +1,71 @@
++/* vim:set sw=4 sts=4 et cin: */
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org widget code.
++ *
++ * The Initial Developer of the Original Code is
++ * Christian Biesinger <cbiesinger@web.de>.
++ * Portions created by the Initial Developer are Copyright (C) 2006
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#ifndef NSIMAGETOPIXBUF_H_
++#define NSIMAGETOPIXBUF_H_
++
++#include "nsIImageToPixbuf.h"
++
++class gfxASurface;
++class gfxPattern;
++class gfxImageSurface;
++
++class nsImageToPixbuf : public nsIImageToPixbuf {
++ public:
++ NS_DECL_ISUPPORTS
++ NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(nsIImage* aImage);
++
++ // Friendlier version of ConvertImageToPixbuf for callers inside of
++ // widget
++ static GdkPixbuf* ImageToPixbuf(nsIImage* aImage);
++ static GdkPixbuf* SurfaceToPixbuf(gfxASurface* aSurface,
++ PRInt32 aWidth, PRInt32 aHeight);
++ static GdkPixbuf* PatternToPixbuf(gfxPattern* aPattern,
++ PRInt32 aWidth, PRInt32 aHeight);
++ private:
++ static GdkPixbuf* ImgSurfaceToPixbuf(gfxImageSurface* aImgSurface,
++ PRInt32 aWidth, PRInt32 aHeight);
++ ~nsImageToPixbuf() {}
++};
++
++
++// fc2389b8-c650-4093-9e42-b05e5f0685b7
++#define NS_IMAGE_TO_PIXBUF_CID \
++{ 0xfc2389b8, 0xc650, 0x4093, \
++ { 0x9e, 0x42, 0xb0, 0x5e, 0x5f, 0x06, 0x85, 0xb7 } }
++
++#endif
+diff --git a/widget/src/headless/nsWidgetFactory.cpp b/widget/src/headless/nsWidgetFactory.cpp
+index eb94333..a215988 100644
+--- a/widget/src/headless/nsWidgetFactory.cpp
++++ b/widget/src/headless/nsWidgetFactory.cpp
+@@ -46,6 +46,10 @@
+ #include "nsWindow.h"
+ #include "nsTransferable.h"
+ #include "nsHTMLFormatConverter.h"
++#ifdef MOZ_X11
++#include "nsClipboardHelper.h"
++#include "nsClipboard.h"
++#endif
+ //#include "nsFilePicker.h"
+ #include "nsSound.h"
+ #include "nsBidiKeyboard.h"
+@@ -74,6 +78,10 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsLookAndFeel)
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsTransferable)
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsBidiKeyboard)
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsHTMLFormatConverter)
++#ifdef MOZ_X11
++NS_GENERIC_FACTORY_CONSTRUCTOR(nsClipboardHelper)
++NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsClipboard, Init)
++#endif
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsSound)
+ NS_GENERIC_FACTORY_CONSTRUCTOR(nsScreenManagerHeadless)
+ //NS_GENERIC_FACTORY_CONSTRUCTOR(nsImageToPixbuf)
+@@ -189,6 +197,16 @@ static const nsModuleComponentInfo components[] =
+ NS_TRANSFERABLE_CID,
+ "@mozilla.org/widget/transferable;1",
+ nsTransferableConstructor },
++#ifdef MOZ_X11
++ { "Gtk Clipboard",
++ NS_CLIPBOARD_CID,
++ "@mozilla.org/widget/clipboard;1",
++ nsClipboardConstructor },
++ { "Clipboard Helper",
++ NS_CLIPBOARDHELPER_CID,
++ "@mozilla.org/widget/clipboardhelper;1",
++ nsClipboardHelperConstructor },
++#endif
+ { "HTML Format Converter",
+ NS_HTMLFORMATCONVERTER_CID,
+ "@mozilla.org/widget/htmlformatconverter;1",
+--
+1.6.0.4
+
--- /dev/null
+Index: offscreen/configure.in
+===================================================================
+--- offscreen.orig/configure.in 2009-04-16 22:51:48.000000000 +0100
++++ offscreen/configure.in 2009-04-16 23:07:48.000000000 +0100
+@@ -62,7 +62,6 @@
+
+ AC_PREREQ(2.13)
+ AC_INIT(config/config.mk)
+-AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
+ AC_CANONICAL_SYSTEM
+ TARGET_CPU="${target_cpu}"
+ TARGET_VENDOR="${target_vendor}"
+@@ -103,7 +102,6 @@
+ _SUBDIR_HOST_CFLAGS="$HOST_CFLAGS"
+ _SUBDIR_HOST_CXXFLAGS="$HOST_CXXFLAGS"
+ _SUBDIR_HOST_LDFLAGS="$HOST_LDFLAGS"
+-_SUBDIR_CONFIG_ARGS="$ac_configure_args"
+
+ dnl Set the version number of the libs included with mozilla
+ dnl ========================================================
+@@ -136,6 +134,9 @@
+
+ MSMANIFEST_TOOL=
+
++ac_cv_have_usable_wchar_v2=no
++ac_cv_have_usable_wchar_option_v2=no
++
+ dnl Set various checks
+ dnl ========================================================
+ MISSING_X=
+@@ -281,7 +282,7 @@
+ ;;
+ esac
+
+-if test -n "$CROSS_COMPILE" && test "$target" != "$host"; then
++
+ echo "cross compiling from $host to $target"
+ cross_compiling=yes
+
+@@ -319,7 +320,7 @@
+
+ AC_MSG_CHECKING([whether the host c compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
+ AC_TRY_COMPILE([], [return(0);],
+- [ac_cv_prog_hostcc_works=1 AC_MSG_RESULT([yes])],
++ [ac_cv_prog_hostcc_works=1; AC_MSG_RESULT([yes])],
+ AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CC cannot create executables.]) )
+
+ CC="$HOST_CXX"
+@@ -327,7 +328,7 @@
+
+ AC_MSG_CHECKING([whether the host c++ compiler ($HOST_CXX $HOST_CXXFLAGS $HOST_LDFLAGS) works])
+ AC_TRY_COMPILE([], [return(0);],
+- [ac_cv_prog_hostcxx_works=1 AC_MSG_RESULT([yes])],
++ [ac_cv_prog_hostcxx_works=1; AC_MSG_RESULT([yes])],
+ AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CXX cannot create executables.]) )
+
+ CC=$_SAVE_CC
+@@ -348,7 +349,7 @@
+ ;;
+ esac
+
+- AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", :)
++ CC="${target_alias}-gcc"
+ unset ac_cv_prog_CC
+ AC_PROG_CC
+ AC_CHECK_PROGS(CXX, $CXX "${target_alias}-g++" "${target}-g++", :)
+@@ -372,37 +373,6 @@
+ AC_CHECK_PROGS(STRIP, $STRIP "${target_alias}-strip" "${target}-strip", :)
+ AC_CHECK_PROGS(WINDRES, $WINDRES "${target_alias}-windres" "${target}-windres", :)
+ AC_DEFINE(CROSS_COMPILE)
+-else
+- AC_PROG_CC
+- AC_PROG_CXX
+- AC_PROG_RANLIB
+- MOZ_PATH_PROGS(AS, $AS as, $CC)
+- AC_CHECK_PROGS(AR, ar, :)
+- AC_CHECK_PROGS(LD, ld, :)
+- AC_CHECK_PROGS(STRIP, strip, :)
+- AC_CHECK_PROGS(WINDRES, windres, :)
+- if test -z "$HOST_CC"; then
+- HOST_CC="$CC"
+- fi
+- if test -z "$HOST_CFLAGS"; then
+- HOST_CFLAGS="$CFLAGS"
+- fi
+- if test -z "$HOST_CXX"; then
+- HOST_CXX="$CXX"
+- fi
+- if test -z "$HOST_CXXFLAGS"; then
+- HOST_CXXFLAGS="$CXXFLAGS"
+- fi
+- if test -z "$HOST_LDFLAGS"; then
+- HOST_LDFLAGS="$LDFLAGS"
+- fi
+- if test -z "$HOST_RANLIB"; then
+- HOST_RANLIB="$RANLIB"
+- fi
+- if test -z "$HOST_AR"; then
+- HOST_AR="$AR"
+- fi
+-fi
+
+ GNU_AS=
+ GNU_LD=
+@@ -1569,6 +1539,7 @@
+ '
+
+ dnl test that the macros actually work:
++ac_cv_static_assertion_macros_work="yes"
+ AC_MSG_CHECKING(that static assertion macros used in autoconf tests work)
+ AC_CACHE_VAL(ac_cv_static_assertion_macros_work,
+ [AC_LANG_SAVE
+@@ -2730,9 +2701,13 @@
+ AC_LANG_C
+ AC_HEADER_STDC
+ AC_C_CONST
++ac_cv_type_mode_t=yes
+ AC_TYPE_MODE_T
++ac_cv_type_off_t=yes
+ AC_TYPE_OFF_T
++ac_cv_type_pid_t=yes
+ AC_TYPE_PID_T
++ac_cv_type_size_t=yes
+ AC_TYPE_SIZE_T
+ AC_STRUCT_ST_BLKSIZE
+ AC_MSG_CHECKING(for siginfo_t)
+@@ -3115,19 +3090,9 @@
+ dnl We don't want to link against libm or libpthread on Darwin since
+ dnl they both are just symlinks to libSystem and explicitly linking
+ dnl against libSystem causes issues when debugging (see bug 299601).
+-case $target in
+-*-darwin*)
+- ;;
+-*-beos*)
+- ;;
+-*)
+ AC_CHECK_LIB(m, atan)
+ AC_CHECK_LIB(dl, dlopen,
+- AC_CHECK_HEADER(dlfcn.h,
+- LIBS="-ldl $LIBS"
+- AC_DEFINE(HAVE_LIBDL)))
+- ;;
+-esac
++ AC_DEFINE(HAVE_LIBDL))
+
+ _SAVE_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -D_GNU_SOURCE"
+@@ -6931,18 +6896,13 @@
+
+ # Demangle only for debug or trace-malloc builds
+ MOZ_DEMANGLE_SYMBOLS=
+-if test "$HAVE_DEMANGLE" -a "$HAVE_GCC3_ABI" && test "$MOZ_DEBUG" -o "$NS_TRACE_MALLOC"; then
+- MOZ_DEMANGLE_SYMBOLS=1
+- AC_DEFINE(MOZ_DEMANGLE_SYMBOLS)
+-fi
++
+ AC_SUBST(MOZ_DEMANGLE_SYMBOLS)
+
+ dnl ========================================================
+ dnl = Support for gcc stack unwinding (from gcc 3.3)
+ dnl ========================================================
+-if test "$HAVE_GCC3_ABI" && test -z "$SKIP_LIBRARY_CHECKS"; then
+- AC_CHECK_HEADER(unwind.h, AC_CHECK_FUNCS(_Unwind_Backtrace))
+-fi
++
+
+ dnl ========================================================
+ dnl =
+@@ -7454,10 +7414,7 @@
+ dnl if no gtk/libIDL1 or gtk2/libIDL2 combination was found, fall back
+ dnl to either libIDL1 or libIDL2.
+ if test -z "$_LIBIDL_FOUND"; then
+- AM_PATH_LIBIDL($LIBIDL_VERSION,_LIBIDL_FOUND=1)
+- if test -z "$_LIBIDL_FOUND"; then
+ PKG_CHECK_MODULES(LIBIDL, libIDL-2.0 >= 0.8.0,_LIBIDL_FOUND=1)
+- fi
+ fi
+ dnl
+ dnl If we don't have a libIDL config program & not cross-compiling,
+@@ -7529,13 +7486,7 @@
+ fi
+
+ if test -z "$SKIP_PATH_CHECKS"; then
+-if test -z "${GLIB_CFLAGS}" || test -z "${GLIB_LIBS}" ; then
+- if test "$MOZ_ENABLE_GTK2" || test "$USE_ELF_DYNSTR_GC" || test "$MOZ_ENABLE_HEADLESS"; then
+ PKG_CHECK_MODULES(GLIB, glib-2.0 >= 1.3.7 gobject-2.0)
+- else
+- AM_PATH_GLIB(${GLIB_VERSION})
+- fi
+-fi
+ fi
+
+ if test -z "${GLIB_GMODULE_LIBS}" -a -n "${GLIB_CONFIG}"; then
+@@ -8346,10 +8297,7 @@
+ HAVE_WCRTOMB
+ "
+
+-AC_CONFIG_HEADER(
+-netwerk/necko-config.h
+-xpcom/xpcom-config.h
+-xpcom/xpcom-private.h
++AC_CONFIG_HEADER(netwerk/necko-config.h xpcom/xpcom-config.h xpcom/xpcom-private.h
+ )
+
+ # Save the defines header file before autoconf removes it.
+@@ -8408,31 +8356,11 @@
+ dnl To add new Makefiles, edit allmakefiles.sh.
+ dnl allmakefiles.sh sets the variable, MAKEFILES.
+ . ${srcdir}/allmakefiles.sh
+-dnl
+-dnl Run a perl script to quickly create the makefiles.
+-dnl If it succeeds, it outputs a shell command to set CONFIG_FILES
+-dnl for the files it cannot handle correctly. This way, config.status
+-dnl will handle these files.
+-dnl If it fails, nothing is set and config.status will run as usual.
+-dnl
+-dnl This does not change the $MAKEFILES variable.
+-dnl
+-dnl OpenVMS gets a line overflow on the long eval command, so use a temp file.
+-dnl
+-if test -z "${AS_PERL}"; then
+-echo $MAKEFILES | ${PERL} $srcdir/build/autoconf/acoutput-fast.pl > conftest.sh
+-else
+-echo $MAKEFILES | ${PERL} $srcdir/build/autoconf/acoutput-fast.pl -nowrap --cygwin-srcdir=$srcdir > conftest.sh
+-fi
+-. ./conftest.sh
+-rm conftest.sh
+
+ echo $MAKEFILES > unallmakefiles
+
+ mv -f config/autoconf.mk config/autoconf.mk.orig 2> /dev/null
+
+-AC_OUTPUT($MAKEFILES)
+-
+ dnl Prevent the regeneration of cairo-features.h forcing rebuilds of gfx stuff
+ if test "$CAIRO_FEATURES_H"; then
+ if cmp -s $CAIRO_FEATURES_H "$CAIRO_FEATURES_H".orig; then
+@@ -8458,14 +8386,14 @@
+ HOST_LDFLAGS="$_SUBDIR_HOST_LDFLAGS"
+ RC=
+
+-unset MAKEFILES
+-unset CONFIG_FILES
++#unset MAKEFILES
++#unset CONFIG_FILES
+
+ # No need to run subconfigures when building with LIBXUL_SDK_DIR
+ if test "$COMPILE_ENVIRONMENT" -a -z "$LIBXUL_SDK_DIR"; then
+
+ if test -z "$MOZ_NATIVE_NSPR"; then
+- ac_configure_args="$_SUBDIR_CONFIG_ARGS --with-dist-prefix=$MOZ_BUILD_ROOT/dist --with-mozilla"
++ ac_configure_args="$ac_configure_args --with-dist-prefix=$MOZ_BUILD_ROOT/dist --with-mozilla"
+ if test -z "$MOZ_DEBUG"; then
+ ac_configure_args="$ac_configure_args --disable-debug"
+ fi
+@@ -8481,8 +8409,7 @@
+ if test -n "$USE_ARM_KUSER"; then
+ ac_configure_args="$ac_configure_args --with-arm-kuser"
+ fi
+- AC_OUTPUT_SUBDIRS(nsprpub)
+- ac_configure_args="$_SUBDIR_CONFIG_ARGS"
++ AC_CONFIG_SUBDIRS(nsprpub)
+ fi
+
+ if test -z "$MOZ_NATIVE_NSPR"; then
+@@ -8499,7 +8426,6 @@
+
+ # Run the SpiderMonkey 'configure' script.
+ dist=$MOZ_BUILD_ROOT/dist
+-ac_configure_args="$_SUBDIR_CONFIG_ARGS"
+ ac_configure_args="$ac_configure_args --enable-threadsafe"
+ if test -z "$MOZ_NATIVE_NSPR"; then
+ ac_configure_args="$ac_configure_args --with-nspr-cflags='$NSPR_CFLAGS'"
+@@ -8513,11 +8439,14 @@
+ if test "$MOZ_MEMORY"; then
+ ac_configure_args="$ac_configure_args --enable-jemalloc"
+ fi
+-AC_OUTPUT_SUBDIRS(js/src)
+-ac_configure_args="$_SUBDIR_CONFIG_ARGS"
++AC_CONFIG_SUBDIRS(js/src)
+
+ fi # COMPILE_ENVIRONMENT && !LIBXUL_SDK_DIR
+
++m4_pattern_allow(AS_BIN)
++
++AC_OUTPUT($MAKEFILES)
++
+ dnl Prevent the regeneration of autoconf.mk forcing rebuilds of the world
+ dnl Needs to be at the end to respect possible changes from NSPR configure
+ if cmp -s config/autoconf.mk config/autoconf.mk.orig; then
+Index: offscreen/js/src/configure.in
+===================================================================
+--- offscreen.orig/js/src/configure.in 2009-04-16 22:51:49.000000000 +0100
++++ offscreen/js/src/configure.in 2009-04-16 23:06:42.000000000 +0100
+@@ -62,7 +62,6 @@
+
+ AC_PREREQ(2.13)
+ AC_INIT(jsapi.h)
+-AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
+ AC_CONFIG_HEADER(js-config.h)
+ AC_CANONICAL_SYSTEM
+ TARGET_CPU="${target_cpu}"
+@@ -101,6 +100,9 @@
+ _SUBDIR_HOST_LDFLAGS="$HOST_LDFLAGS"
+ _SUBDIR_CONFIG_ARGS="$ac_configure_args"
+
++ac_cv_have_usable_wchar_v2=no
++ac_cv_have_usable_wchar_option_v2=no
++
+ dnl Set the version number of the libs included with mozilla
+ dnl ========================================================
+ NSPR_VERSION=4
+@@ -114,6 +116,8 @@
+
+ MSMANIFEST_TOOL=
+
++m4_pattern_allow(AS_BIN)
++
+ dnl Set various checks
+ dnl ========================================================
+ MISSING_X=
+@@ -200,7 +204,7 @@
+
+ if test "$COMPILE_ENVIRONMENT"; then
+
+-if test "$target" != "$host"; then
++
+ echo "cross compiling from $host to $target"
+
+ _SAVE_CC="$CC"
+@@ -237,7 +241,7 @@
+
+ AC_MSG_CHECKING([whether the host c compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
+ AC_TRY_COMPILE([], [return(0);],
+- [ac_cv_prog_hostcc_works=1 AC_MSG_RESULT([yes])],
++ [ac_cv_prog_hostcc_works=1; AC_MSG_RESULT([yes])],
+ AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CC cannot create executables.]) )
+
+ CC="$HOST_CXX"
+@@ -245,7 +249,7 @@
+
+ AC_MSG_CHECKING([whether the host c++ compiler ($HOST_CXX $HOST_CXXFLAGS $HOST_LDFLAGS) works])
+ AC_TRY_COMPILE([], [return(0);],
+- [ac_cv_prog_hostcxx_works=1 AC_MSG_RESULT([yes])],
++ [ac_cv_prog_hostcxx_works=1; AC_MSG_RESULT([yes])],
+ AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CXX cannot create executables.]) )
+
+ CC=$_SAVE_CC
+@@ -266,7 +270,7 @@
+ ;;
+ esac
+
+- AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", :)
++ CC="${target_alias}-gcc"
+ unset ac_cv_prog_CC
+ AC_PROG_CC
+ AC_CHECK_PROGS(CXX, $CXX "${target_alias}-g++" "${target}-g++", :)
+@@ -296,37 +300,6 @@
+ dnl able to run ppc code in a translated environment, making a cross
+ dnl compiler appear native. So we override that here.
+ cross_compiling=yes
+-else
+- AC_PROG_CC
+- AC_PROG_CXX
+- AC_PROG_RANLIB
+- MOZ_PATH_PROGS(AS, $AS as, $CC)
+- AC_CHECK_PROGS(AR, ar, :)
+- AC_CHECK_PROGS(LD, ld, :)
+- AC_CHECK_PROGS(STRIP, strip, :)
+- AC_CHECK_PROGS(WINDRES, windres, :)
+- if test -z "$HOST_CC"; then
+- HOST_CC="$CC"
+- fi
+- if test -z "$HOST_CFLAGS"; then
+- HOST_CFLAGS="$CFLAGS"
+- fi
+- if test -z "$HOST_CXX"; then
+- HOST_CXX="$CXX"
+- fi
+- if test -z "$HOST_CXXFLAGS"; then
+- HOST_CXXFLAGS="$CXXFLAGS"
+- fi
+- if test -z "$HOST_LDFLAGS"; then
+- HOST_LDFLAGS="$LDFLAGS"
+- fi
+- if test -z "$HOST_RANLIB"; then
+- HOST_RANLIB="$RANLIB"
+- fi
+- if test -z "$HOST_AR"; then
+- HOST_AR="$AR"
+- fi
+-fi
+
+ GNU_AS=
+ GNU_LD=
+@@ -1435,6 +1408,8 @@
+ fi # GNU_CC
+ fi # COMPILE_ENVIRONMENT
+
++ac_cv_static_assertion_macros_work=yes
++
+ dnl =================================================================
+ dnl Set up and test static assertion macros used to avoid AC_TRY_RUN,
+ dnl which is bad when cross compiling.
+@@ -2565,9 +2540,13 @@
+ AC_LANG_C
+ AC_HEADER_STDC
+ AC_C_CONST
++ac_cv_type_mode_t=yes
+ AC_TYPE_MODE_T
++ac_cv_type_off_t=yes
+ AC_TYPE_OFF_T
++ac_cv_type_pid_t=yes
+ AC_TYPE_PID_T
++ac_cv_type_size_t=yes
+ AC_TYPE_SIZE_T
+ AC_STRUCT_ST_BLKSIZE
+ AC_MSG_CHECKING(for siginfo_t)
+@@ -2592,7 +2571,8 @@
+
+ AC_CHECK_HEADER(stdint.h)
+ if test "$ac_cv_header_stdint_h" = yes; then
+- AC_DEFINE(JS_HAVE_STDINT_H)
++ AC_DEFINE(JS_HAVE_STDINT_H, 1, [have stdint.h])
++ AC_DEFINE(HAVE_STDINT_H)
+ else
+ dnl We'll figure them out for ourselves. List more likely types
+ dnl earlier. If we ever really encounter a size for which none of
+@@ -2990,10 +2970,7 @@
+ ;;
+ *)
+ AC_CHECK_LIB(m, atan)
+- AC_CHECK_LIB(dl, dlopen,
+- AC_CHECK_HEADER(dlfcn.h,
+- LIBS="-ldl $LIBS"
+- AC_DEFINE(HAVE_LIBDL)))
++ AC_CHECK_LIB(dl, dlopen, AC_DEFINE(HAVE_LIBDL))
+ ;;
+ esac
+
+@@ -3908,6 +3885,7 @@
+ [ --with-nspr-libs=LIBS Pass LIBS to LD when linking code that uses NSPR.
+ See --with-nspr-cflags for more details.],
+ NSPR_LIBS=$withval)
++$NSPR_LIBS="$NSPR_LIBS -L$(LIBXUL_DIST)/sdk/lib"
+ AC_SUBST(NSPR_CFLAGS)
+ AC_SUBST(NSPR_LIBS)
+
+@@ -4542,18 +4520,11 @@
+
+ # Demangle only for debug or trace-malloc builds
+ MOZ_DEMANGLE_SYMBOLS=
+-if test "$HAVE_DEMANGLE" -a "$HAVE_GCC3_ABI" && test "$MOZ_DEBUG" -o "$NS_TRACE_MALLOC"; then
+- MOZ_DEMANGLE_SYMBOLS=1
+- AC_DEFINE(MOZ_DEMANGLE_SYMBOLS)
+-fi
+ AC_SUBST(MOZ_DEMANGLE_SYMBOLS)
+
+ dnl ========================================================
+ dnl = Support for gcc stack unwinding (from gcc 3.3)
+ dnl ========================================================
+-if test "$HAVE_GCC3_ABI" && test -z "$SKIP_LIBRARY_CHECKS"; then
+- AC_CHECK_HEADER(unwind.h, AC_CHECK_FUNCS(_Unwind_Backtrace))
+-fi
+
+ dnl ========================================================
+ dnl =
+@@ -5256,6 +5227,8 @@
+ done
+ AC_SUBST(LIBS_PATH)
+
++
++
+ dnl ========================================================
+ dnl JavaScript shell
+ dnl ========================================================
+@@ -5396,3 +5369,4 @@
+ # 'js-config' in Makefile.in.
+ AC_MSG_RESULT(invoking make to create js-config script)
+ $MAKE js-config
++
+Index: offscreen/nsprpub/configure.in
+===================================================================
+--- offscreen.orig/nsprpub/configure.in 2009-04-16 18:09:00.000000000 +0100
++++ offscreen/nsprpub/configure.in 2009-04-16 23:06:42.000000000 +0100
+@@ -42,7 +42,6 @@
+ AC_PREREQ(2.12)
+ AC_INIT(config/libc_r.h)
+
+-AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
+ AC_CANONICAL_SYSTEM
+
+ dnl ========================================================
+@@ -400,7 +399,7 @@
+ dnl ========================================================
+ dnl Checks for compilers.
+ dnl ========================================================
+-if test "$target" != "$host"; then
++
+ echo "cross compiling from $host to $target"
+ cross_compiling=yes
+
+@@ -427,7 +426,7 @@
+
+ AC_MSG_CHECKING([whether the $host compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
+ AC_TRY_COMPILE([], [return(0);],
+- [ac_cv_prog_host_cc_works=1 AC_MSG_RESULT([yes])],
++ [ac_cv_prog_host_cc_works=1; AC_MSG_RESULT([yes])],
+ AC_MSG_ERROR([installation or configuration problem: $host compiler $HOST_CC cannot create executables.]) )
+
+ CC=$_SAVE_CC
+@@ -448,7 +447,7 @@
+ ;;
+ esac
+
+- AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", echo)
++ CC="${target_alias}-gcc"
+ unset ac_cv_prog_CC
+ AC_PROG_CC
+ if test -n "$USE_CPLUS"; then
+@@ -474,30 +473,6 @@
+ AC_CHECK_PROGS(STRIP, $STRIP "${target_alias}-strip" "${target}-strip", echo)
+ AC_CHECK_PROGS(WINDRES, $WINDRES "${target_alias}-windres" "${target}-windres", echo)
+
+-else
+- AC_PROG_CC
+- if test -n "$USE_CPLUS"; then
+- if test "$CC" = "cl" -a -z "$CXX"; then
+- CXX=$CC
+- else
+- AC_PROG_CXX
+- fi
+- fi
+- AC_PROG_CPP
+- AC_PROG_RANLIB
+- AC_PATH_PROGS(AS, as, $CC)
+- AC_PATH_PROGS(AR, ar, echo not_ar)
+- AC_PATH_PROGS(LD, ld link, echo not_ld)
+- AC_PATH_PROGS(STRIP, strip, echo not_strip)
+- AC_PATH_PROGS(WINDRES, windres, echo not_windres)
+- if test -z "$HOST_CC"; then
+- HOST_CC="$CC"
+- fi
+- if test -z "$HOST_CFLAGS"; then
+- HOST_CFLAGS="$CFLAGS"
+- fi
+-fi
+-
+ if test "$GCC" = "yes"; then
+ GNU_CC=1
+ fi
+@@ -518,11 +493,8 @@
+ ;;
+ esac
+
+-if test "$cross_compiling" = "yes"; then
++
+ CROSS_COMPILE=1
+-else
+- CROSS_COMPILE=
+-fi
+
+ dnl ========================================================
+ dnl Check for gcc -pipe support
+@@ -2249,10 +2221,7 @@
+ *-darwin*|*-beos*)
+ ;;
+ *)
+- AC_CHECK_LIB(dl, dlopen,
+- AC_CHECK_HEADER(dlfcn.h,
+- OS_LIBS="-ldl $OS_LIBS"))
+- ;;
++ AC_CHECK_LIB(dl, dlopen)
+ esac
+
+
+@@ -2869,6 +2838,8 @@
+ dnl pr/tests/w16gui/Makefile
+ dnl tools/Makefile
+
++m4_pattern_allow(AS_BIN)
++
+ if test -z "$USE_PTHREADS" && test -z "$USE_BTHREADS"; then
+ MAKEFILES="$MAKEFILES pr/src/threads/combined/Makefile"
+ elif test -n "$USE_PTHREADS"; then
+@@ -2884,3 +2855,5 @@
+ echo $MAKEFILES > unallmakefiles
+
+ AC_OUTPUT([$MAKEFILES], [chmod +x config/nspr-config])
++
++
+Index: offscreen/toolkit/toolkit-makefiles.sh
+===================================================================
+--- offscreen.orig/toolkit/toolkit-makefiles.sh 2009-04-16 22:51:50.000000000 +0100
++++ offscreen/toolkit/toolkit-makefiles.sh 2009-04-16 23:06:42.000000000 +0100
+@@ -628,7 +628,6 @@
+ toolkit/crashreporter/client/Makefile
+ toolkit/crashreporter/google-breakpad/src/client/Makefile
+ toolkit/crashreporter/google-breakpad/src/client/mac/handler/Makefile
+- toolkit/crashreporter/google-breakpad/src/client/windows/Makefile
+ toolkit/crashreporter/google-breakpad/src/client/windows/handler/Makefile
+ toolkit/crashreporter/google-breakpad/src/client/windows/sender/Makefile
+ toolkit/crashreporter/google-breakpad/src/common/Makefile
+Index: offscreen/js/src/Makefile.in
+===================================================================
+--- offscreen.orig/js/src/Makefile.in 2009-04-16 18:07:56.000000000 +0100
++++ offscreen/js/src/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -507,20 +507,8 @@
+
+ export:: jsautocfg.h
+
+-ifeq (,$(CROSS_COMPILE)$(GNU_CC)$(filter-out WINNT,$(OS_ARCH)))
+ jsautocfg.h:
+ touch $@
+-else
+-ifeq ($(OS_ARCH),WINCE)
+-jsautocfg.h:
+- touch $@
+-else
+-jsautocfg.h: jscpucfg$(HOST_BIN_SUFFIX)
+- @rm -f $@ jsautocfg.tmp
+- ./jscpucfg > jsautocfg.tmp
+- mv jsautocfg.tmp $@
+-endif
+-endif
+
+ # jscpucfg is a strange target
+ # Needs to be built with the host compiler but needs to include
+@@ -550,7 +538,7 @@
+ echo no need to build jscpucfg $<
+ else
+ jscpucfg$(HOST_BIN_SUFFIX): jscpucfg.cpp Makefile.in
+- $(HOST_CXX) $(HOST_CXXFLAGS) $(JSCPUCFG_DEFINES) $(DEFINES) $(NSPR_CFLAGS) $(HOST_OUTOPTION)$@ $<
++ $(HOST_CXX) $(HOST_CXXFLAGS) $(JSCPUCFG_DEFINES) $(DEFINES) -I$(DIST)/sdk/include $(NSPR_CFLAGS) $(HOST_OUTOPTION)$@ $<
+ endif
+ endif
+
+Index: offscreen/js/src/xpconnect/loader/mozJSComponentLoader.cpp
+===================================================================
+--- offscreen.orig/js/src/xpconnect/loader/mozJSComponentLoader.cpp 2009-04-16 18:08:00.000000000 +0100
++++ offscreen/js/src/xpconnect/loader/mozJSComponentLoader.cpp 2009-04-16 23:06:42.000000000 +0100
+@@ -47,6 +47,8 @@
+
+ #include <stdarg.h>
+
++#include "mozilla-config.h"
++
+ #include "prlog.h"
+
+ #include "nsCOMPtr.h"
+Index: offscreen/js/src/xpconnect/loader/mozJSSubScriptLoader.cpp
+===================================================================
+--- offscreen.orig/js/src/xpconnect/loader/mozJSSubScriptLoader.cpp 2009-04-16 18:08:00.000000000 +0100
++++ offscreen/js/src/xpconnect/loader/mozJSSubScriptLoader.cpp 2009-04-16 23:06:42.000000000 +0100
+@@ -39,6 +39,8 @@
+ *
+ * ***** END LICENSE BLOCK ***** */
+
++#include "mozilla-config.h"
++
+ #if !defined(XPCONNECT_STANDALONE) && !defined(NO_SUBSCRIPT_LOADER)
+
+ #include "mozJSSubScriptLoader.h"
+Index: offscreen/modules/lcms/include/icc34.h
+===================================================================
+--- offscreen.orig/modules/lcms/include/icc34.h 2009-04-16 18:08:47.000000000 +0100
++++ offscreen/modules/lcms/include/icc34.h 2009-04-16 23:06:42.000000000 +0100
+@@ -144,7 +144,7 @@
+ */
+
+
+-#ifdef PACKAGE_NAME
++#if 0
+ /*
+ June 9, 2003, Adapted for use with configure by Bob Friesenhahn
+ Added the stupid check for autoconf by Marti Maria.
+Index: offscreen/toolkit/mozapps/update/src/updater/Makefile.in
+===================================================================
+--- offscreen.orig/toolkit/mozapps/update/src/updater/Makefile.in 2009-04-16 18:09:35.000000000 +0100
++++ offscreen/toolkit/mozapps/update/src/updater/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -59,7 +59,7 @@
+
+ LIBS += \
+ $(DEPTH)/modules/libmar/src/$(LIB_PREFIX)mar.$(LIB_SUFFIX) \
+- $(BZ2_LIBS) \
++ $(BZ2_LIBS) -lpthread \
+ $(NULL)
+
+ ifeq ($(OS_ARCH),WINNT)
+Index: offscreen/xpcom/sample/program/Makefile.in
+===================================================================
+--- offscreen.orig/xpcom/sample/program/Makefile.in 2009-04-16 18:09:47.000000000 +0100
++++ offscreen/xpcom/sample/program/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -57,7 +57,7 @@
+ # that the application be linked against the XPCOM dynamic library or the NSPR
+ # dynamic libraries.
+ LIBS = \
+- $(XPCOM_STANDALONE_GLUE_LDOPTS) \
++ $(XPCOM_STANDALONE_GLUE_LDOPTS) -ldl \
+ $(NULL)
+
+ # Need to link with CoreFoundation on Mac
+Index: offscreen/xpcom/tools/registry/Makefile.in
+===================================================================
+--- offscreen.orig/xpcom/tools/registry/Makefile.in 2009-04-16 18:09:48.000000000 +0100
++++ offscreen/xpcom/tools/registry/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -54,7 +54,7 @@
+ SIMPLE_PROGRAMS = $(CPPSRCS:.cpp=$(BIN_SUFFIX))
+
+ LIBS = \
+- $(XPCOM_STANDALONE_GLUE_LDOPTS) \
++ $(XPCOM_STANDALONE_GLUE_LDOPTS) -ldl \
+ $(NULL)
+
+ # Need to link with CoreFoundation on Mac
+Index: offscreen/xulrunner/app/Makefile.in
+===================================================================
+--- offscreen.orig/xulrunner/app/Makefile.in 2009-04-16 18:09:50.000000000 +0100
++++ offscreen/xulrunner/app/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -180,7 +180,7 @@
+ RCFLAGS += -DXULRUNNER_ICO=\"$(DIST)/branding/xulrunner.ico\" -DDOCUMENT_ICO=\"$(DIST)/branding/document.ico\"
+ endif
+
+-LIBS += $(JEMALLOC_LIBS)
++LIBS += $(JEMALLOC_LIBS) -lpthread -ldl
+
+ include $(topsrcdir)/config/rules.mk
+
+Index: offscreen/xulrunner/stub/Makefile.in
+===================================================================
+--- offscreen.orig/xulrunner/stub/Makefile.in 2009-04-16 18:09:50.000000000 +0100
++++ offscreen/xulrunner/stub/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -101,7 +101,7 @@
+ endif
+ endif
+
+-LIBS += $(JEMALLOC_LIBS)
++LIBS += $(JEMALLOC_LIBS) -lpthread -ldl
+
+ include $(topsrcdir)/config/rules.mk
+
+Index: offscreen/modules/plugin/test/testplugin/Makefile.in
+===================================================================
+--- offscreen.orig/modules/plugin/test/testplugin/Makefile.in 2009-04-16 18:08:56.000000000 +0100
++++ offscreen/modules/plugin/test/testplugin/Makefile.in 2009-04-16 23:06:42.000000000 +0100
+@@ -63,9 +63,7 @@
+ CMMSRCS = nptest_macosx.mm
+ endif
+
+-ifeq ($(MOZ_WIDGET_TOOLKIT),gtk2)
+ CPPSRCS += nptest_gtk2.cpp
+-endif
+
+ ifeq ($(MOZ_WIDGET_TOOLKIT),qt)
+ CPPSRCS += nptest_qt.cpp
+Index: offscreen/xulrunner/installer/libxul-unstable.pc.in
+===================================================================
+--- offscreen.orig/xulrunner/installer/libxul-unstable.pc.in 2009-04-16 18:09:50.000000000 +0100
++++ offscreen/xulrunner/installer/libxul-unstable.pc.in 2009-04-16 23:06:42.000000000 +0100
+@@ -8,5 +8,5 @@
+ Description: The Mozilla Runtime and Embedding Engine (unstable API)
+ Version: %MOZILLA_VERSION%
+ Requires: %NSPR_NAME% >= %NSPR_VERSION%
+-Libs: -L${sdkdir}/lib -lxpcomglue_s -lxul -lxpcom
++Libs: -L${sdkdir}/lib -lxpcomglue_s -lxul -lxpcom -lsmime3 -lnss3 -lssl3 -lnssutil3 -L${sdkdir}/../xulrunner-1.9.2a1pre
+ Cflags: -I${includedir}/${includetype} %WCHAR_CFLAGS%
+Index: offscreen/js/src/aclocal.m4
+===================================================================
+--- offscreen.orig/js/src/aclocal.m4 2009-04-16 18:07:56.000000000 +0100
++++ offscreen/js/src/aclocal.m4 2009-04-16 23:06:42.000000000 +0100
+@@ -9,4 +9,3 @@
+ builtin(include, build/autoconf/moznbytetype.m4)dnl
+ builtin(include, build/autoconf/mozprog.m4)dnl
+
+-MOZ_PROG_CHECKMSYS()
