src/third_party/WebKit/Source/core/clipboard/DataObject.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "core/clipboard/DataObject.h"
  33
  34 #include "core/clipboard/Pasteboard.h"
  35 #include "platform/clipboard/ClipboardMimeTypes.h"
  36 #include "platform/clipboard/ClipboardUtilities.h"
  37 #include "public/platform/Platform.h"
  38 #include "public/platform/WebClipboard.h"
  39
  40 namespace WebCore {
  41
  42 PassRefPtr<DataObject> DataObject::createFromPasteboard(PasteMode pasteMode)
  43 {
  44     RefPtr<DataObject> dataObject = create();
  45     blink::WebClipboard::Buffer buffer = Pasteboard::generalPasteboard()->buffer();
  46     uint64_t sequenceNumber = blink::Platform::current()->clipboard()->sequenceNumber(buffer);
  47     bool ignored;
  48     blink::WebVector<blink::WebString> webTypes = blink::Platform::current()->clipboard()->readAvailableTypes(buffer, &ignored);
  49     ListHashSet<String> types;
  50     for (size_t i = 0; i < webTypes.size(); ++i)
  51         types.add(webTypes[i]);
  52     for (ListHashSet<String>::const_iterator it = types.begin(); it != types.end(); ++it) {
  53         if (pasteMode == PlainTextOnly && *it != mimeTypeTextPlain)
  54             continue;
  55         dataObject->m_itemList.append(DataObjectItem::createFromPasteboard(*it, sequenceNumber));
  56     }
  57     return dataObject.release();
  58 }
  59
  60 PassRefPtr<DataObject> DataObject::create()
  61 {
  62     return adoptRef(new DataObject());
  63 }
  64
  65 PassRefPtr<DataObject> DataObject::copy() const
  66 {
  67     return adoptRef(new DataObject(*this));
  68 }
  69
  70 size_t DataObject::length() const
  71 {
  72     return m_itemList.size();
  73 }
  74
  75 PassRefPtr<DataObjectItem> DataObject::item(unsigned long index)
  76 {
  77     if (index >= length())
  78         return 0;
  79     return m_itemList[index];
  80 }
  81
  82 void DataObject::deleteItem(unsigned long index)
  83 {
  84     if (index >= length())
  85         return;
  86     m_itemList.remove(index);
  87 }
  88
  89 void DataObject::clearAll()
  90 {
  91     m_itemList.clear();
  92 }
  93
  94 PassRefPtr<DataObjectItem> DataObject::add(const String& data, const String& type)
  95 {
  96     RefPtr<DataObjectItem> item = DataObjectItem::createFromString(type, data);
  97     if (!internalAddStringItem(item))
  98         return 0;
  99     return item;
 100 }
 101
 102 PassRefPtr<DataObjectItem> DataObject::add(PassRefPtr<File> file)
 103 {
 104     if (!file)
 105         return 0;
 106
 107     RefPtr<DataObjectItem> item = DataObjectItem::createFromFile(file);
 108     m_itemList.append(item);
 109     return item;
 110 }
 111
 112 void DataObject::clearData(const String& type)
 113 {
 114     for (size_t i = 0; i < m_itemList.size(); ++i) {
 115         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == type) {
 116             // Per the spec, type must be unique among all items of kind 'string'.
 117             m_itemList.remove(i);
 118             return;
 119         }
 120     }
 121 }
 122
 123 void DataObject::clearAllExceptFiles()
 124 {
 125     for (size_t i = 0; i < m_itemList.size(); ) {
 126         if (m_itemList[i]->kind() != DataObjectItem::FileKind) {
 127             m_itemList.remove(i);
 128             continue;
 129         }
 130         ++i;
 131     }
 132 }
 133
 134 ListHashSet<String> DataObject::types() const
 135 {
 136     ListHashSet<String> results;
 137     bool containsFiles = false;
 138     for (size_t i = 0; i < m_itemList.size(); ++i) {
 139         switch (m_itemList[i]->kind()) {
 140         case DataObjectItem::StringKind:
 141             results.add(m_itemList[i]->type());
 142             break;
 143         case DataObjectItem::FileKind:
 144             containsFiles = true;
 145             break;
 146         }
 147     }
 148     if (containsFiles)
 149         results.add(mimeTypeFiles);
 150     return results;
 151 }
 152
 153 String DataObject::getData(const String& type) const
 154 {
 155     for (size_t i = 0; i < m_itemList.size(); ++i)  {
 156         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == type)
 157             return m_itemList[i]->getAsString();
 158     }
 159     return String();
 160 }
 161
 162 bool DataObject::setData(const String& type, const String& data)
 163 {
 164     clearData(type);
 165     if (!add(data, type))
 166         ASSERT_NOT_REACHED();
 167     return true;
 168 }
 169
 170 void DataObject::urlAndTitle(String& url, String* title) const
 171 {
 172     RefPtr<DataObjectItem> item = findStringItem(mimeTypeTextURIList);
 173     if (!item)
 174         return;
 175     url = convertURIListToURL(item->getAsString());
 176     if (title)
 177         *title = item->title();
 178 }
 179
 180 void DataObject::setURLAndTitle(const String& url, const String& title)
 181 {
 182     clearData(mimeTypeTextURIList);
 183     internalAddStringItem(DataObjectItem::createFromURL(url, title));
 184 }
 185
 186 void DataObject::htmlAndBaseURL(String& html, KURL& baseURL) const
 187 {
 188     RefPtr<DataObjectItem> item = findStringItem(mimeTypeTextHTML);
 189     if (!item)
 190         return;
 191     html = item->getAsString();
 192     baseURL = item->baseURL();
 193 }
 194
 195 void DataObject::setHTMLAndBaseURL(const String& html, const KURL& baseURL)
 196 {
 197     clearData(mimeTypeTextHTML);
 198     internalAddStringItem(DataObjectItem::createFromHTML(html, baseURL));
 199 }
 200
 201 bool DataObject::containsFilenames() const
 202 {
 203     for (size_t i = 0; i < m_itemList.size(); ++i) {
 204         if (m_itemList[i]->isFilename())
 205             return true;
 206     }
 207     return false;
 208 }
 209
 210 Vector<String> DataObject::filenames() const
 211 {
 212     Vector<String> results;
 213     for (size_t i = 0; i < m_itemList.size(); ++i) {
 214         if (m_itemList[i]->isFilename())
 215             results.append(static_cast<File*>(m_itemList[i]->getAsFile().get())->path());
 216     }
 217     return results;
 218 }
 219
 220 void DataObject::addFilename(const String& filename, const String& displayName)
 221 {
 222     internalAddFileItem(DataObjectItem::createFromFile(File::createWithName(filename, displayName, File::AllContentTypes)));
 223 }
 224
 225 void DataObject::addSharedBuffer(const String& name, PassRefPtr<SharedBuffer> buffer)
 226 {
 227     internalAddFileItem(DataObjectItem::createFromSharedBuffer(name, buffer));
 228 }
 229
 230 DataObject::DataObject()
 231     : m_modifierKeyState(0)
 232 {
 233 }
 234
 235 DataObject::DataObject(const DataObject& other)
 236     : RefCounted<DataObject>()
 237     , m_itemList(other.m_itemList)
 238     , m_modifierKeyState(0)
 239 {
 240 }
 241
 242 PassRefPtr<DataObjectItem> DataObject::findStringItem(const String& type) const
 243 {
 244     for (size_t i = 0; i < m_itemList.size(); ++i) {
 245         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == type)
 246             return m_itemList[i];
 247     }
 248     return 0;
 249 }
 250
 251 bool DataObject::internalAddStringItem(PassRefPtr<DataObjectItem> item)
 252 {
 253     ASSERT(item->kind() == DataObjectItem::StringKind);
 254     for (size_t i = 0; i < m_itemList.size(); ++i) {
 255         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == item->type())
 256             return false;
 257     }
 258
 259     m_itemList.append(item);
 260     return true;
 261 }
 262
 263 void DataObject::internalAddFileItem(PassRefPtr<DataObjectItem> item)
 264 {
 265     ASSERT(item->kind() == DataObjectItem::FileKind);
 266     m_itemList.append(item);
 267 }
 268
 269 } // namespace WebCore