Merge Webkit at r58956: Initial merge by Git.

Change-Id: I1d9fb60ea2c3f2ddc04c17a871acdb39353be228

11 files changed, 418 insertions, 68 deletions

diff --git a/WebCore/platform/gtk/ClipboardGtk.cpp b/WebCore/platform/gtk/ClipboardGtk.cpp
index 93a21e2..9bee55a 100644
--- a/WebCore/platform/gtk/ClipboardGtk.cpp
+++ b/WebCore/platform/gtk/ClipboardGtk.cpp
@@ -24,6 +24,8 @@
 #include "Frame.h"
 #include "Image.h"
 #include "NotImplemented.h"
+#include "Pasteboard.h"
+#include "PasteboardHelper.h"
 #include "RenderImage.h"
 #include "StringHash.h"
 #include "markup.h"
@@ -32,13 +34,33 @@
 
 namespace WebCore {
 
+enum ClipboardType {
+    ClipboardTypeText,
+    ClipboardTypeMarkup,
+    ClipboardTypeURIList,
+    ClipboardTypeURL,
+    ClipboardTypeImage,
+    ClipboardTypeUnknown
+};
+
 PassRefPtr<Clipboard> Editor::newGeneralClipboard(ClipboardAccessPolicy policy)
 {
-    return ClipboardGtk::create(policy, false);
+    return ClipboardGtk::create(policy, gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD), false);
+}
+
+ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, GtkClipboard* clipboard)
+    : Clipboard(policy, false)
+    , m_dataObject(DataObjectGtk::forClipboard(clipboard))
+    , m_clipboard(clipboard)
+    , m_helper(Pasteboard::generalPasteboard()->helper())
+{
 }
 
-ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, bool forDragging)
+ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, PassRefPtr<DataObjectGtk> dataObject, bool forDragging)
     : Clipboard(policy, forDragging)
+    , m_dataObject(dataObject)
+    , m_clipboard(0)
+    , m_helper(Pasteboard::generalPasteboard()->helper())
 {
 }
 
@@ -46,39 +68,197 @@ ClipboardGtk::~ClipboardGtk()
 {
 }
 
-void ClipboardGtk::clearData(const String&)
+static ClipboardType dataObjectTypeFromHTMLClipboardType(const String& rawType)
 {
-    notImplemented();
+    String type(rawType.stripWhiteSpace());
+
+    // Two special cases for IE compatibility
+    if (type == "Text")
+        return ClipboardTypeText;
+    if (type == "URL")
+        return ClipboardTypeURL;
+
+    // From the Mac port: Ignore any trailing charset - JS strings are
+    // Unicode, which encapsulates the charset issue.
+    if (type == "text/plain" || type.startsWith("text/plain;"))
+        return ClipboardTypeText;
+    if (type == "text/html" || type.startsWith("text/html;"))
+        return ClipboardTypeMarkup;
+    if (type == "Files" || type == "text/uri-list" || type.startsWith("text/uri-list;"))
+        return ClipboardTypeURIList;
+
+    // Not a known type, so just default to using the text portion.
+    return ClipboardTypeUnknown;
 }
 
