Changeset 205958 in webkit


Ignore:
Timestamp:
Sep 15, 2016 1:02:20 AM (8 years ago)
Author:
Carlos Garcia Campos
Message:

Merge r205860 - [GTK] Get rid of DataObjectGtk::forClipboard and cleanup pasteboard code
​https://bugs.webkit.org/show_bug.cgi?id=161907

Reviewed by Michael Catanzaro.

Source/WebCore:

We don't really need to keep a DataObjectGtk for every clipboard, we could simply pass the DataObjectGtk to read
and write methods of PasteboardHelper.

  • editing/gtk/EditorGtk.cpp:

(WebCore::createFragmentFromPasteboardData): Update for DataObjectGtk API changes.

  • platform/Pasteboard.h:
  • platform/gtk/DataObjectGtk.cpp: Remove forClipboard() static method.
  • platform/gtk/DataObjectGtk.h: Ditto.
  • platform/gtk/PasteboardGtk.cpp:

(WebCore::Pasteboard::Pasteboard): Always create a new DataObjectGtk.
(WebCore::Pasteboard::dataObject): Return a const reference instead of a pointer.
(WebCore::Pasteboard::writePlainText): Pass the DataObjectGtk to PasteboardHelper.
(WebCore::Pasteboard::write): Ditto.
(WebCore::Pasteboard::writePasteboard): Ditto.
(WebCore::Pasteboard::clear): Ditto.
(WebCore::Pasteboard::read): Ditto.
(WebCore::Pasteboard::hasData): Ditto.
(WebCore::Pasteboard::types): Ditto.
(WebCore::Pasteboard::readString): Ditto.
(WebCore::Pasteboard::readFilenames): Ditto.

  • platform/gtk/PasteboardHelper.cpp:

(WebCore::PasteboardHelper::getClipboardContents): Update the given DataObjectGtk.
(WebCore::PasteboardHelper::fillSelectionData): Use a const reference to DataObjectGtk instead of a pointer.
(WebCore::PasteboardHelper::targetListForDataObject): Ditto.
(WebCore::PasteboardHelper::fillDataObjectFromDropData): Use a reference to DataObjectGtk instead of a pointer.
(WebCore::ClipboardSetData::ClipboardSetData): Helper struct to pass DataObjectGtk and callback to clipboard callbacks.
(WebCore::ClipboardSetData::~ClipboardSetData):
(WebCore::getClipboardContentsCallback): Get the DataObjectGtk from ClipboardSetData struct passed as user data.
(WebCore::clearClipboardContentsCallback): Get the DataObjectGtk and callback from ClipboardSetData struct
passed as user data.
(WebCore::PasteboardHelper::writeClipboardContents): Write the given DataObjectGtk.

  • platform/gtk/PasteboardHelper.h:

Source/WebKit2:

Update to DataObjectGtk and PasteboardHelper API changes.

  • UIProcess/gtk/DragAndDropHandler.cpp:

(WebKit::DragAndDropHandler::startDrag):
(WebKit::DragAndDropHandler::fillDragData):
(WebKit::DragAndDropHandler::dataObjectForDropData):

  • WebProcess/WebCoreSupport/gtk/WebDragClientGtk.cpp:

(WebKit::WebDragClient::startDrag):

  • WebProcess/WebCoreSupport/gtk/WebEditorClientGtk.cpp:

(WebKit::collapseSelection):
(WebKit::WebEditorClient::updateGlobalSelection): Remove wrong X11 guards, since that code is not X11 specific.

