Changeset 146644 in webkit


Ignore:
Timestamp:
Mar 22, 2013 1:04:15 PM (11 years ago)
Author:
dcheng@chromium.org
Message:

Data store should be readable in dragstart/copy/cut events
​https://bugs.webkit.org/show_bug.cgi?id=23695

Reviewed by Tony Chang.

Source/WebCore:

There were several events where data could be written but not read back due to the fact that
different Clipboard method implementations checked permissions inconsistently. This patch
adds helper methods to check if an operation is permitted on a Clipboard and refactors all
direct comparisons against Clipboard::m_policy to use the new helpers instead. This fixes
several bugs where Clipboard::types and Clipboard::getData are not usable inside the
aforementioned events.

Tests: editing/pasteboard/can-read-in-copy-and-cut-events.html

editing/pasteboard/can-read-in-dragstart-event.html

  • dom/Clipboard.cpp:

(WebCore::Clipboard::canReadTypes): Formerly restricted to ClipboardReadable and

ClipboardTypesReadable; now allows ClipboardWritable as
well.

(WebCore::Clipboard::canReadData): Formerly restricted to ClipboardReadable; now allows

ClipboardWritable as well.

(WebCore::Clipboard::canWriteData):
(WebCore::Clipboard::canSetDragImage):
(WebCore::Clipboard::hasFileOfType):
(WebCore::Clipboard::hasStringOfType):
(WebCore::Clipboard::setDropEffect):
(WebCore::Clipboard::setEffectAllowed):

  • dom/Clipboard.h:

(Clipboard):

  • platform/blackberry/ClipboardBlackBerry.cpp:

(WebCore::ClipboardBlackBerry::clearData):
(WebCore::ClipboardBlackBerry::clearAllData):
(WebCore::ClipboardBlackBerry::getData):
(WebCore::ClipboardBlackBerry::setData):
(WebCore::ClipboardBlackBerry::types):

  • platform/chromium/ClipboardChromium.cpp:

(WebCore::DataTransferItemPolicyWrapper::kind):
(WebCore::DataTransferItemPolicyWrapper::type):
(WebCore::DataTransferItemPolicyWrapper::getAsString):
(WebCore::DataTransferItemPolicyWrapper::getAsFile):
(WebCore::ClipboardChromium::clearData):
(WebCore::ClipboardChromium::clearAllData):
(WebCore::ClipboardChromium::getData):
(WebCore::ClipboardChromium::setData):
(WebCore::ClipboardChromium::types):
(WebCore::ClipboardChromium::files):
(WebCore::ClipboardChromium::setDragImage):

  • platform/gtk/ClipboardGtk.cpp:

(WebCore::ClipboardGtk::clearData):
(WebCore::ClipboardGtk::clearAllData):
(WebCore::ClipboardGtk::getData):
(WebCore::ClipboardGtk::setData):
(WebCore::ClipboardGtk::types):
(WebCore::ClipboardGtk::files):
(WebCore::ClipboardGtk::setDragImage):

  • platform/mac/ClipboardMac.mm:

(WebCore::ClipboardMac::clearData):
(WebCore::ClipboardMac::clearAllData):
(WebCore::ClipboardMac::getData):
(WebCore::ClipboardMac::setData):
(WebCore::ClipboardMac::types):
(WebCore::ClipboardMac::files):
(WebCore::ClipboardMac::setDragImage):

  • platform/qt/ClipboardQt.cpp:

(WebCore::ClipboardQt::clearData):
(WebCore::ClipboardQt::clearAllData):
(WebCore::ClipboardQt::getData):
(WebCore::ClipboardQt::setData):
(WebCore::ClipboardQt::types):
(WebCore::ClipboardQt::files):
(WebCore::ClipboardQt::setDragImage):
(WebCore::ClipboardQt::items):

  • platform/qt/DataTransferItemListQt.cpp:

(WebCore::DataTransferItemListQt::length):
(WebCore::DataTransferItemListQt::item):
(WebCore::DataTransferItemListQt::deleteItem):
(WebCore::DataTransferItemListQt::clear):
(WebCore::DataTransferItemListQt::add):

  • platform/qt/DataTransferItemQt.cpp:

(WebCore::DataTransferItemQt::getAsString):

  • platform/win/ClipboardWin.cpp:

(WebCore::ClipboardWin::clearData):
(WebCore::ClipboardWin::clearAllData):
(WebCore::ClipboardWin::getData):
(WebCore::ClipboardWin::setData):
(WebCore::ClipboardWin::types):
(WebCore::ClipboardWin::files):
(WebCore::ClipboardWin::setDragImage):

LayoutTests:

  • editing/pasteboard/can-read-in-copy-and-cut-events-expected.txt: Added.
  • editing/pasteboard/can-read-in-copy-and-cut-events.html: Added.
  • editing/pasteboard/can-read-in-dragstart-event-expected.txt: Added.
  • editing/pasteboard/can-read-in-dragstart-event.html: Added.
Location:
trunk
Files:
4 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r146643 r146644  
     12013-03-22  Daniel Cheng  <dcheng@chromium.org>
     2
     3        Data store should be readable in dragstart/copy/cut events
     4        https://bugs.webkit.org/show_bug.cgi?id=23695
     5
     6        Reviewed by Tony Chang.
     7
     8        * editing/pasteboard/can-read-in-copy-and-cut-events-expected.txt: Added.
     9        * editing/pasteboard/can-read-in-copy-and-cut-events.html: Added.
     10        * editing/pasteboard/can-read-in-dragstart-event-expected.txt: Added.
     11        * editing/pasteboard/can-read-in-dragstart-event.html: Added.
     12
    1132013-03-22  Stephen Chenney  <schenney@chromium.org>
    214

  • trunk/Source/WebCore/ChangeLog

    r146642 r146644  
     12013-03-22  Daniel Cheng  <dcheng@chromium.org>
     2
     3        Data store should be readable in dragstart/copy/cut events
     4        https://bugs.webkit.org/show_bug.cgi?id=23695
     5
     6        Reviewed by Tony Chang.
     7
     8        There were several events where data could be written but not read back due to the fact that
     9        different Clipboard method implementations checked permissions inconsistently. This patch
     10        adds helper methods to check if an operation is permitted on a Clipboard and refactors all
     11        direct comparisons against Clipboard::m_policy to use the new helpers instead. This fixes
     12        several bugs where Clipboard::types and Clipboard::getData are not usable inside the
     13        aforementioned events.
     14
     15        Tests: editing/pasteboard/can-read-in-copy-and-cut-events.html
     16               editing/pasteboard/can-read-in-dragstart-event.html
     17
     18        * dom/Clipboard.cpp:
     19        (WebCore::Clipboard::canReadTypes): Formerly restricted to ClipboardReadable and
     20                                            ClipboardTypesReadable; now allows ClipboardWritable as
     21                                            well.
     22        (WebCore::Clipboard::canReadData): Formerly restricted to ClipboardReadable; now allows
     23                                           ClipboardWritable as well.
     24        (WebCore::Clipboard::canWriteData):
     25        (WebCore::Clipboard::canSetDragImage):
     26        (WebCore::Clipboard::hasFileOfType):
     27        (WebCore::Clipboard::hasStringOfType):
     28        (WebCore::Clipboard::setDropEffect):
     29        (WebCore::Clipboard::setEffectAllowed):
     30        * dom/Clipboard.h:
     31        (Clipboard):
     32        * platform/blackberry/ClipboardBlackBerry.cpp:
     33        (WebCore::ClipboardBlackBerry::clearData):
     34        (WebCore::ClipboardBlackBerry::clearAllData):
     35        (WebCore::ClipboardBlackBerry::getData):
     36        (WebCore::ClipboardBlackBerry::setData):
     37        (WebCore::ClipboardBlackBerry::types):
     38        * platform/chromium/ClipboardChromium.cpp:
     39        (WebCore::DataTransferItemPolicyWrapper::kind):
     40        (WebCore::DataTransferItemPolicyWrapper::type):
     41        (WebCore::DataTransferItemPolicyWrapper::getAsString):
     42        (WebCore::DataTransferItemPolicyWrapper::getAsFile):
     43        (WebCore::ClipboardChromium::clearData):
     44        (WebCore::ClipboardChromium::clearAllData):
     45        (WebCore::ClipboardChromium::getData):
     46        (WebCore::ClipboardChromium::setData):
     47        (WebCore::ClipboardChromium::types):
     48        (WebCore::ClipboardChromium::files):
     49        (WebCore::ClipboardChromium::setDragImage):
     50        * platform/gtk/ClipboardGtk.cpp:
     51        (WebCore::ClipboardGtk::clearData):
     52        (WebCore::ClipboardGtk::clearAllData):
     53        (WebCore::ClipboardGtk::getData):
     54        (WebCore::ClipboardGtk::setData):
     55        (WebCore::ClipboardGtk::types):
     56        (WebCore::ClipboardGtk::files):
     57        (WebCore::ClipboardGtk::setDragImage):
     58        * platform/mac/ClipboardMac.mm:
     59        (WebCore::ClipboardMac::clearData):
     60        (WebCore::ClipboardMac::clearAllData):
     61        (WebCore::ClipboardMac::getData):
     62        (WebCore::ClipboardMac::setData):
     63        (WebCore::ClipboardMac::types):
     64        (WebCore::ClipboardMac::files):
     65        (WebCore::ClipboardMac::setDragImage):
     66        * platform/qt/ClipboardQt.cpp:
     67        (WebCore::ClipboardQt::clearData):
     68        (WebCore::ClipboardQt::clearAllData):
     69        (WebCore::ClipboardQt::getData):
     70        (WebCore::ClipboardQt::setData):
     71        (WebCore::ClipboardQt::types):
     72        (WebCore::ClipboardQt::files):
     73        (WebCore::ClipboardQt::setDragImage):
     74        (WebCore::ClipboardQt::items):
     75        * platform/qt/DataTransferItemListQt.cpp:
     76        (WebCore::DataTransferItemListQt::length):
     77        (WebCore::DataTransferItemListQt::item):
     78        (WebCore::DataTransferItemListQt::deleteItem):
     79        (WebCore::DataTransferItemListQt::clear):
     80        (WebCore::DataTransferItemListQt::add):
     81        * platform/qt/DataTransferItemQt.cpp:
     82        (WebCore::DataTransferItemQt::getAsString):
     83        * platform/win/ClipboardWin.cpp:
     84        (WebCore::ClipboardWin::clearData):
     85        (WebCore::ClipboardWin::clearAllData):
     86        (WebCore::ClipboardWin::getData):
     87        (WebCore::ClipboardWin::setData):
     88        (WebCore::ClipboardWin::types):
     89        (WebCore::ClipboardWin::files):
     90        (WebCore::ClipboardWin::setDragImage):
     91
    1922013-03-22  Andrei Bucur  <abucur@adobe.com>
    293

  • trunk/Source/WebCore/dom/Clipboard.cpp

    r144565 r146644  
    5252}
    5353
     54bool Clipboard::canReadTypes() const
     55{
     56    return m_policy == ClipboardReadable || m_policy == ClipboardTypesReadable || m_policy == ClipboardWritable;
     57}
     58
     59bool Clipboard::canReadData() const
     60{
     61    return m_policy == ClipboardReadable || m_policy == ClipboardWritable;
     62}
     63
     64bool Clipboard::canWriteData() const
     65{
     66    return m_policy == ClipboardWritable;
     67}
     68
     69bool Clipboard::canSetDragImage() const
     70{
     71    return m_policy == ClipboardImageWritable || m_policy == ClipboardWritable;
     72}
     73
    5474// These "conversion" methods are called by both WebCore and WebKit, and never make sense to JS, so we don't
    5575// worry about security for these. They don't allow access to the pasteboard anyway.
    … …  
    129149bool Clipboard::hasFileOfType(const String& type) const
    130150{
    131     if (m_policy != ClipboardReadable && m_policy != ClipboardTypesReadable)
     151    if (!canReadTypes())
    132152        return false;
    133153   
    … …  
    145165bool Clipboard::hasStringOfType(const String& type) const
    146166{
    147     if (m_policy != ClipboardReadable && m_policy != ClipboardTypesReadable)
     167    if (!canReadTypes())
    148168        return false;
    149169   
    … …  
    160180        return;
    161181
    162     if (m_policy == ClipboardReadable || m_policy == ClipboardTypesReadable)
     182    // FIXME: The spec actually allows this in all circumstances, even though there's no point in
     183    // setting the drop effect when this condition is not true.
     184    if (canReadTypes())
    163185        m_dropEffect = effect;
    164186}
    … …  
    180202
    181203
    182     if (m_policy == ClipboardWritable)
     204    if (canWriteData())
    183205        m_effectAllowed = effect;
    184206}

  • trunk/Source/WebCore/dom/Clipboard.h

    r142170 r146644  
    8787       
    8888        void setAccessPolicy(ClipboardAccessPolicy);
    89         ClipboardAccessPolicy policy() const { return m_policy; }
     89        bool canReadTypes() const;
     90        bool canReadData() const;
     91        bool canWriteData() const;
     92        // Note that the spec doesn't actually allow drag image modification outside the dragstart
     93        // event. This capability is maintained for backwards compatiblity for ports that have
     94        // supported this in the past. On many ports, attempting to set a drag image outside the
     95        // dragstart operation is a no-op anyway.
     96        bool canSetDragImage() const;
    9097
    9198        DragOperation sourceOperation() const;
    … …  
    110117        bool hasFileOfType(const String&) const;
    111118        bool hasStringOfType(const String&) const;
    112        
     119
     120        // Instead of using this member directly, prefer to use the can*() methods above.
    113121        ClipboardAccessPolicy m_policy;
    114122        String m_dropEffect;

  • trunk/Source/WebCore/platform/blackberry/ClipboardBlackBerry.cpp

    r142170 r146644  
    4343void ClipboardBlackBerry::clearData(const String& type)
    4444{
    45     if (policy() != ClipboardWritable)
     45    if (!canWriteData())
    4646        return;
    4747
    … …  
    5151void ClipboardBlackBerry::clearAllData()
    5252{
    53     if (policy() != ClipboardWritable)
     53    if (!canWriteData())
    5454        return;
    5555
    … …  
    5959String ClipboardBlackBerry::getData(const String& type) const
    6060{
    61     if (policy() != ClipboardReadable)
     61    if (!canReadData())
    6262        return String();
    6363
    … …  
    6767bool ClipboardBlackBerry::setData(const String& type, const String& text)
    6868{
    69     if (policy() != ClipboardWritable)
     69    if (!canWriteData())
    7070        return false;
    7171
    … …  
    8181ListHashSet<String> ClipboardBlackBerry::types() const
    8282{
    83     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     83    if (!canReadTypes())
    8484        return ListHashSet<String>();
    8585

  • trunk/Source/WebCore/platform/chromium/ClipboardChromium.cpp

    r142170 r146644  
    9090size_t DataTransferItemListPolicyWrapper::length() const
    9191{
    92     if (m_clipboard->policy() == ClipboardNumb)
     92    if (!m_clipboard->canReadTypes())
    9393        return 0;
    9494    return m_dataObject->length();
    … …  
    9797PassRefPtr<DataTransferItem> DataTransferItemListPolicyWrapper::item(unsigned long index)
    9898{
    99     if (m_clipboard->policy() == ClipboardNumb)
     99    if (!m_clipboard->canReadTypes())
    100100        return 0;
    101101    RefPtr<ChromiumDataObjectItem> item = m_dataObject->item(index);
    … …  
    108108void DataTransferItemListPolicyWrapper::deleteItem(unsigned long index, ExceptionCode& ec)
    109109{
    110     if (m_clipboard->policy() != ClipboardWritable) {
     110    if (!m_clipboard->canWriteData()) {
    111111        ec = INVALID_STATE_ERR;
    112112        return;
    … …  
    117117void DataTransferItemListPolicyWrapper::clear()
    118118{
    119     if (m_clipboard->policy() != ClipboardWritable)
     119    if (!m_clipboard->canWriteData())
    120120        return;
    121121    m_dataObject->clearAll();
    … …  
    124124void DataTransferItemListPolicyWrapper::add(const String& data, const String& type, ExceptionCode& ec)
    125125{
    126     if (m_clipboard->policy() != ClipboardWritable)
     126    if (!m_clipboard->canWriteData())
    127127        return;
    128128    m_dataObject->add(data, type, ec);
    … …  
    131131void DataTransferItemListPolicyWrapper::add(PassRefPtr<File> file)
    132132{
    133     if (m_clipboard->policy() != ClipboardWritable)
     133    if (!m_clipboard->canWriteData())
    134134        return;
    135135    m_dataObject->add(file, m_clipboard->frame()->document()->scriptExecutionContext());
    … …  
    157157String DataTransferItemPolicyWrapper::kind() const
    158158{
    159     if (m_clipboard->policy() == ClipboardNumb)
     159    if (!m_clipboard->canReadTypes())
    160160        return String();
    161161    return m_item->kind();
    … …  
    164164String DataTransferItemPolicyWrapper::type() const
    165165{
    166     if (m_clipboard->policy() == ClipboardNumb)
     166    if (!m_clipboard->canReadTypes())
    167167        return String();
    168168    return m_item->type();
    … …  
    171171void DataTransferItemPolicyWrapper::getAsString(PassRefPtr<StringCallback> callback) const
    172172{
    173     if (m_clipboard->policy() != ClipboardReadable && m_clipboard->policy() != ClipboardWritable)
     173    if (!m_clipboard->canReadData())
    174174        return;
    175175
    … …  
    179179PassRefPtr<Blob> DataTransferItemPolicyWrapper::getAsFile() const
    180180{
    181     if (m_clipboard->policy() != ClipboardReadable && m_clipboard->policy() != ClipboardWritable)
     181    if (!m_clipboard->canReadData())
    182182        return 0;
    183183
    … …  
    239239void ClipboardChromium::clearData(const String& type)
    240240{
    241     if (policy() != ClipboardWritable)
     241    if (!canWriteData())
    242242        return;
    243243
    … …  
    249249void ClipboardChromium::clearAllData()
    250250{
    251     if (policy() != ClipboardWritable)
     251    if (!canWriteData())
    252252        return;
    253253
    … …  
    257257String ClipboardChromium::getData(const String& type) const
    258258{
    259     if (policy() != ClipboardReadable)
     259    if (!canReadData())
    260260        return String();
    261261
    … …  
    269269bool ClipboardChromium::setData(const String& type, const String& data)
    270270{
    271     if (policy() != ClipboardWritable)
     271    if (!canWriteData())
    272272        return false;
    273273
    … …  
    278278ListHashSet<String> ClipboardChromium::types() const
    279279{
    280     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     280    if (!canReadTypes())
    281281        return ListHashSet<String>();
    282282
    … …  
    287287{
    288288    RefPtr<FileList> files = FileList::create();
    289     if (policy() != ClipboardReadable)
     289    if (!canReadData())
    290290        return files.release();
    291291
    … …  
    303303void ClipboardChromium::setDragImage(CachedImage* image, Node* node, const IntPoint& loc)
    304304{
    305     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
     305    if (!canSetDragImage())
    306306        return;
    307307

  • trunk/Source/WebCore/platform/gtk/ClipboardGtk.cpp

    r142170 r146644  
    104104void ClipboardGtk::clearData(const String& typeString)
    105105{
    106     if (policy() != ClipboardWritable)
     106    if (!canWriteData())
    107107        return;
    108108
    … …  
    134134void ClipboardGtk::clearAllData()
    135135{
    136     if (policy() != ClipboardWritable)
     136    if (!canWriteData())
    137137        return;
    138138
    … …  
    149149String ClipboardGtk::getData(const String& typeString) const
    150150{
    151     if (policy() != ClipboardReadable || !m_dataObject)
     151    if (!canReadData() || !m_dataObject)
    152152        return String();
    153153
    … …  
    170170bool ClipboardGtk::setData(const String& typeString, const String& data)
    171171{
    172     if (policy() != ClipboardWritable)
     172    if (!canWriteData())
    173173        return false;
    174174
    … …  
    191191ListHashSet<String> ClipboardGtk::types() const
    192192{
    193     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     193    if (!canReadTypes())
    194194        return ListHashSet<String>();
    195195
    … …  
    220220PassRefPtr<FileList> ClipboardGtk::files() const
    221221{
    222     if (policy() != ClipboardReadable)
     222    if (!canReadData())
    223223        return FileList::create();
    224224
    … …  
    245245void ClipboardGtk::setDragImage(CachedImage* image, Node* element, const IntPoint& location)
    246246{
    247     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
     247    if (!canSetDragImage())
    248248        return;
    249249

  • trunk/Source/WebCore/platform/mac/ClipboardMac.mm

    r144568 r146644  
    156156void ClipboardMac::clearData(const String& type)
    157157{
    158     if (policy() != ClipboardWritable)
     158    if (!canWriteData())
    159159        return;
    160160
    … …  
    168168void ClipboardMac::clearAllData()
    169169{
    170     if (policy() != ClipboardWritable)
     170    if (!canWriteData())
    171171        return;
    172172
    … …  
    221221String ClipboardMac::getData(const String& type) const
    222222{
    223     if (policy() != ClipboardReadable || m_clipboardContents == DragAndDropFiles)
     223    if (!canReadData() || m_clipboardContents == DragAndDropFiles)
    224224        return String();
    225225
    … …  
    250250bool ClipboardMac::setData(const String &type, const String &data)
    251251{
    252     if (policy() != ClipboardWritable || m_clipboardContents == DragAndDropFiles)
     252    if (!canWriteData() || m_clipboardContents == DragAndDropFiles)
    253253        return false;
    254254    // note NSPasteboard enforces changeCount itself on writing - can't write if not the owner
    … …  
    284284ListHashSet<String> ClipboardMac::types() const
    285285{
    286     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     286    if (!canReadTypes())
    287287        return ListHashSet<String>();
    288288
    … …  
    313313PassRefPtr<FileList> ClipboardMac::files() const
    314314{
    315     if (policy() != ClipboardReadable || m_clipboardContents == DragAndDropData)
     315    if (!canReadData() || m_clipboardContents == DragAndDropData)
    316316        return FileList::create();
    317317
    … …  
    341341void ClipboardMac::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
    342342{
    343     if (policy() == ClipboardImageWritable || policy() == ClipboardWritable) {
     343    if (canSetDragImage()) {
    344344        if (m_dragImage)
    345345            m_dragImage->removeClient(this);

  • trunk/Source/WebCore/platform/qt/ClipboardQt.cpp

    r142170 r146644  
    113113void ClipboardQt::clearData(const String& type)
    114114{
    115     if (policy() != ClipboardWritable)
     115    if (!canWriteData())
    116116        return;
    117117
    … …  
    132132void ClipboardQt::clearAllData()
    133133{
    134     if (policy() != ClipboardWritable)
     134    if (!canWriteData())
    135135        return;
    136136
    … …  
    147147{
    148148
    149     if (policy() != ClipboardReadable)
     149    if (!canReadData())
    150150        return String();
    151151
    … …  
    164164bool ClipboardQt::setData(const String& type, const String& data)
    165165{
    166     if (policy() != ClipboardWritable)
     166    if (!canWriteData())
    167167        return false;
    168168
    … …  
    185185ListHashSet<String> ClipboardQt::types() const
    186186{
    187     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     187    if (!canReadTypes())
    188188        return ListHashSet<String>();
    189189
    … …  
    198198PassRefPtr<FileList> ClipboardQt::files() const
    199199{
    200     if (policy() != ClipboardReadable || !m_readableData->hasUrls())
     200    if (!canReadData() || !m_readableData->hasUrls())
    201201        return FileList::create();
    202202
    … …  
    226226void ClipboardQt::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
    227227{
    228     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
     228    if (!canSetDragImage())
    229229        return;
    230230
    … …  
    360360        return items;
    361361
    362     if (isForCopyAndPaste() && policy() == ClipboardReadable) {
     362    if (isForCopyAndPaste() && canReadData()) {
    363363        const QStringList types = m_readableData->formats();
    364364        for (int i = 0; i < types.count(); ++i)

  • trunk/Source/WebCore/platform/qt/DataTransferItemListQt.cpp

    r105825 r146644  
    4848size_t DataTransferItemListQt::length() const
    4949{
    50     if (m_owner->policy() == ClipboardNumb)
     50    if (!m_owner->canReadTypes())
    5151        return 0;
    5252
    … …  
    5656PassRefPtr<DataTransferItem> DataTransferItemListQt::item(unsigned long index)
    5757{
    58     if (m_owner->policy() == ClipboardNumb || index >= length())
     58    if (!m_owner->canReadTypes() || index >= length())
    5959        return 0;
    6060
    … …  
    6464void DataTransferItemListQt::deleteItem(unsigned long index, ExceptionCode& ec)
    6565{
    66     if (m_owner->policy() != ClipboardWritable) {
     66    if (!m_owner->canWriteData()) {
    6767        ec = INVALID_STATE_ERR;
    6868        return;
    … …  
    7777void DataTransferItemListQt::clear()
    7878{
    79     if (m_owner->policy() != ClipboardWritable)
     79    if (!m_owner->canWriteData())
    8080        return;
    8181
    … …  
    8686void DataTransferItemListQt::add(const String& data, const String& type, ExceptionCode& ec)
    8787{
    88     if (m_owner->policy() != ClipboardWritable)
     88    if (!m_owner->canWriteData())
    8989        return;
    9090
    … …  
    102102void DataTransferItemListQt::add(PassRefPtr<File> file)
    103103{
    104     if (m_owner->policy() != ClipboardWritable || !file)
     104    if (!m_owner->canWriteData() || !file)
    105105        return;
    106106

  • trunk/Source/WebCore/platform/qt/DataTransferItemQt.cpp

    r105648 r146644  
    9696void DataTransferItemQt::getAsString(PassRefPtr<StringCallback> callback) const
    9797{
    98     if ((owner()->policy() != ClipboardReadable && owner()->policy() != ClipboardWritable)
    99         || kind() != kindString)
     98    if (!owner()->policy()->canReadData() || kind() != kindString)
    10099        return;
    101100

  • trunk/Source/WebCore/platform/win/ClipboardWin.cpp

    r142170 r146644  
    408408    // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
    409409    ASSERT(isForDragAndDrop());
    410     if (policy() != ClipboardWritable || !m_writableDataObject)
     410    if (!canWriteData() || !m_writableDataObject)
    411411        return;
    412412
    … …  
    428428    // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
    429429    ASSERT(isForDragAndDrop());
    430     if (policy() != ClipboardWritable)
     430    if (!canWriteData())
    431431        return;
    432432   
    … …  
    438438String ClipboardWin::getData(const String& type) const
    439439{     
    440     if (policy() != ClipboardReadable || (!m_dataObject && m_dragDataMap.isEmpty()))
     440    if (!canReadData() || (!m_dataObject && m_dragDataMap.isEmpty()))
    441441        return "";
    442442
    … …  
    460460    // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
    461461    ASSERT(isForDragAndDrop());
    462     if (policy() != ClipboardWritable || !m_writableDataObject)
     462    if (!canWriteData() || !m_writableDataObject)
    463463        return false;
    464464
    … …  
    503503{
    504504    ListHashSet<String> results;
    505     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     505    if (!canReadTypes())
    506506        return results;
    507507
    … …  
    541541#else
    542542    RefPtr<FileList> files = FileList::create();
    543     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
     543    if (!canReadData())
    544544        return files.release();
    545545
    … …  
    579579void ClipboardWin::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
    580580{
    581     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
     581    if (!canSetDragImage())
    582582        return;
    583583       
Note: See TracChangeset for help on using the changeset viewer.