+void ClipboardGtk::clearData(const String& typeString)
+{
+    if (policy() != ClipboardWritable)
+        return;
+
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    switch (type) {
+    case ClipboardTypeURIList:
+    case ClipboardTypeURL:
+        m_dataObject->clearURIList();
+        break;
+    case ClipboardTypeMarkup:
+        m_dataObject->clearMarkup();
+        break;
+    case ClipboardTypeText:
+        m_dataObject->clearText();
+        break;
+    case ClipboardTypeUnknown:
+    default:
+        m_dataObject->clear();
+    }
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+}
+
+
 void ClipboardGtk::clearAllData()
 {
-    notImplemented();
+    if (policy() != ClipboardWritable)
+        return;
+
+    m_dataObject->clear();
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
 
-String ClipboardGtk::getData(const String&, bool &success) const
+static String joinURIList(Vector<KURL> uriList)
 {
-    notImplemented();
-    success = false;
+    if (uriList.isEmpty())
+        return String();
+
+    String joined(uriList[0].string());
+    for (size_t i = 1; i < uriList.size(); i++) {
+        joined.append("\r\n");
+        joined.append(uriList[i].string());
+    }
+
+    return joined;
+}
+
+String ClipboardGtk::getData(const String& typeString, bool& success) const
+{
+    success = false; // Pessimism.
+    if (policy() != ClipboardReadable || !m_dataObject)
+        return String();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    if (type == ClipboardTypeURIList) {
+        if (!m_dataObject->hasURIList())
+            return String();
+        success = true;
+        return joinURIList(m_dataObject->uriList());
+    }
+
+    if (type == ClipboardTypeURL) {
+        if (!m_dataObject->hasURL())
+            return String();
+        success = true;
+        return m_dataObject->url();
+    }
+
+    if (type == ClipboardTypeMarkup) {
+        if (!m_dataObject->hasMarkup())
+            return String();
+        success = true;
+        return m_dataObject->markup();
+    }
+
+    if (type == ClipboardTypeText) {
+        if (!m_dataObject->hasText())
+                return String();
+        success = true;
+        return m_dataObject->text();
+    }
+
     return String();
 }
 
-bool ClipboardGtk::setData(const String&, const String&)
+bool ClipboardGtk::setData(const String& typeString, const String& data)
 {
-    notImplemented();
-    return false;
+    if (policy() != ClipboardWritable)
+        return false;
+
+    bool success = false;
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    if (type == ClipboardTypeURIList || type == ClipboardTypeURL) {
+        Vector<KURL> uriList;
+        gchar** uris = g_uri_list_extract_uris(data.utf8().data());
+        if (uris) {
+            gchar** currentURI = uris;
+            while (*currentURI) {
+                uriList.append(KURL(KURL(), *currentURI));
+                currentURI++;
+            }
+            g_strfreev(uris);
+            m_dataObject->setURIList(uriList);
+            success = true;
+        }
+    } else if (type == ClipboardTypeMarkup) {
+        m_dataObject->setMarkup(data);
+        success = true;
+    } else if (type == ClipboardTypeText) {
+        m_dataObject->setText(data);
+        success = true;
+    }
+
+    if (success && m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+
+    return success;
 }
 
 HashSet<String> ClipboardGtk::types() const
 {
-    notImplemented();
-    return HashSet<String>();
+    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
+        return HashSet<String>();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    HashSet<String> types;
+    if (m_dataObject->hasText()) {
+        types.add("text/plain");
+        types.add("Text");
+    }
+
+    if (m_dataObject->hasMarkup())
+        types.add("text/html");
+
+    if (m_dataObject->hasURIList()) {
+        types.add("text/uri-list");
+        types.add("URL");
+        types.add("Files");
+    }
+
+    return types;
 }
 
 PassRefPtr<FileList> ClipboardGtk::files() const
 {
-    notImplemented();
-    return 0;
+    if (policy() != ClipboardReadable)
+        return FileList::create();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    RefPtr<FileList> fileList = FileList::create();
+    Vector<String> fileVector(m_dataObject->files());
+
+    for (size_t i = 0; i < fileVector.size(); i++)
+        fileList->append(File::create(fileVector[i]));
+
+    return fileList.release();
 }
 
 IntPoint ClipboardGtk::dragLocation() const
@@ -151,44 +331,54 @@ void ClipboardGtk::declareAndWriteDragImage(Element* element, const KURL& url, c
 
 void ClipboardGtk::writeURL(const KURL& url, const String& label, Frame*)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    GtkClipboard* urlClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardUrl"));
-    GtkClipboard* urlLabelClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardUrlLabel"));
-
-    gtk_clipboard_clear(textClipboard);
-    gtk_clipboard_clear(urlClipboard);
-    gtk_clipboard_clear(urlLabelClipboard);
-
-    gtk_clipboard_set_text(textClipboard, url.string().utf8().data(), -1);
-    gtk_clipboard_set_text(urlClipboard, url.string().utf8().data(), -1);
-    gtk_clipboard_set_text(urlLabelClipboard, label.utf8().data(), -1);
+    String actualLabel(label);
+    if (actualLabel.isEmpty())
+        actualLabel = url;
+
+    m_dataObject->setText(url.string());
+
+    Vector<UChar> markup;
+    append(markup, "<a href=\"");
+    append(markup, url.string());
+    append(markup, "\">");
+    append(markup, label);
+    append(markup, "</a>");
+    m_dataObject->setMarkup(String::adopt(markup));
+
+    Vector<KURL> uriList;
+    uriList.append(url);
+    m_dataObject->setURIList(uriList);
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
 
 void ClipboardGtk::writeRange(Range* range, Frame* frame)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    GtkClipboard* htmlClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardHtml"));
+    ASSERT(range);
 
-    gtk_clipboard_clear(textClipboard);
-    gtk_clipboard_clear(htmlClipboard);
+    m_dataObject->setText(frame->selectedText());
+    m_dataObject->setMarkup(createMarkup(range, 0, AnnotateForInterchange));
 
-    gtk_clipboard_set_text(textClipboard, frame->selectedText().utf8().data(), -1);
-    gtk_clipboard_set_text(htmlClipboard, createMarkup(range, 0, AnnotateForInterchange).utf8().data(), -1);
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
 
 void ClipboardGtk::writePlainText(const String& text)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    
-    gtk_clipboard_clear(textClipboard);
-    
-    gtk_clipboard_set_text(textClipboard, text.utf8().data(), -1);
+    m_dataObject->setText(text);
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
-    
+
 bool ClipboardGtk::hasData()
 {
-    notImplemented();
-    return false;
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    return m_dataObject->hasText() || m_dataObject->hasMarkup()
+        || m_dataObject->hasURIList() || m_dataObject->hasImage();
 }
 
 }
diff --git a/WebCore/platform/gtk/ClipboardGtk.h b/WebCore/platform/gtk/ClipboardGtk.h
index 74e36b1..c3438c4 100644
--- a/WebCore/platform/gtk/ClipboardGtk.h
+++ b/WebCore/platform/gtk/ClipboardGtk.h
@@ -28,17 +28,26 @@
 #define ClipboardGtk_h
 
 #include "Clipboard.h"
+#include "DataObjectGtk.h"
+
+typedef struct _GtkClipboard GtkClipboard;
 
 namespace WebCore {
     class CachedImage;
+    class PasteboardHelper;
 
     // State available during IE's events for drag and drop and copy/paste
     // Created from the EventHandlerGtk to be used by the dom
     class ClipboardGtk : public Clipboard {
     public:
-        static PassRefPtr<ClipboardGtk> create(ClipboardAccessPolicy policy, bool isForDragging)
+        static PassRefPtr<ClipboardGtk> create(ClipboardAccessPolicy policy, GtkClipboard* clipboard, bool isForDragging)
+        {
+            return adoptRef(new ClipboardGtk(policy, clipboard));
+        }
+
+        static PassRefPtr<ClipboardGtk> create(ClipboardAccessPolicy policy, PassRefPtr<DataObjectGtk> dataObject, bool isForDragging)
         {
-            return adoptRef(new ClipboardGtk(policy, isForDragging));
+            return adoptRef(new ClipboardGtk(policy, dataObject, isForDragging));
         }
         virtual ~ClipboardGtk();
 
@@ -64,8 +73,16 @@ namespace WebCore {
 
         virtual bool hasData();
 
+        PasteboardHelper* helper() { return m_helper; }
+        PassRefPtr<DataObjectGtk> dataObject() { return m_dataObject; }
+
     private:
-        ClipboardGtk(ClipboardAccessPolicy, bool);
+        ClipboardGtk(ClipboardAccessPolicy, GtkClipboard*);
+        ClipboardGtk(ClipboardAccessPolicy, PassRefPtr<DataObjectGtk>, bool);
+
+        RefPtr<DataObjectGtk> m_dataObject;
+        GtkClipboard* m_clipboard;
+        PasteboardHelper* m_helper;
     };
 }
 
diff --git a/WebCore/platform/gtk/CursorGtk.cpp b/WebCore/platform/gtk/CursorGtk.cpp
index 1c669f3..705c2ae 100644
--- a/WebCore/platform/gtk/CursorGtk.cpp
+++ b/WebCore/platform/gtk/CursorGtk.cpp
@@ -88,13 +88,15 @@ Cursor::Cursor(GdkCursor* c)
     : m_impl(c)
 {
     m_impl = c;
-    ASSERT(c);
-    gdk_cursor_ref(c);
+
+    // The GdkCursor may be NULL - the default cursor for the window.
+    if (c)
+        gdk_cursor_ref(c);
 }
 
 const Cursor& pointerCursor()
 {
-    static Cursor c = gdk_cursor_new(GDK_LEFT_PTR);
+    static Cursor c = 0;
     return c;
 }
 
diff --git a/WebCore/platform/gtk/DataObjectGtk.cpp b/WebCore/platform/gtk/DataObjectGtk.cpp
index 900fe8e..57d920c 100644
--- a/WebCore/platform/gtk/DataObjectGtk.cpp
+++ b/WebCore/platform/gtk/DataObjectGtk.cpp
@@ -24,6 +24,13 @@
 
 namespace WebCore {
 
+static void replaceNonBreakingSpaceWithSpace(String& str)
+{
+    static const UChar NonBreakingSpaceCharacter = 0xA0;
+    static const UChar SpaceCharacter = ' ';
+    str.replace(NonBreakingSpaceCharacter, SpaceCharacter);
+}
+
 String DataObjectGtk::text()
 {
     if (m_range)
@@ -34,7 +41,7 @@ String DataObjectGtk::text()
 String DataObjectGtk::markup()
 {
     if (m_range)
-        createMarkup(m_range.get(), 0, AnnotateForInterchange);
+        return createMarkup(m_range.get(), 0, AnnotateForInterchange);
     return m_markup;
 }
 
@@ -42,6 +49,7 @@ void DataObjectGtk::setText(const String& newText)
 {
     m_range = 0;
     m_text = newText;
+    replaceNonBreakingSpaceWithSpace(m_text);
 }
 
 void DataObjectGtk::setMarkup(const String& newMarkup)
@@ -50,6 +58,18 @@ void DataObjectGtk::setMarkup(const String& newMarkup)
     m_markup = newMarkup;
 }
 
+void DataObjectGtk::clearText()
+{
+    m_range = 0;
+    m_text = "";
+}
+
+void DataObjectGtk::clearMarkup()
+{
+    m_range = 0;
+    m_markup = "";
+}
+
 Vector<String> DataObjectGtk::files()
 {
     Vector<KURL> uris(uriList());
diff --git a/WebCore/platform/gtk/DataObjectGtk.h b/WebCore/platform/gtk/DataObjectGtk.h
index 22158d4..41f8f49 100644
--- a/WebCore/platform/gtk/DataObjectGtk.h
+++ b/WebCore/platform/gtk/DataObjectGtk.h
@@ -50,6 +50,8 @@ public:
     bool hasMarkup() { return m_range || !m_markup.isEmpty(); }
     bool hasURIList() { return !m_uriList.isEmpty(); }
     bool hasImage() { return m_image; }
+    void clearURIList() { m_uriList.clear(); }
+    void clearImage() { m_image = 0; }
     GdkDragContext* dragContext() { return m_dragContext.get(); }
 
     String text();
@@ -61,6 +63,8 @@ public:
     String url();
     String urlLabel();
     void clear();
+    void clearText();
+    void clearMarkup();
 
     static DataObjectGtk* forClipboard(GtkClipboard*);
 
diff --git a/WebCore/platform/gtk/PasteboardGtk.cpp b/WebCore/platform/gtk/PasteboardGtk.cpp
index 907a55e..9e7b23a 100644
--- a/WebCore/platform/gtk/PasteboardGtk.cpp
+++ b/WebCore/platform/gtk/PasteboardGtk.cpp
@@ -61,7 +61,7 @@ static void clipboard_get_contents_cb(GtkClipboard *clipboard, GtkSelectionData
     if (info == Pasteboard::generalPasteboard()->helper()->getIdForTargetType(PasteboardHelper::TargetTypeMarkup))
         gtk_selection_data_set(selection_data, selection_data->target, 8,
                                reinterpret_cast<const guchar*>(clipboardData->markup()),
-                               g_utf8_strlen(clipboardData->markup(), -1));
+                               strlen(clipboardData->markup()));
     else
         gtk_selection_data_set_text(selection_data, clipboardData->text(), -1);
 }
diff --git a/WebCore/platform/gtk/PasteboardHelper.cpp b/WebCore/platform/gtk/PasteboardHelper.cpp
index be32ea5..3dc4cc0 100644
--- a/WebCore/platform/gtk/PasteboardHelper.cpp
+++ b/WebCore/platform/gtk/PasteboardHelper.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2010 Martin Robinson <mrobinson@webkit.org>
+ * Copyright (C) Igalia S.L.
  * All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ -26,12 +27,15 @@
 #include "Frame.h"
 #include "Page.h"
 #include "Pasteboard.h"
+#include "TextResourceDecoder.h"
 #include <gtk/gtk.h>
 #include <wtf/gobject/GOwnPtr.h>
 
 namespace WebCore {
 
 static GdkAtom gdkMarkupAtom = gdk_atom_intern("text/html", FALSE);
+static GdkAtom netscapeURLAtom = gdk_atom_intern("_NETSCAPE_URL", FALSE);
+static GdkAtom uriListAtom = gdk_atom_intern("text/uri-list", FALSE);
 
 PasteboardHelper::PasteboardHelper()
     : m_targetList(gtk_target_list_new(0, 0))
@@ -48,6 +52,8 @@ void PasteboardHelper::initializeTargetList()
 {
     gtk_target_list_add_text_targets(m_targetList, getIdForTargetType(TargetTypeText));
     gtk_target_list_add(m_targetList, gdkMarkupAtom, 0, getIdForTargetType(TargetTypeMarkup));
+    gtk_target_list_add_uri_targets(m_targetList, getIdForTargetType(TargetTypeURIList));
+    gtk_target_list_add(m_targetList, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
 }
 
 static inline GtkWidget* widgetFromFrame(Frame* frame)
@@ -84,16 +90,85 @@ GtkTargetList* PasteboardHelper::targetList() const
     return m_targetList;
 }
 
+static Vector<KURL> urisToKURLVector(gchar** uris)
+{
+    ASSERT(uris);
+
+    Vector<KURL> uriList;
+    for (int i = 0; *(uris + i); i++)
+        uriList.append(KURL(KURL(), *(uris + i)));
+
+    return uriList;
+}
+
+void PasteboardHelper::getClipboardContents(GtkClipboard* clipboard)
+{
+    DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
+    ASSERT(dataObject);
+
+    if (gtk_clipboard_wait_is_text_available(clipboard)) {
+        GOwnPtr<gchar> textData(gtk_clipboard_wait_for_text(clipboard));
+        if (textData)
+            dataObject->setText(String::fromUTF8(textData.get()));
+    }
+
+    if (gtk_clipboard_wait_is_target_available(clipboard, gdkMarkupAtom)) {
+       if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, gdkMarkupAtom)) {
+          RefPtr<TextResourceDecoder> decoder(TextResourceDecoder::create("text/plain", "UTF-8", true));
+          String markup(decoder->decode(reinterpret_cast<char*>(data->data), data->length));
+          markup += decoder->flush();
+          dataObject->setMarkup(markup);
+          gtk_selection_data_free(data);
+       }
+    }
+
+    if (gtk_clipboard_wait_is_target_available(clipboard, uriListAtom)) {
+        if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, uriListAtom)) {
+            gchar** uris = gtk_selection_data_get_uris(data);
+            if (uris) {
+                dataObject->setURIList(urisToKURLVector(uris));
+                g_strfreev(uris);
+            }
+            gtk_selection_data_free(data);
+        }
+    }
+}
+
 void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
 {
     if (info == getIdForTargetType(TargetTypeText))
         gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
+
     else if (info == getIdForTargetType(TargetTypeMarkup)) {
         GOwnPtr<gchar> markup(g_strdup(dataObject->markup().utf8().data()));
         gtk_selection_data_set(selectionData, selectionData->target, 8,
-                               reinterpret_cast<const guchar*>(markup.get()),
-                               strlen(markup.get()));
-    }
+            reinterpret_cast<const guchar*>(markup.get()), strlen(markup.get()));
+
+    } else if (info == getIdForTargetType(TargetTypeURIList)) {
+        Vector<KURL> uriList(dataObject->uriList());
+        gchar** uris = g_new0(gchar*, uriList.size() + 1);
+        for (size_t i = 0; i < uriList.size(); i++)
+            uris[i] = g_strdup(uriList[i].string().utf8().data());
+
+        gtk_selection_data_set_uris(selectionData, uris);
+        g_strfreev(uris);
+
+    } else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
+        String url(dataObject->url());
+        String result(url);
+        result.append("\n");
+
+        if (dataObject->hasText())
+            result.append(dataObject->text());
+        else
+            result.append(url);
+
+        GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
+        gtk_selection_data_set(selectionData, selectionData->target, 8,
+            reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
+
+    } else if (info == getIdForTargetType(TargetTypeImage))
+        gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
 }
 
 GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject)