Location:
releases/WebKitGTK/webkit-2.14/Source
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/ChangeLog

    r205957 r205958  
     12016-09-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK] Get rid of DataObjectGtk::forClipboard and cleanup pasteboard code
     4        https://bugs.webkit.org/show_bug.cgi?id=161907
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        We don't really need to keep a DataObjectGtk for every clipboard, we could simply pass the DataObjectGtk to read
     9        and write methods of PasteboardHelper.
     10
     11        * editing/gtk/EditorGtk.cpp:
     12        (WebCore::createFragmentFromPasteboardData): Update for DataObjectGtk API changes.
     13        * platform/Pasteboard.h:
     14        * platform/gtk/DataObjectGtk.cpp: Remove forClipboard() static method.
     15        * platform/gtk/DataObjectGtk.h: Ditto.
     16        * platform/gtk/PasteboardGtk.cpp:
     17        (WebCore::Pasteboard::Pasteboard): Always create a new DataObjectGtk.
     18        (WebCore::Pasteboard::dataObject): Return a const reference instead of a pointer.
     19        (WebCore::Pasteboard::writePlainText): Pass the DataObjectGtk to PasteboardHelper.
     20        (WebCore::Pasteboard::write): Ditto.
     21        (WebCore::Pasteboard::writePasteboard): Ditto.
     22        (WebCore::Pasteboard::clear): Ditto.
     23        (WebCore::Pasteboard::read): Ditto.
     24        (WebCore::Pasteboard::hasData): Ditto.
     25        (WebCore::Pasteboard::types): Ditto.
     26        (WebCore::Pasteboard::readString): Ditto.
     27        (WebCore::Pasteboard::readFilenames): Ditto.
     28        * platform/gtk/PasteboardHelper.cpp:
     29        (WebCore::PasteboardHelper::getClipboardContents): Update the given DataObjectGtk.
     30        (WebCore::PasteboardHelper::fillSelectionData): Use a const reference to DataObjectGtk instead of a pointer.
     31        (WebCore::PasteboardHelper::targetListForDataObject): Ditto.
     32        (WebCore::PasteboardHelper::fillDataObjectFromDropData): Use a reference to DataObjectGtk instead of a pointer.
     33        (WebCore::ClipboardSetData::ClipboardSetData): Helper struct to pass DataObjectGtk and callback to clipboard callbacks.
     34        (WebCore::ClipboardSetData::~ClipboardSetData):
     35        (WebCore::getClipboardContentsCallback): Get the DataObjectGtk from ClipboardSetData struct passed as user data.
     36        (WebCore::clearClipboardContentsCallback): Get the DataObjectGtk and callback from ClipboardSetData struct
     37        passed as user data.
     38        (WebCore::PasteboardHelper::writeClipboardContents): Write the given DataObjectGtk.
     39        * platform/gtk/PasteboardHelper.h:
     40
    1412016-09-12  Carlos Garcia Campos  <cgarcia@igalia.com>
    242

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/editing/gtk/EditorGtk.cpp

    r203324 r205958  
    5454        return nullptr;
    5555
    56     DataObjectGtk* dataObject = pasteboard.dataObject();
    57     if (dataObject->hasMarkup() && frame.document())
    58         return createFragmentFromMarkup(*frame.document(), dataObject->markup(), emptyString(), DisallowScriptingAndPluginContent);
     56    const auto& dataObject = pasteboard.dataObject();
     57    if (dataObject.hasMarkup() && frame.document())
     58        return createFragmentFromMarkup(*frame.document(), dataObject.markup(), emptyString(), DisallowScriptingAndPluginContent);
    5959
    6060    if (!allowPlainText)
    6161        return nullptr;
    6262
    63     if (dataObject->hasText()) {
     63    if (dataObject.hasText()) {
    6464        chosePlainText = true;
    65         return createFragmentFromText(range, dataObject->text());
     65        return createFragmentFromText(range, dataObject.text());
    6666    }
    6767

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/Pasteboard.h

    r198177 r205958  
    194194
    195195#if PLATFORM(GTK)
    196     DataObjectGtk* dataObject() const;
     196    const DataObjectGtk& dataObject() const;
    197197    static std::unique_ptr<Pasteboard> createForGlobalSelection();
    198198#endif

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/gtk/DataObjectGtk.cpp

    r198209 r205958  
    148148}
    149149
    150 DataObjectGtk* DataObjectGtk::forClipboard(GtkClipboard* clipboard)
    151 {
    152     static HashMap<GtkClipboard*, RefPtr<DataObjectGtk> > objectMap;
    153 
    154     auto addResult = objectMap.add(clipboard, nullptr);
    155     if (addResult.isNewEntry)
    156         addResult.iterator->value = DataObjectGtk::create();
    157 
    158     return addResult.iterator->value.get();
    159150}
    160 
    161 }

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/gtk/DataObjectGtk.h

    r204467 r205958  
    6767    void clearMarkup();
    6868
    69     static DataObjectGtk* forClipboard(GtkClipboard*);
    70 
    7169private:
    7270    String m_text;

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/gtk/PasteboardGtk.cpp

    r198177 r205958  
    8383
    8484Pasteboard::Pasteboard(GtkClipboard* gtkClipboard)
    85     : m_dataObject(DataObjectGtk::forClipboard(gtkClipboard))
     85    : m_dataObject(DataObjectGtk::create())
    8686    , m_gtkClipboard(gtkClipboard)
    8787{
    … …  
    9494}
    9595
    96 DataObjectGtk* Pasteboard::dataObject() const
    97 {
    98     return m_dataObject.get();
     96const DataObjectGtk& Pasteboard::dataObject() const
     97{
     98    return *m_dataObject;
    9999}
    100100
    … …  
    149149
    150150    if (m_gtkClipboard)
    151         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, (smartReplaceOption == CanSmartReplace) ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
     151        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject, (smartReplaceOption == CanSmartReplace) ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
    152152}
    153153
    … …  
    160160
    161161    if (m_gtkClipboard)
    162         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard);
     162        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject);
    163163}
    164164
    … …  
    176176
    177177    if (m_gtkClipboard)
    178         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard);
     178        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject);
    179179}
    180180
    … …  
    186186
    187187    if (m_gtkClipboard)
    188         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, pasteboardContent.canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste, pasteboardContent.callback.get());
     188        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject, pasteboardContent.canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste, pasteboardContent.callback.get());
    189189}
    190190
    191191void Pasteboard::writePasteboard(const Pasteboard& sourcePasteboard)
    192192{
    193     RefPtr<DataObjectGtk> sourceDataObject = sourcePasteboard.dataObject();
    194     m_dataObject->clearAll();
    195 
    196     if (sourceDataObject->hasText())
    197         m_dataObject->setText(sourceDataObject->text());
    198     if (sourceDataObject->hasMarkup())
    199         m_dataObject->setMarkup(sourceDataObject->markup());
    200     if (sourceDataObject->hasURL())
    201         m_dataObject->setURL(sourceDataObject->url(), sourceDataObject->urlLabel());
    202     if (sourceDataObject->hasURIList())
    203         m_dataObject->setURIList(sourceDataObject->uriList());
    204     if (sourceDataObject->hasImage())
    205         m_dataObject->setImage(sourceDataObject->image());
    206     if (sourceDataObject->hasUnknownTypeData()) {
    207         for (auto& it : m_dataObject->unknownTypes())
     193    const auto& sourceDataObject = sourcePasteboard.dataObject();
     194    m_dataObject->clearAll();
     195
     196    if (sourceDataObject.hasText())
     197        m_dataObject->setText(sourceDataObject.text());
     198    if (sourceDataObject.hasMarkup())
     199        m_dataObject->setMarkup(sourceDataObject.markup());
     200    if (sourceDataObject.hasURL())
     201        m_dataObject->setURL(sourceDataObject.url(), sourceDataObject.urlLabel());
     202    if (sourceDataObject.hasURIList())
     203        m_dataObject->setURIList(sourceDataObject.uriList());
     204    if (sourceDataObject.hasImage())
     205        m_dataObject->setImage(sourceDataObject.image());
     206    if (sourceDataObject.hasUnknownTypeData()) {
     207        for (auto& it : sourceDataObject.unknownTypes())
    208208            m_dataObject->setUnknownTypeData(it.key, it.value);
    209209    }
    210210
    211211    if (m_gtkClipboard)
    212         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard);
     212        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject);
    213213}
    214214
    … …  
    222222
    223223    if (m_gtkClipboard)
    224         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard);
     224        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject);
    225225}
    226226
    … …  
    247247
    248248    if (m_gtkClipboard)
    249         PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard);
     249        PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject);
    250250}
    251251
    … …  
    264264{
    265265    if (m_gtkClipboard)
    266         PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard);
     266        PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard, *m_dataObject);
    267267    text.text = m_dataObject->text();
    268268}
    … …  
    271271{
    272272    if (m_gtkClipboard)
    273         PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard);
     273        PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard, *m_dataObject);
    274274
    275275    return m_dataObject->hasText() || m_dataObject->hasMarkup() || m_dataObject->hasURIList() || m_dataObject->hasImage() || m_dataObject->hasUnknownTypeData();
    … …  
    279279{
    280280    if (m_gtkClipboard)
    281         PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard);
     281        PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard, *m_dataObject);
    282282
    283283    Vector<String> types;
    … …  
    308308{
    309309    if (m_gtkClipboard)
    310         PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard);
     310        PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard, *m_dataObject);
    311311
    312312    switch (dataObjectTypeFromHTMLClipboardType(type)) {
    … …  
    331331{
    332332    if (m_gtkClipboard)
    333         PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard);
     333        PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard, *m_dataObject);
    334334
    335335    return m_dataObject->filenames();

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/gtk/PasteboardHelper.cpp

    r187640 r205958  
    2525
    2626#include "DataObjectGtk.h"
    27 #include "GRefPtrGtk.h"
    2827#include "GtkVersioning.h"
    2928#include "Pasteboard.h"
    … …  
    9493}
    9594
    96 void PasteboardHelper::getClipboardContents(GtkClipboard* clipboard)
    97 {
    98     DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
    99     ASSERT(dataObject);
    100 
     95void PasteboardHelper::getClipboardContents(GtkClipboard* clipboard, DataObjectGtk& dataObject)
     96{
    10197    if (gtk_clipboard_wait_is_text_available(clipboard)) {
    10298        GUniquePtr<gchar> textData(gtk_clipboard_wait_for_text(clipboard));
    10399        if (textData)
    104             dataObject->setText(String::fromUTF8(textData.get()));
     100            dataObject.setText(String::fromUTF8(textData.get()));
    105101    }
    106102
    … …  
    109105            String markup(selectionDataToUTF8String(data));
    110106            removeMarkupPrefix(markup);
    111             dataObject->setMarkup(markup);
     107            dataObject.setMarkup(markup);
    112108            gtk_selection_data_free(data);
    113109        }
    … …  
    116112    if (gtk_clipboard_wait_is_target_available(clipboard, uriListAtom)) {
    117113        if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, uriListAtom)) {
    118             dataObject->setURIList(selectionDataToUTF8String(data));
     114            dataObject.setURIList(selectionDataToUTF8String(data));
    119115            gtk_selection_data_free(data);
    120116        }
    … …  
    122118}
    123119
    124 void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
     120void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, const DataObjectGtk& dataObject)
    125121{
    126122    if (info == TargetTypeText)
    127         gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
     123        gtk_selection_data_set_text(selectionData, dataObject.text().utf8().data(), -1);
    128124
    129125    else if (info == TargetTypeMarkup) {
    130126        // Some Linux applications refuse to accept pasted markup unless it is
    131127        // prefixed by a content-type meta tag.
    132         CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
     128        CString markup = String(gMarkupPrefix + dataObject.markup()).utf8();
    133129        gtk_selection_data_set(selectionData, markupAtom, 8,
    134130            reinterpret_cast<const guchar*>(markup.data()), markup.length());
    135131
    136132    } else if (info == TargetTypeURIList) {
    137         CString uriList = dataObject->uriList().utf8();
     133        CString uriList = dataObject.uriList().utf8();
    138134        gtk_selection_data_set(selectionData, uriListAtom, 8,
    139135            reinterpret_cast<const guchar*>(uriList.data()), uriList.length());
    140136
    141     } else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
    142         String url(dataObject->url());
     137    } else if (info == TargetTypeNetscapeURL && dataObject.hasURL()) {
     138        String url(dataObject.url());
    143139        String result(url);
    144140        result.append("\n");
    145141
    146         if (dataObject->hasText())
    147             result.append(dataObject->text());
     142        if (dataObject.hasText())
     143            result.append(dataObject.text());
    148144        else
    149145            result.append(url);
    … …  
    154150
    155151    } else if (info == TargetTypeImage)
    156         gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
     152        gtk_selection_data_set_pixbuf(selectionData, dataObject.image());
    157153
    158154    else if (info == TargetTypeSmartPaste)
    … …  
    163159        g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
    164160
    165         for (auto& it : dataObject->unknownTypes()) {
     161        for (auto& it : dataObject.unknownTypes()) {
    166162            GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it.key.utf8().data(), it.value.utf8().data()));
    167163            g_variant_builder_add_parsed(&builder, dictItem.get());
    … …  
    174170}
    175171
    176 GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject, SmartPasteInclusion shouldInludeSmartPaste)
    177 {
    178     GtkTargetList* list = gtk_target_list_new(nullptr, 0);
    179 
    180     if (dataObject->hasText())
    181         gtk_target_list_add_text_targets(list, TargetTypeText);
    182 
    183     if (dataObject->hasMarkup())
    184         gtk_target_list_add(list, markupAtom, 0, TargetTypeMarkup);
    185 
    186     if (dataObject->hasURIList()) {
    187         gtk_target_list_add_uri_targets(list, TargetTypeURIList);
    188         gtk_target_list_add(list, netscapeURLAtom, 0, TargetTypeNetscapeURL);
    189     }
    190 
    191     if (dataObject->hasImage())
    192         gtk_target_list_add_image_targets(list, TargetTypeImage, TRUE);
    193 
    194     if (dataObject->hasUnknownTypeData())
    195         gtk_target_list_add(list, unknownAtom, 0, TargetTypeUnknown);
     172GRefPtr<GtkTargetList> PasteboardHelper::targetListForDataObject(const DataObjectGtk& dataObject, SmartPasteInclusion shouldInludeSmartPaste)
     173{
     174    GRefPtr<GtkTargetList> list = adoptGRef(gtk_target_list_new(nullptr, 0));
     175
     176    if (dataObject.hasText())
     177        gtk_target_list_add_text_targets(list.get(), TargetTypeText);
     178
     179    if (dataObject.hasMarkup())
     180        gtk_target_list_add(list.get(), markupAtom, 0, TargetTypeMarkup);
     181
     182    if (dataObject.hasURIList()) {
     183        gtk_target_list_add_uri_targets(list.get(), TargetTypeURIList);
     184        gtk_target_list_add(list.get(), netscapeURLAtom, 0, TargetTypeNetscapeURL);
     185    }
     186
     187    if (dataObject.hasImage())
     188        gtk_target_list_add_image_targets(list.get(), TargetTypeImage, TRUE);
     189
     190    if (dataObject.hasUnknownTypeData())
     191        gtk_target_list_add(list.get(), unknownAtom, 0, TargetTypeUnknown);
    196192
    197193    if (shouldInludeSmartPaste == IncludeSmartPaste)
    198         gtk_target_list_add(list, smartPasteAtom, 0, TargetTypeSmartPaste);
     194        gtk_target_list_add(list.get(), smartPasteAtom, 0, TargetTypeSmartPaste);
    199195
    200196    return list;
    201197}
    202198
    203 void PasteboardHelper::fillDataObjectFromDropData(GtkSelectionData* data, guint /* info */, DataObjectGtk* dataObject)
     199void PasteboardHelper::fillDataObjectFromDropData(GtkSelectionData* data, guint /* info */, DataObjectGtk& dataObject)
    204200{
    205201    if (!gtk_selection_data_get_data(data))
    … …  
    208204    GdkAtom target = gtk_selection_data_get_target(data);
    209205    if (target == textPlainAtom)
    210         dataObject->setText(selectionDataToUTF8String(data));
     206        dataObject.setText(selectionDataToUTF8String(data));
    211207    else if (target == markupAtom) {
    212208        String markup(selectionDataToUTF8String(data));
    213209        removeMarkupPrefix(markup);
    214         dataObject->setMarkup(markup);
     210        dataObject.setMarkup(markup);
    215211    } else if (target == uriListAtom) {
    216         dataObject->setURIList(selectionDataToUTF8String(data));
     212        dataObject.setURIList(selectionDataToUTF8String(data));
    217213    } else if (target == netscapeURLAtom) {
    218214        String urlWithLabel(selectionDataToUTF8String(data));
    … …  
    222218        // Give preference to text/uri-list here, as it can hold more
    223219        // than one URI but still take  the label if there is one.
    224         if (!dataObject->hasURIList())
    225             dataObject->setURIList(pieces[0]);
     220        if (!dataObject.hasURIList())
     221            dataObject.setURIList(pieces[0]);
    226222        if (pieces.size() > 1)
    227             dataObject->setText(pieces[1]);
     223            dataObject.setText(pieces[1]);
    228224    } else if (target == unknownAtom) {
    229225        GRefPtr<GVariant> variant = g_variant_new_parsed(reinterpret_cast<const char*>(gtk_selection_data_get_data(data)));
    … …  
    235231        g_variant_iter_init(&iter, variant.get());
    236232        while (g_variant_iter_next(&iter, "{ss}", &key.outPtr(), &value.outPtr()))
    237             dataObject->setUnknownTypeData(key.get(), value.get());
     233            dataObject.setUnknownTypeData(key.get(), value.get());
    238234    }
    239235}
    … …  
    261257static DataObjectGtk* settingClipboardDataObject = 0;
    262258
    263 static void getClipboardContentsCallback(GtkClipboard* clipboard, GtkSelectionData *selectionData, guint info, gpointer)
    264 {
    265     DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
    266     ASSERT(dataObject);
    267     PasteboardHelper::singleton().fillSelectionData(selectionData, info, dataObject);
    268 }
    269 
    270 static void clearClipboardContentsCallback(GtkClipboard* clipboard, gpointer data)
    271 {
    272     DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
    273     ASSERT(dataObject);
     259struct ClipboardSetData {
     260    ClipboardSetData(DataObjectGtk* dataObject, GClosure* callback)
     261        : dataObject(dataObject)
     262        , callback(callback)
     263    {
     264    }
     265
     266    ~ClipboardSetData()
     267    {
     268    }
     269
     270    RefPtr<DataObjectGtk> dataObject;
     271    GRefPtr<GClosure> callback;
     272};
     273
     274static void getClipboardContentsCallback(GtkClipboard*, GtkSelectionData *selectionData, guint info, gpointer userData)
     275{
     276    auto* data = static_cast<ClipboardSetData*>(userData);
     277    PasteboardHelper::singleton().fillSelectionData(selectionData, info, *data->dataObject);
     278}
     279
     280static void clearClipboardContentsCallback(GtkClipboard* clipboard, gpointer userData)
     281{
     282    std::unique_ptr<ClipboardSetData> data(static_cast<ClipboardSetData*>(userData));
    274283
    275284    // Only clear the DataObject for this clipboard if we are not currently setting it.
    276     if (dataObject != settingClipboardDataObject)
    277         dataObject->clearAll();
    278 
    279     if (!data)
     285    if (data->dataObject.get() != settingClipboardDataObject)
     286        data->dataObject->clearAll();
     287
     288    if (!data->callback)
    280289        return;
    281290
    282     GRefPtr<GClosure> callback = adoptGRef(static_cast<GClosure*>(data));
    283291    GValue firstArgument = {0, {{0}}};
    284292    g_value_init(&firstArgument, G_TYPE_POINTER);
    285293    g_value_set_pointer(&firstArgument, clipboard);
    286     g_closure_invoke(callback.get(), nullptr, 1, &firstArgument, 0);
    287 }
    288 
    289 void PasteboardHelper::writeClipboardContents(GtkClipboard* clipboard, SmartPasteInclusion includeSmartPaste, GClosure* callback)
    290 {
    291     DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
    292     GtkTargetList* list = targetListForDataObject(dataObject, includeSmartPaste);
     294    g_closure_invoke(data->callback.get(), nullptr, 1, &firstArgument, 0);
     295}
     296
     297void PasteboardHelper::writeClipboardContents(GtkClipboard* clipboard, const DataObjectGtk& dataObject, SmartPasteInclusion includeSmartPaste, GClosure* callback)
     298{
     299    GRefPtr<GtkTargetList> list = targetListForDataObject(dataObject, includeSmartPaste);
    293300
    294301    int numberOfTargets;
    295     GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets);
     302    GtkTargetEntry* table = gtk_target_table_new_from_list(list.get(), &numberOfTargets);
    296303
    297304    if (numberOfTargets > 0 && table) {
    298         settingClipboardDataObject = dataObject;
    299 
    300         if (gtk_clipboard_set_with_data(clipboard, table, numberOfTargets, getClipboardContentsCallback, clearClipboardContentsCallback, callback ? g_closure_ref(callback) : nullptr))
     305        settingClipboardDataObject = const_cast<DataObjectGtk*>(&dataObject);
     306
     307        auto data = std::make_unique<ClipboardSetData>(settingClipboardDataObject, callback);
     308        if (gtk_clipboard_set_with_data(clipboard, table, numberOfTargets, getClipboardContentsCallback, clearClipboardContentsCallback, data.get())) {
    301309            gtk_clipboard_set_can_store(clipboard, nullptr, 0);
    302         else {
    303             // When gtk_clipboard_set_with_data fails the callbacks are ignored, so we need to release the reference we were passing to clearClipboardContentsCallback.
    304             if (callback)
    305                 g_closure_unref(callback);
     310            // When gtk_clipboard_set_with_data() succeeds clearClipboardContentsCallback takes the ownership of data, so we leak it here.
     311            data.release();
    306312        }
    307313
    308314        settingClipboardDataObject = nullptr;
    309 
    310315    } else
    311316        gtk_clipboard_clear(clipboard);
    … …  
    313318    if (table)
    314319        gtk_target_table_free(table, numberOfTargets);
    315     gtk_target_list_unref(list);
    316320}
    317321

  • releases/WebKitGTK/webkit-2.14/Source/WebCore/platform/gtk/PasteboardHelper.h

    r187580 r205958  
    2626#define PasteboardHelper_h
    2727
     28#include "GRefPtrGtk.h"
    2829#include <wtf/HashSet.h>
    2930#include <wtf/Noncopyable.h>
    … …  
    4344
    4445    GtkTargetList* targetList() const;
    45     GtkTargetList* targetListForDataObject(DataObjectGtk*, SmartPasteInclusion = DoNotIncludeSmartPaste);
    46     void fillSelectionData(GtkSelectionData*, guint, DataObjectGtk*);
    47     void fillDataObjectFromDropData(GtkSelectionData*, guint, DataObjectGtk*);
     46    GRefPtr<GtkTargetList> targetListForDataObject(const DataObjectGtk&, SmartPasteInclusion = DoNotIncludeSmartPaste);
     47    void fillSelectionData(GtkSelectionData*, guint, const DataObjectGtk&);
     48    void fillDataObjectFromDropData(GtkSelectionData*, guint, DataObjectGtk&);
    4849    Vector<GdkAtom> dropAtomsForContext(GtkWidget*, GdkDragContext*);
    49     void writeClipboardContents(GtkClipboard*, SmartPasteInclusion = DoNotIncludeSmartPaste, GClosure* = 0);
    50     void getClipboardContents(GtkClipboard*);
     50    void writeClipboardContents(GtkClipboard*, const DataObjectGtk&, SmartPasteInclusion = DoNotIncludeSmartPaste, GClosure* = 0);
     51    void getClipboardContents(GtkClipboard*, DataObjectGtk&);
    5152
    5253    enum PasteboardTargetType { TargetTypeMarkup, TargetTypeText, TargetTypeImage, TargetTypeURIList, TargetTypeNetscapeURL, TargetTypeSmartPaste, TargetTypeUnknown };

  • releases/WebKitGTK/webkit-2.14/Source/WebKit2/ChangeLog

    r205738 r205958  
     12016-09-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK] Get rid of DataObjectGtk::forClipboard and cleanup pasteboard code
     4        https://bugs.webkit.org/show_bug.cgi?id=161907
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        Update to DataObjectGtk and PasteboardHelper API changes.
     9
     10        * UIProcess/gtk/DragAndDropHandler.cpp:
     11        (WebKit::DragAndDropHandler::startDrag):
     12        (WebKit::DragAndDropHandler::fillDragData):
     13        (WebKit::DragAndDropHandler::dataObjectForDropData):
     14        * WebProcess/WebCoreSupport/gtk/WebDragClientGtk.cpp:
     15        (WebKit::WebDragClient::startDrag):
     16        * WebProcess/WebCoreSupport/gtk/WebEditorClientGtk.cpp:
     17        (WebKit::collapseSelection):
     18        (WebKit::WebEditorClient::updateGlobalSelection): Remove wrong X11 guards, since that code is not X11 specific.
     19
    1202016-09-09  Carlos Garcia Campos  <cgarcia@igalia.com>
    221

  • releases/WebKitGTK/webkit-2.14/Source/WebKit2/UIProcess/gtk/DragAndDropHandler.cpp

    r195811 r205958  
    116116#if GTK_CHECK_VERSION(3, 16, 0)
    117117    m_draggingDataObject = adoptRef(dragData.platformData());
    118     GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::singleton().targetListForDataObject(m_draggingDataObject.get()));
     118    GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForDataObject(*m_draggingDataObject);
    119119#else
    120120    RefPtr<DataObjectGtk> dataObject = adoptRef(dragData.platformData());
    121     GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::singleton().targetListForDataObject(dataObject.get()));
     121    GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForDataObject(*dataObject);
    122122#endif
    123123
    … …  
    157157
    158158    ASSERT(m_draggingDataObject);
    159     PasteboardHelper::singleton().fillSelectionData(selectionData, info, m_draggingDataObject.get());
     159    PasteboardHelper::singleton().fillSelectionData(selectionData, info, *m_draggingDataObject);
    160160#else
    161161    if (DataObjectGtk* dataObject = m_draggingDataObjects.get(context))
    162         PasteboardHelper::singleton().fillSelectionData(selectionData, info, dataObject);
     162        PasteboardHelper::singleton().fillSelectionData(selectionData, info, *dataObject);
    163163#endif
    164164}
    … …  
    197197
    198198    droppingContext->pendingDataRequests--;
    199     PasteboardHelper::singleton().fillDataObjectFromDropData(selectionData, info, droppingContext->dataObject.get());
     199    PasteboardHelper::singleton().fillDataObjectFromDropData(selectionData, info, *droppingContext->dataObject);
    200200    if (droppingContext->pendingDataRequests)
    201201        return nullptr;

  • releases/WebKitGTK/webkit-2.14/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebDragClientGtk.cpp

    r189144 r205958  
    6666        return;
    6767
    68     RefPtr<DataObjectGtk> dataObject = dataTransfer.pasteboard().dataObject();
    69     DragData dragData(dataObject.get(), clientPosition, globalPosition, dataTransfer.sourceOperation());
     68    const auto& dataObject = dataTransfer.pasteboard().dataObject();
     69    DragData dragData(const_cast<DataObjectGtk*>(&dataObject), clientPosition, globalPosition, dataTransfer.sourceOperation());
    7070    m_page->send(Messages::WebPageProxy::StartDrag(dragData, handle));
    7171}

  • releases/WebKitGTK/webkit-2.14/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebEditorClientGtk.cpp

    r202807 r205958  
    120120}
    121121
    122 #if PLATFORM(X11)
    123122class EditorClientFrameDestructionObserver : FrameDestructionObserver {
    124123public:
    … …  
    159158    frame->selection().setBase(selection.extent(), selection.affinity());
    160159}
    161 #endif
    162160
    163161void WebEditorClient::updateGlobalSelection(Frame* frame)
    164162{
    165 #if PLATFORM(X11)
    166163    if (!frame->selection().isRange())
    167164        return;
    … …  
    185182    Pasteboard::createForGlobalSelection()->write(pasteboardContent);
    186183    frameSettingClipboard = nullptr;
    187 #endif
    188184}
    189185
Note: See TracChangeset for help on using the changeset viewer.