Changeset 107894 in webkit


Ignore:
Timestamp:
Feb 15, 2012 11:26:18 PM (12 years ago)
Author:
dcheng@chromium.org
Message:

dataTransfer.types (HTML5 drag & drop) should return DOMStringList
https://bugs.webkit.org/show_bug.cgi?id=30416

Reviewed by Eric Seidel.

Source/WebCore:

This change breaks backwards compatibility; however, since Firefox only supported
event.dataTransfer.types.contains, sites already needed to check whether to use contains or
indexOf. Therefore, the net compatibility effect of this change should be minimal.

Test: fast/events/drag-dataTransfer-live-attributes.html

  • bindings/js/JSClipboardCustom.cpp:

(WebCore):

  • bindings/v8/custom/V8ClipboardCustom.cpp:
  • dom/Clipboard.cpp:

(WebCore::Clipboard::hasStringOfType):

  • dom/Clipboard.h:

(WebCore):
(Clipboard):

  • dom/Clipboard.idl:
  • platform/blackberry/ClipboardBlackBerry.cpp:

(WebCore::ClipboardBlackBerry::types):

  • platform/blackberry/ClipboardBlackBerry.h:

(ClipboardBlackBerry):

  • platform/chromium/ChromiumDataObject.cpp:

(WebCore::ChromiumDataObject::types):

  • platform/chromium/ChromiumDataObject.h:

(ChromiumDataObject):

  • platform/chromium/ClipboardChromium.cpp:

(WebCore::ClipboardChromium::types):
(WebCore::ClipboardChromium::mayUpdateItems):

  • platform/chromium/ClipboardChromium.h:

(ClipboardChromium):

  • platform/chromium/DragDataChromium.cpp:

(WebCore::containsHTML):
(WebCore::DragData::containsURL):
(WebCore::DragData::asURL):
(WebCore::DragData::containsPlainText):
(WebCore::DragData::canSmartReplace):
(WebCore::DragData::asFragment):

  • platform/efl/ClipboardEfl.cpp:

(WebCore::ClipboardEfl::types):

  • platform/efl/ClipboardEfl.h:

(ClipboardEfl):

  • platform/gtk/ClipboardGtk.cpp:

(WebCore::ClipboardGtk::types):

  • platform/gtk/ClipboardGtk.h:

(ClipboardGtk):

  • platform/mac/ClipboardMac.h:

(ClipboardMac):

  • platform/mac/ClipboardMac.mm:

(WebCore::addHTMLClipboardTypesForCocoaType):
(WebCore::ClipboardMac::types):

  • platform/qt/ClipboardQt.cpp:

(WebCore::ClipboardQt::types):

  • platform/qt/ClipboardQt.h:

(ClipboardQt):

  • platform/win/ClipboardWin.cpp:

(WebCore::addMimeTypesForFormat):
(WebCore::ClipboardWin::types):

  • platform/win/ClipboardWin.h:

(ClipboardWin):

  • platform/wx/ClipboardWx.cpp:

(WebCore::ClipboardWx::types):

  • platform/wx/ClipboardWx.h:

(ClipboardWx):

LayoutTests:

Add a test to document the fact that many dataTransfer attributes aren't live and return a
different object each time they're accessed. Also update tests to use contains() instead of
indexOf().

  • editing/pasteboard/clipboard-customData.html:
  • editing/pasteboard/onpaste-text-html-types.html:
  • fast/events/drag-and-drop-dataTransfer-types-nocrash.html:
  • fast/events/drag-customData.html:
  • fast/events/drag-dataTransfer-live-attributes-expected.txt: Added.
  • fast/events/drag-dataTransfer-live-attributes.html: Copied from LayoutTests/fast/events/drag-customData.html.
  • http/tests/local/fileapi/resources/setup-file-input-element-for-drag.js:
  • http/tests/security/clipboard/script-tests/clipboard-file-access.js:

(checkForEventTransferType):