@@ -106,6 +181,14 @@ GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObje
     if (dataObject->hasMarkup())
         gtk_target_list_add(list, gdkMarkupAtom, 0, getIdForTargetType(TargetTypeMarkup));
 
+    if (dataObject->hasURIList()) {
+        gtk_target_list_add_uri_targets(list, getIdForTargetType(TargetTypeURIList));
+        gtk_target_list_add(list, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
+    }
+
+    if (dataObject->hasImage())
+        gtk_target_list_add_image_targets(list, getIdForTargetType(TargetTypeImage), TRUE);
+
     return list;
 }
 
diff --git a/WebCore/platform/gtk/PasteboardHelper.h b/WebCore/platform/gtk/PasteboardHelper.h
index 6e5d366..2d46adc 100644
--- a/WebCore/platform/gtk/PasteboardHelper.h
+++ b/WebCore/platform/gtk/PasteboardHelper.h
@@ -2,6 +2,7 @@
  * Copyright (C) 2007 Luca Bruno <lethalman88@gmail.com>
  * Copyright (C) 2009 Holger Hans Peter Freyther
  * Copyright (C) 2010 Martin Robinson <mrobinson@webkit.org>
+ * Copyright (C) 2010 Igalia S.L.
  * All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ -49,8 +50,10 @@ public:
     GtkClipboard* getClipboard(Frame*) const;
     GtkClipboard* getPrimarySelectionClipboard(Frame*) const;
     GtkTargetList* targetList() const;
+    GtkTargetList* targetListForDataObject(DataObjectGtk*);
     void fillSelectionData(GtkSelectionData*, guint, DataObjectGtk*);
-    void writeClipboardContents(GtkClipboard*, GClosure*);
+    void writeClipboardContents(GtkClipboard*, GClosure* closure = 0);
+    void getClipboardContents(GtkClipboard*);
 
     enum PasteboardTargetType { TargetTypeText, TargetTypeMarkup, TargetTypeURIList, TargetTypeNetscapeURL, TargetTypeImage, TargetTypeUnknown };
     virtual guint getIdForTargetType(PasteboardTargetType) = 0;
@@ -61,7 +64,6 @@ protected:
 
 private:
     GtkTargetList* m_targetList;
-    GtkTargetList* targetListForDataObject(DataObjectGtk*);
 };
 
 }
diff --git a/WebCore/platform/gtk/RenderThemeGtk.cpp b/WebCore/platform/gtk/RenderThemeGtk.cpp
index 93794ff..31af1a9 100644
--- a/WebCore/platform/gtk/RenderThemeGtk.cpp
+++ b/WebCore/platform/gtk/RenderThemeGtk.cpp
@@ -92,8 +92,11 @@ void RenderThemeGtk::initMediaStyling(GtkStyle* style, bool force)
         m_seekForwardButton.clear();
 
         m_fullscreenButton = Image::loadPlatformThemeIcon("gtk-fullscreen", m_mediaIconSize);