Location:
trunk
Files:
1 added
32 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r107893 r107894  
     12012-02-15  Daniel Cheng  <dcheng@chromium.org>
     2
     3        dataTransfer.types (HTML5 drag & drop) should return DOMStringList
     4        https://bugs.webkit.org/show_bug.cgi?id=30416
     5
     6        Reviewed by Eric Seidel.
     7
     8        Add a test to document the fact that many dataTransfer attributes aren't live and return a
     9        different object each time they're accessed. Also update tests to use contains() instead of
     10        indexOf().
     11
     12        * editing/pasteboard/clipboard-customData.html:
     13        * editing/pasteboard/onpaste-text-html-types.html:
     14        * fast/events/drag-and-drop-dataTransfer-types-nocrash.html:
     15        * fast/events/drag-customData.html:
     16        * fast/events/drag-dataTransfer-live-attributes-expected.txt: Added.
     17        * fast/events/drag-dataTransfer-live-attributes.html: Copied from LayoutTests/fast/events/drag-customData.html.
     18        * http/tests/local/fileapi/resources/setup-file-input-element-for-drag.js:
     19        * http/tests/security/clipboard/script-tests/clipboard-file-access.js:
     20        (checkForEventTransferType):
     21
    1222012-02-15  Bear Travis  <betravis@adobe.com>
    223
  • trunk/LayoutTests/editing/pasteboard/clipboard-customData.html

    r101828 r107894  
    1818function paste(event) {
    1919    var failed = false;
    20     if (event.clipboardData.types.indexOf('text/plain') < 0
    21         || event.clipboardData.types.indexOf('custom-data') < 0)
     20    if (!event.clipboardData.types.contains('text/plain')
     21        || !event.clipboardData.types.contains('custom-data'))
    2222        failed = true;
    2323    if (event.clipboardData.getData('text') != 'sample'
  • trunk/LayoutTests/editing/pasteboard/onpaste-text-html-types.html

    r81522 r107894  
    99{
    1010    var types = ev.clipboardData.types;
    11     if (types.indexOf('text/plain') >= 0 &&
    12         types.indexOf('text/html') >= 0)
     11    if (types.contains('text/plain') && types.contains('text/html'))
    1312        document.getElementById("results").innerHTML = "PASS";
    1413}
  • trunk/LayoutTests/fast/events/drag-and-drop-dataTransfer-types-nocrash.html

    r98407 r107894  
    8585        event = e;
    8686        var formatTypes = e.dataTransfer.types; // This line causes the crash.
    87         if (event.dataTransfer.types.indexOf(FORMAT_TYPE) == -1)
     87        if (event.dataTransfer.types.contains(FORMAT_TYPE) == -1)
    8888            testFailed('event.dataTransfer.types should contain format "' + FORMAT_TYPE + '", but it does not.');
    8989        else
  • trunk/LayoutTests/fast/events/drag-customData.html

    r101828 r107894  
    3333function drop(event) {
    3434    var failed = false;
    35     if (event.dataTransfer.types.indexOf('text/plain') < 0
    36         || event.dataTransfer.types.indexOf('custom-data') < 0)
     35    if (!event.dataTransfer.types.contains('text/plain')
     36        || !event.dataTransfer.types.contains('custom-data'))
    3737        failed = true;
    3838    if (event.dataTransfer.getData('text') != 'sample'
  • trunk/LayoutTests/fast/events/drag-dataTransfer-live-attributes.html

    r107893 r107894  
    1515</style>
    1616<script>
     17var failed;
     18
    1719function log(str)
    1820{
     
    2123    result.appendChild(document.createElement('br'));
    2224}
    23 function dragstart(event) {
     25function dragstart(event)
     26{
     27    failed = false;
    2428    event.dataTransfer.setData('text', 'sample');
    25     event.dataTransfer.setData('custom-data', 'hello world');
     29    if (event.dataTransfer.types != event.dataTransfer.types) {
     30        failed = true;
     31        log('types != types');
     32    }
     33    if (event.dataTransfer.files != event.dataTransfer.files) {
     34        failed = true;
     35        log('files != files');
     36    }
     37    if (event.dataTransfer.items != event.dataTransfer.items) {
     38        failed = true;
     39        log('items != items');
     40    }
    2641}
    27 function dragenter(event) {
     42function dragenter(event)
     43{
    2844    event.preventDefault();
    2945}
    30 function dragover(event) {
     46function dragover(event)
     47{
    3148    event.preventDefault();
    3249}
    33 function drop(event) {
    34     var failed = false;
    35     if (event.dataTransfer.types.indexOf('text/plain') < 0
    36         || event.dataTransfer.types.indexOf('custom-data') < 0)
     50function drop(event)
     51{
     52    if (!event.dataTransfer.types.contains('text/plain'))
    3753        failed = true;
    38     if (event.dataTransfer.getData('text') != 'sample'
    39         || event.dataTransfer.getData('custom-data') != 'hello world')
     54    if (event.dataTransfer.getData('text') != 'sample')
    4055        failed = true;
    4156    log(failed ? 'FAILURE' : 'SUCCESS');
     
    6378</head>
    6479<body>
    65 <p>To manually test, drag 'Drag Me' to 'Drop Here' and drop. The word 'SUCCESS' should appear.
     80<p>This is a test that various dataTransfer attributes are live and return the same object when accessed multiple times. To manually test, drag 'Drag Me' to 'Drop Here' and drop. The word 'SUCCESS' should appear.
    6681<div draggable="true" id="drag" ondragstart="dragstart(event)">Drag Me</div>
    6782<div id="drop" ondragenter="dragenter(event)" ondragover="dragover(event)" ondrop="drop(event)">Drop Here</div>
  • trunk/LayoutTests/http/tests/local/fileapi/resources/setup-file-input-element-for-drag.js

    r72340 r107894  
    1717var fileInputDropCallback = null;
    1818fileInput.addEventListener("drop", function() {
    19     if (event.dataTransfer.types.indexOf("Files") != -1 && event.dataTransfer.files.length == 1)
     19    if (event.dataTransfer.types.contains("Files") && event.dataTransfer.files.length == 1)
    2020        testPassed("event.dataTransfer contains a File object on drop.");
    2121    else {
  • trunk/LayoutTests/http/tests/security/clipboard/script-tests/clipboard-file-access.js

    r59689 r107894  
    7676    var passedCheck;
    7777    var message;
    78     if (event.dataTransfer.types && event.dataTransfer.types.indexOf(typeString) != -1) {
     78    if (event.dataTransfer.types && event.dataTransfer.types.contains(typeString)) {
    7979        passedCheck = shouldContainType;
    8080        message = "event.dataTransfer.types contains " + typeString + ".";
  • trunk/Source/WebCore/ChangeLog

    r107893 r107894  
     12012-02-15  Daniel Cheng  <dcheng@chromium.org>
     2
     3        dataTransfer.types (HTML5 drag & drop) should return DOMStringList
     4        https://bugs.webkit.org/show_bug.cgi?id=30416
     5
     6        Reviewed by Eric Seidel.
     7
     8        This change breaks backwards compatibility; however, since Firefox only supported
     9        event.dataTransfer.types.contains, sites already needed to check whether to use contains or
     10        indexOf. Therefore, the net compatibility effect of this change should be minimal.
     11
     12        Test: fast/events/drag-dataTransfer-live-attributes.html
     13
     14        * bindings/js/JSClipboardCustom.cpp:
     15        (WebCore):
     16        * bindings/v8/custom/V8ClipboardCustom.cpp:
     17        * dom/Clipboard.cpp:
     18        (WebCore::Clipboard::hasStringOfType):
     19        * dom/Clipboard.h:
     20        (WebCore):
     21        (Clipboard):
     22        * dom/Clipboard.idl:
     23        * platform/blackberry/ClipboardBlackBerry.cpp:
     24        (WebCore::ClipboardBlackBerry::types):
     25        * platform/blackberry/ClipboardBlackBerry.h:
     26        (ClipboardBlackBerry):
     27        * platform/chromium/ChromiumDataObject.cpp:
     28        (WebCore::ChromiumDataObject::types):
     29        * platform/chromium/ChromiumDataObject.h:
     30        (ChromiumDataObject):
     31        * platform/chromium/ClipboardChromium.cpp:
     32        (WebCore::ClipboardChromium::types):
     33        (WebCore::ClipboardChromium::mayUpdateItems):
     34        * platform/chromium/ClipboardChromium.h:
     35        (ClipboardChromium):
     36        * platform/chromium/DragDataChromium.cpp:
     37        (WebCore::containsHTML):
     38        (WebCore::DragData::containsURL):
     39        (WebCore::DragData::asURL):
     40        (WebCore::DragData::containsPlainText):
     41        (WebCore::DragData::canSmartReplace):
     42        (WebCore::DragData::asFragment):
     43        * platform/efl/ClipboardEfl.cpp:
     44        (WebCore::ClipboardEfl::types):
     45        * platform/efl/ClipboardEfl.h:
     46        (ClipboardEfl):
     47        * platform/gtk/ClipboardGtk.cpp:
     48        (WebCore::ClipboardGtk::types):
     49        * platform/gtk/ClipboardGtk.h:
     50        (ClipboardGtk):
     51        * platform/mac/ClipboardMac.h:
     52        (ClipboardMac):
     53        * platform/mac/ClipboardMac.mm:
     54        (WebCore::addHTMLClipboardTypesForCocoaType):
     55        (WebCore::ClipboardMac::types):
     56        * platform/qt/ClipboardQt.cpp:
     57        (WebCore::ClipboardQt::types):
     58        * platform/qt/ClipboardQt.h:
     59        (ClipboardQt):
     60        * platform/win/ClipboardWin.cpp:
     61        (WebCore::addMimeTypesForFormat):
     62        (WebCore::ClipboardWin::types):
     63        * platform/win/ClipboardWin.h:
     64        (ClipboardWin):
     65        * platform/wx/ClipboardWx.cpp:
     66        (WebCore::ClipboardWx::types):
     67        * platform/wx/ClipboardWx.h:
     68        (ClipboardWx):
     69
    1702012-02-15  Bear Travis  <betravis@adobe.com>
    271
  • trunk/Source/WebCore/bindings/js/JSClipboardCustom.cpp

    r105698 r107894  
    4848
    4949using namespace HTMLNames;
    50 
    51 JSValue JSClipboard::types(ExecState* exec) const
    52 {
    53     Clipboard* clipboard = impl();
    54 
    55     HashSet<String> types = clipboard->types();
    56     if (types.isEmpty())
    57         return jsNull();
    58 
    59     MarkedArgumentBuffer list;
    60     HashSet<String>::const_iterator end = types.end();
    61     for (HashSet<String>::const_iterator it = types.begin(); it != end; ++it)
    62         list.append(jsString(exec, stringToUString(*it)));
    63     return constructArray(exec, globalObject(), list);
    64 }
    6550
    6651JSValue JSClipboard::clearData(ExecState* exec)
  • trunk/Source/WebCore/bindings/v8/custom/V8ClipboardCustom.cpp

    r95901 r107894  
    4444
    4545namespace WebCore {
    46 
    47 v8::Handle<v8::Value> V8Clipboard::typesAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
    48 {
    49     INC_STATS("DOM.Clipboard.types()");
    50     Clipboard* clipboard = V8Clipboard::toNative(info.Holder());
    51 
    52     HashSet<String> types = clipboard->types();
    53     if (types.isEmpty())
    54         return v8::Null();
    55 
    56     v8::Local<v8::Array> result = v8::Array::New(types.size());
    57     HashSet<String>::const_iterator end = types.end();
    58     int index = 0;
    59     for (HashSet<String>::const_iterator it = types.begin(); it != end; ++it, ++index)
    60         result->Set(v8::Integer::New(index), v8String(*it));
    61 
    62     return result;
    63 }
    6446
    6547v8::Handle<v8::Value> V8Clipboard::clearDataCallback(const v8::Arguments& args)
  • trunk/Source/WebCore/dom/Clipboard.cpp

    r106018 r107894  
    2828
    2929#include "CachedImage.h"
     30#include "DOMStringList.h"
    3031#include "FileList.h"
    3132#include "Frame.h"
     
    148149        return false;
    149150   
    150     return types().contains(type);
     151    return types()->contains(type);
    151152}
    152153   
  • trunk/Source/WebCore/dom/Clipboard.h

    r106884 r107894  
    3434namespace WebCore {
    3535
     36    class DOMStringList;
    3637    class DataTransferItemList;
    3738    class DragData;
     
    6768   
    6869        // extensions beyond IE's API
    69         virtual HashSet<String> types() const = 0;
     70        virtual PassRefPtr<DOMStringList> types() const = 0;
    7071        virtual PassRefPtr<FileList> files() const = 0;
    7172
  • trunk/Source/WebCore/dom/Clipboard.idl

    r107312 r107894  
    3232                 attribute [TreatReturnedNullStringAs=Undefined] DOMString dropEffect;
    3333                 attribute [TreatReturnedNullStringAs=Undefined] DOMString effectAllowed;
    34         readonly attribute [CustomGetter] Array types;
     34        readonly attribute DOMStringList types;
    3535        readonly attribute FileList files;
    3636
  • trunk/Source/WebCore/platform/blackberry/ClipboardBlackBerry.cpp

    r102739 r107894  
    2020#include "ClipboardBlackBerry.h"
    2121
     22#include "DOMStringList.h"
    2223#include "FileList.h"
    2324#include "NotImplemented.h"
     
    7374}
    7475
    75 HashSet<String> ClipboardBlackBerry::types() const
     76PassRefPtr<DOMStringList> ClipboardBlackBerry::types() const
    7677{
    7778    // We use hardcoded list here since there seems to be no API to get the list.
    78     HashSet<String> ret;
    79     ret.add("text/plain");
    80     ret.add("text/html");
    81     ret.add("text/url");
    82     return ret;
     79    RefPtr<DOMStringList> ret = DOMStringList::create();
     80    ret->append("text/plain");
     81    ret->append("text/html");
     82    ret->append("text/url");
     83    return ret.release();
    8384}
    8485
  • trunk/Source/WebCore/platform/blackberry/ClipboardBlackBerry.h

    r102739 r107894  
    3737
    3838    // extensions beyond IE's API
    39     virtual HashSet<String> types() const;
     39    virtual PassRefPtr<DOMStringList> types() const;
    4040    virtual PassRefPtr<FileList> files() const;
    4141    virtual DragImageRef createDragImage(IntPoint&) const;
  • trunk/Source/WebCore/platform/chromium/ChromiumDataObject.cpp

    r105826 r107894  
    102102}
    103103
    104 HashSet<String> ChromiumDataObject::types() const
    105 {
     104PassRefPtr<DOMStringList> ChromiumDataObject::types() const
     105{
     106    RefPtr<DOMStringList> results = DOMStringList::create();
     107
    106108    if (m_storageMode == Pasteboard) {
    107109        bool ignoredContainsFilenames;
    108         return PlatformSupport::clipboardReadAvailableTypes(currentPasteboardBuffer(),
    109                                                             &ignoredContainsFilenames);
    110     }
    111 
    112     HashSet<String> results;
     110        HashSet<String> hashedResults = PlatformSupport::clipboardReadAvailableTypes(
     111            currentPasteboardBuffer(), &ignoredContainsFilenames);
     112        for (HashSet<String>::const_iterator it = hashedResults.begin(); it != hashedResults.end(); ++it)
     113          results->append(*it);
     114        return results.release();
     115    }
    113116
    114117    if (!m_plainText.isEmpty()) {
    115         results.add(mimeTypeText);
    116         results.add(mimeTypeTextPlain);
     118        results->append(mimeTypeText);
     119        results->append(mimeTypeTextPlain);
    117120    }
    118121
    119122    if (!m_uriList.isEmpty())
    120         results.add(mimeTypeTextURIList);
     123        results->append(mimeTypeTextURIList);
    121124
    122125    if (!m_textHtml.isEmpty())
    123         results.add(mimeTypeTextHTML);
     126        results->append(mimeTypeTextHTML);
    124127
    125128    for (HashMap<String, String>::const_iterator::Keys it = m_customData.begin().keys();
    126129         it != m_customData.end().keys(); ++it) {
    127         results.add(*it);
    128     }
    129 
    130     return results;
     130        results->append(*it);
     131    }
     132
     133    return results.release();
    131134}
    132135
  • trunk/Source/WebCore/platform/chromium/ChromiumDataObject.h

    r105506 r107894  
    3232#define ChromiumDataObject_h
    3333
     34#include "DOMStringList.h"
    3435#include "KURL.h"
    3536#include "PlatformString.h"
    3637#include "SharedBuffer.h"
    3738#include <wtf/HashMap.h>
    38 #include <wtf/HashSet.h>
    3939#include <wtf/RefPtr.h>
    4040#include <wtf/Vector.h>
     
    7676    bool hasData() const;
    7777
    78     HashSet<String> types() const;
     78    PassRefPtr<DOMStringList> types() const;
    7979    String getData(const String& type, bool& success) const;
    8080    bool setData(const String& type, const String& data);
  • trunk/Source/WebCore/platform/chromium/ClipboardChromium.cpp

    r105962 r107894  
    3232#include "ClipboardMimeTypes.h"
    3333#include "ClipboardUtilitiesChromium.h"
     34#include "DOMStringList.h"
    3435#include "DataTransferItemChromium.h"
    3536#include "DataTransferItemListChromium.h"
     
    290291
    291292// extensions beyond IE's API
    292 HashSet<String> ClipboardChromium::types() const
    293 {
    294     HashSet<String> results;
     293PassRefPtr<DOMStringList> ClipboardChromium::types() const
     294{
    295295    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
    296         return results;
    297 
    298     if (!m_dataObject)
    299         return results;
    300 
    301     results = m_dataObject->types();
     296        return DOMStringList::create();
     297
     298    if (!m_dataObject)
     299        return DOMStringList::create();
     300
     301    RefPtr<DOMStringList> results = m_dataObject->types();
    302302
    303303    if (m_dataObject->containsFilenames())
    304         results.add(mimeTypeFiles);
    305 
    306     return results;
     304        results->append(mimeTypeFiles);
     305
     306    return results.release();
    307307}
    308308
     
    519519    if (isForCopyAndPaste() && policy() == ClipboardReadable) {
    520520        // Iterate through the types and add them.
    521         HashSet<String> types = m_dataObject->types();
    522         for (HashSet<String>::const_iterator it = types.begin(); it != types.end(); ++it)
    523             items.append(DataTransferItemChromium::createFromPasteboard(this, scriptExecutionContext, *it));
     521        RefPtr<DOMStringList> types = m_dataObject->types();
     522        for (size_t i = 0; i < types->length(); ++i)
     523            items.append(DataTransferItemChromium::createFromPasteboard(this, scriptExecutionContext, types->item(i)));
    524524        return;
    525525    }
  • trunk/Source/WebCore/platform/chromium/ClipboardChromium.h

    r105962 r107894  
    6464
    6565        // extensions beyond IE's API
    66         virtual HashSet<String> types() const;
     66        virtual PassRefPtr<DOMStringList> types() const;
    6767        virtual PassRefPtr<FileList> files() const;
    6868
  • trunk/Source/WebCore/platform/chromium/DragDataChromium.cpp

    r105826 r107894  
    4646static bool containsHTML(const ChromiumDataObject* dropData)
    4747{
    48     return dropData->types().contains(mimeTypeTextHTML);
     48    return dropData->types()->contains(mimeTypeTextHTML);
    4949}
    5050
    5151bool DragData::containsURL(Frame*, FilenameConversionPolicy filenamePolicy) const
    5252{
    53     return m_platformDragData->types().contains(mimeTypeTextURIList)
     53    return m_platformDragData->types()->contains(mimeTypeTextURIList)
    5454        || (filenamePolicy == ConvertFilenames && m_platformDragData->containsFilenames());
    5555}
     
    5858{
    5959    String url;
    60     if (m_platformDragData->types().contains(mimeTypeTextURIList)) {
     60    if (m_platformDragData->types()->contains(mimeTypeTextURIList)) {
    6161        bool ignoredSuccess;
    6262        url = m_platformDragData->getData(mimeTypeURL, ignoredSuccess);
     
    8888bool DragData::containsPlainText() const
    8989{
    90     return m_platformDragData->types().contains(mimeTypeTextPlain);
     90    return m_platformDragData->types()->contains(mimeTypeTextPlain);
    9191}
    9292
     
    109109    // ClipboardWin::writeRange is called).  For example, dragging a link
    110110    // should not result in a space being added.
    111     return m_platformDragData->types().contains(mimeTypeTextPlain)
    112         && !m_platformDragData->types().contains(mimeTypeTextURIList);
     111    return m_platformDragData->types()->contains(mimeTypeTextPlain)
     112        && !m_platformDragData->types()->contains(mimeTypeTextURIList);
    113113}
    114114
     
    142142    }
    143143
    144     if (m_platformDragData->types().contains(mimeTypeTextHTML)) {
     144    if (m_platformDragData->types()->contains(mimeTypeTextHTML)) {
    145145        bool ignoredSuccess;
    146146        RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(frame->document(),
  • trunk/Source/WebCore/platform/efl/ClipboardEfl.cpp

    r103006 r107894  
    2222#include "ClipboardEfl.h"
    2323
     24#include "DOMStringList.h"
    2425#include "DataTransferItemList.h"
    2526#include "Editor.h"
     
    7879}
    7980
    80 HashSet<String> ClipboardEfl::types() const
     81PassRefPtr<DOMStringList> ClipboardEfl::types() const
    8182{
    8283    notImplemented();
    83     return HashSet<String>();
     84    return DOMStringList::create();
    8485}
    8586
  • trunk/Source/WebCore/platform/efl/ClipboardEfl.h

    r103006 r107894  
    4040    bool setData(const String&, const String&);
    4141
    42     HashSet<String> types() const;
     42    PassRefPtr<DOMStringList> types() const;
    4343    virtual PassRefPtr<FileList> files() const;
    4444
  • trunk/Source/WebCore/platform/gtk/ClipboardGtk.cpp

    r100817 r107894  
    1919
    2020#include "CachedImage.h"
     21#include "DOMStringList.h"
    2122#include "DragData.h"
    2223#include "Editor.h"
     
    190191}
    191192
    192 HashSet<String> ClipboardGtk::types() const
     193PassRefPtr<DOMStringList> ClipboardGtk::types() const
    193194{
    194195    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
    195         return HashSet<String>();
     196        return DOMStringList::create();
    196197
    197198    if (m_clipboard)
    198199        PasteboardHelper::defaultPasteboardHelper()->getClipboardContents(m_clipboard);
    199200
    200     HashSet<String> types;
     201    RefPtr<DOMStringList> types = DOMStringList::create();
    201202    if (m_dataObject->hasText()) {
    202         types.add("text/plain");
    203         types.add("Text");
    204         types.add("text");
     203        types->append("text/plain");
     204        types->append("Text");
     205        types->append("text");
    205206    }
    206207
    207208    if (m_dataObject->hasMarkup())
    208         types.add("text/html");
     209        types->append("text/html");
    209210
    210211    if (m_dataObject->hasURIList()) {
    211         types.add("text/uri-list");
    212         types.add("URL");
     212        types->append("text/uri-list");
     213        types->append("URL");
    213214    }
    214215
    215216    if (m_dataObject->hasFilenames())
    216         types.add("Files");
    217 
    218     return types;
     217        types->append("Files");
     218
     219    return types.release();
    219220}
    220221
  • trunk/Source/WebCore/platform/gtk/ClipboardGtk.h

    r99924 r107894  
    5858        bool setData(const String&, const String&);
    5959
    60         virtual HashSet<String> types() const;
     60        virtual PassRefPtr<DOMStringList> types() const;
    6161        virtual PassRefPtr<FileList> files() const;
    6262
  • trunk/Source/WebCore/platform/mac/ClipboardMac.h

    r107844 r107894  
    5757   
    5858    // extensions beyond IE's API
    59     virtual HashSet<String> types() const;
     59    virtual PassRefPtr<DOMStringList> types() const;
    6060    virtual PassRefPtr<FileList> files() const;
    6161
  • trunk/Source/WebCore/platform/mac/ClipboardMac.mm

    r107844 r107894  
    2828
    2929#import "DOMElementInternal.h"
     30#import "DOMStringList.h"
    3031#import "DragClient.h"
    3132#import "DragController.h"
     
    112113}
    113114
    114 static void addHTMLClipboardTypesForCocoaType(HashSet<String>& resultTypes, const String& cocoaType, const String& pasteboardName)
     115static void addHTMLClipboardTypesForCocoaType(DOMStringList* resultTypes, const String& cocoaType, const String& pasteboardName)
    115116{
    116117    // UTI may not do these right, so make sure we get the right, predictable result
    117118    if (cocoaType == String(NSStringPboardType)) {
    118         resultTypes.add("text/plain");
     119        resultTypes->append("text/plain");
    119120        return;
    120121    }
    121122    if (cocoaType == String(NSURLPboardType)) {
    122         resultTypes.add("text/uri-list");
     123        resultTypes->append("text/uri-list");
    123124        return;
    124125    }
     
    132133            // It is unknown if NSFilenamesPboardType always implies NSURLPboardType in Cocoa,
    133134            // but NSFilenamesPboardType should imply both 'text/uri-list' and 'Files'
    134             resultTypes.add("text/uri-list");
    135             resultTypes.add("Files");
     135            resultTypes->append("text/uri-list");
     136            resultTypes->append("Files");
    136137        }
    137138        return;
     
    139140    String utiType = utiTypeFromCocoaType(cocoaType);
    140141    if (!utiType.isEmpty()) {
    141         resultTypes.add(utiType);
     142        resultTypes->append(utiType);
    142143        return;
    143144    }
    144145    // No mapping, just pass the whole string though
    145     resultTypes.add(cocoaType);
     146    resultTypes->append(cocoaType);
    146147}
    147148
     
    284285}
    285286
    286 HashSet<String> ClipboardMac::types() const
     287PassRefPtr<DOMStringList> ClipboardMac::types() const
    287288{
    288289    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
    289         return HashSet<String>();
     290        return DOMStringList::create();
    290291
    291292    Vector<String> types;
     
    295296    // sure it doesn't change between our testing the change count and accessing the data.
    296297    if (m_changeCount != platformStrategies()->pasteboardStrategy()->changeCount(m_pasteboardName))
    297         return HashSet<String>();
    298 
    299     HashSet<String> result;
     298        return DOMStringList::create();
     299
     300    RefPtr<DOMStringList> result = DOMStringList::create();
    300301    // FIXME: This loop could be split into two stages. One which adds all the HTML5 specified types
    301302    // and a second which adds all the extra types from the cocoa clipboard (which is Mac-only behavior).
     
    304305            continue;   // skip this ancient type that gets auto-supplied by some system conversion
    305306
    306         addHTMLClipboardTypesForCocoaType(result, types[i], m_pasteboardName);
    307     }
    308 
    309     return result;
     307        addHTMLClipboardTypesForCocoaType(result.get(), types[i], m_pasteboardName);
     308    }
     309
     310    return result.release();
    310311}
    311312
  • trunk/Source/WebCore/platform/qt/ClipboardQt.cpp

    r99924 r107894  
    3131
    3232#include "CachedImage.h"
     33#include "DOMStringList.h"
    3334#include "DataTransferItemListQt.h"
    3435#include "Document.h"
     
    190191
    191192// extensions beyond IE's API
    192 HashSet<String> ClipboardQt::types() const
     193PassRefPtr<DOMStringList> ClipboardQt::types() const
    193194{
    194195    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
    195         return HashSet<String>();
     196        return DOMStringList::create();
    196197
    197198    ASSERT(m_readableData);
    198     HashSet<String> result;
     199    RefPtr<DOMStringList> result = DOMStringList::create();
    199200    QStringList formats = m_readableData->formats();
    200201    for (int i = 0; i < formats.count(); ++i)
    201         result.add(formats.at(i));
    202     return result;
     202        result->append(formats.at(i));
     203    return result.release();
    203204}
    204205
  • trunk/Source/WebCore/platform/qt/ClipboardQt.h

    r98821 r107894  
    5858
    5959    // extensions beyond IE's API
    60     virtual HashSet<String> types() const;
     60    virtual PassRefPtr<DOMStringList> types() const;
    6161    virtual PassRefPtr<FileList> files() const;
    6262
  • trunk/Source/WebCore/platform/win/ClipboardWin.cpp

    r102016 r107894  
    2929#include "CachedImage.h"
    3030#include "ClipboardUtilitiesWin.h"
     31#include "DOMStringList.h"
    3132#include "Document.h"
    3233#include "DragData.h"
     
    486487}
    487488
    488 static void addMimeTypesForFormat(HashSet<String>& results, const FORMATETC& format)
     489static void addMimeTypesForFormat(DOMStringList* results, const FORMATETC& format)
    489490{
    490491    // URL and Text are provided for compatibility with IE's model
    491492    if (format.cfFormat == urlFormat()->cfFormat || format.cfFormat == urlWFormat()->cfFormat) {
    492         results.add("URL");
    493         results.add("text/uri-list");
     493        results->append("URL");
     494        results->append("text/uri-list");
    494495    }
    495496
    496497    if (format.cfFormat == plainTextWFormat()->cfFormat || format.cfFormat == plainTextFormat()->cfFormat) {
    497         results.add("Text");
    498         results.add("text/plain");
     498        results->append("Text");
     499        results->append("text/plain");
    499500    }
    500501}
    501502
    502503// extensions beyond IE's API
    503 HashSet<String> ClipboardWin::types() const
     504PassRefPtr<DOMStringList> ClipboardWin::types() const
    504505{
    505     HashSet<String> results;
     506    RefPtr<DOMStringList> results = DOMStringList::create();
    506507    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
    507508        return results;
     
    523524        // IEnumFORMATETC::Next returns S_FALSE if there are no more items.
    524525        while (itr->Next(1, &data, 0) == S_OK)
    525             addMimeTypesForFormat(results, data);
     526            addMimeTypesForFormat(results.get(), data);
    526527    } else {
    527528        for (DragDataMap::const_iterator it = m_dragDataMap.begin(); it != m_dragDataMap.end(); ++it) {
    528529            FORMATETC data;
    529530            data.cfFormat = (*it).first;
    530             addMimeTypesForFormat(results, data);
     531            addMimeTypesForFormat(results.get(), data);
    531532        }
    532533    }
    533534
    534     return results;
     535    return results.release();
    535536}
    536537
  • trunk/Source/WebCore/platform/win/ClipboardWin.h

    r97113 r107894  
    6565
    6666    // extensions beyond IE's API
    67     virtual HashSet<String> types() const;
     67    virtual PassRefPtr<DOMStringList> types() const;
    6868    virtual PassRefPtr<FileList> files() const;
    6969
  • trunk/Source/WebCore/platform/wx/ClipboardWx.cpp

    r67973 r107894  
    2727#include "ClipboardWx.h"
    2828
     29#include "DOMStringList.h"
    2930#include "FileList.h"
    3031#include "HashTable.h"
     
    7172
    7273// extensions beyond IE's API
    73 HashSet<String> ClipboardWx::types() const
     74PassRefPtr<DOMStringList> ClipboardWx::types() const
    7475{
    7576    notImplemented();
    76     HashSet<String> result;
    77     return result;
     77    return DOMStringList::create();
    7878}
    7979
  • trunk/Source/WebCore/platform/wx/ClipboardWx.h

    r67973 r107894  
    4747   
    4848        // extensions beyond IE's API
    49         virtual HashSet<String> types() const;
     49        virtual PassRefPtr<DOMStringList> types() const;
    5050        virtual PassRefPtr<FileList> files() const;
    5151   
Note: See TracChangeset for help on using the changeset viewer.