-        m_muteButton = Image::loadPlatformThemeIcon("audio-volume-muted", m_mediaIconSize);
-        m_unmuteButton = Image::loadPlatformThemeIcon("audio-volume-high", m_mediaIconSize);
+        // Note that the muteButton and unmuteButton take icons reflecting
+        // the *current* state. Hence, the unmuteButton represents the *muted*
+        // status, the muteButton represents the then current *unmuted* status.
+        m_muteButton = Image::loadPlatformThemeIcon("audio-volume-high", m_mediaIconSize);
+        m_unmuteButton = Image::loadPlatformThemeIcon("audio-volume-muted", m_mediaIconSize);
         m_playButton = Image::loadPlatformThemeIcon(reinterpret_cast<const char*>(playButtonIconName), m_mediaIconSize);
         m_pauseButton = Image::loadPlatformThemeIcon("gtk-media-pause", m_mediaIconSize).releaseRef();
         m_seekBackButton = Image::loadPlatformThemeIcon(reinterpret_cast<const char*>(seekBackButtonIconName), m_mediaIconSize);
diff --git a/WebCore/platform/gtk/ScrollViewGtk.cpp b/WebCore/platform/gtk/ScrollViewGtk.cpp
index 3df3cb5..5c258ad 100644
--- a/WebCore/platform/gtk/ScrollViewGtk.cpp
+++ b/WebCore/platform/gtk/ScrollViewGtk.cpp
@@ -72,6 +72,29 @@ PassRefPtr<Scrollbar> ScrollView::createScrollbar(ScrollbarOrientation orientati
         return Scrollbar::createNativeScrollbar(this, orientation, RegularScrollbar);
 }
 
+#if !GTK_CHECK_VERSION(2, 14, 0)
+#define gtk_adjustment_configure AdjustmentConfigure
+
+static void AdjustmentConfigure(GtkAdjustment* adjustment, gdouble value, gdouble lower, gdouble upper,
+                                gdouble stepIncrement, gdouble pageIncrement, gdouble pageSize)
+{
+    g_object_freeze_notify(G_OBJECT(adjustment));
+
+    g_object_set(adjustment,
+                 "lower", lower,
+                 "upper", upper,
+                 "step-increment", stepIncrement,
+                 "page-increment", pageIncrement,
+                 "page-size", pageSize,
+                 NULL);
+
+    g_object_thaw_notify(G_OBJECT(adjustment));
+
+    gtk_adjustment_changed(adjustment);
+    gtk_adjustment_value_changed(adjustment);
+}
+#endif
+
 /*
  * The following is assumed:
  *   (hadj && vadj) || (!hadj && !vadj)
@@ -100,17 +123,22 @@ void ScrollView::setGtkAdjustments(GtkAdjustment* hadj, GtkAdjustment* vadj, boo
         // set in the normal case), we make sure they are up-to-date
         // here. This is needed for the parent scrolling widget to be
         // able to report correct values.
-        m_horizontalAdjustment->lower = 0;
-        m_horizontalAdjustment->upper = resetValues ? 0 : frameRect().width();
-        m_horizontalAdjustment->value = resetValues ? 0 : scrollOffset().width();
-        gtk_adjustment_changed(m_horizontalAdjustment);
-        gtk_adjustment_value_changed(m_horizontalAdjustment);
-
-        m_verticalAdjustment->lower = 0;
-        m_verticalAdjustment->upper = resetValues ? 0 : frameRect().height();
-        m_verticalAdjustment->value = resetValues ? 0 : scrollOffset().height();
-        gtk_adjustment_changed(m_verticalAdjustment);
-        gtk_adjustment_value_changed(m_verticalAdjustment);
+
+        int horizontalPageStep = max(max<int>(frameRect().width() * Scrollbar::minFractionToStepWhenPaging(), frameRect().width() - Scrollbar::maxOverlapBetweenPages()), 1);
+        gtk_adjustment_configure(m_horizontalAdjustment,
+                                 resetValues ? 0 : scrollOffset().width(), 0,
+                                 resetValues ? 0 : contentsSize().width(),
+                                 resetValues ? 0 : Scrollbar::pixelsPerLineStep(),
+                                 resetValues ? 0 : horizontalPageStep,
+                                 resetValues ? 0 : frameRect().width());
+
+        int verticalPageStep = max(max<int>(frameRect().height() * Scrollbar::minFractionToStepWhenPaging(), frameRect().height() - Scrollbar::maxOverlapBetweenPages()), 1);
+        gtk_adjustment_configure(m_verticalAdjustment,
+                                 resetValues ? 0 : scrollOffset().height(), 0,
+                                 resetValues ? 0 : contentsSize().height(),
+                                 resetValues ? 0 : Scrollbar::pixelsPerLineStep(),
+                                 resetValues ? 0 : verticalPageStep,
+                                 resetValues ? 0 : frameRect().height());
     } else {
         ScrollbarGtk* hScrollbar = reinterpret_cast<ScrollbarGtk*>(horizontalScrollbar());
         if (hScrollbar)
diff --git a/WebCore/platform/gtk/WidgetGtk.cpp b/WebCore/platform/gtk/WidgetGtk.cpp
index 834c21a..71addfd 100644
--- a/WebCore/platform/gtk/WidgetGtk.cpp
+++ b/WebCore/platform/gtk/WidgetGtk.cpp
@@ -53,9 +53,10 @@ Widget::~Widget()
     releasePlatformWidget();
 }
 
-void Widget::setFocus()
+void Widget::setFocus(bool focused)
 {
-    gtk_widget_grab_focus(platformWidget() ? platformWidget() : GTK_WIDGET(root()->hostWindow()->platformPageClient()));
+    if (focused)
+        gtk_widget_grab_focus(platformWidget() ? platformWidget() : GTK_WIDGET(root()->hostWindow()->platformPageClient()));
 }
 
 static GdkDrawable* gdkDrawable(PlatformWidget widget)