Oilpan: Move core/clipboard/ to oilpan's heap

Source/core/clipboard/DataObject.cpp

 /*
  * Copyright (c) 2008, 2009, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 #include "core/clipboard/DataObject.h"
 
 #include "core/clipboard/Pasteboard.h"
 #include "platform/clipboard/ClipboardMimeTypes.h"
 #include "platform/clipboard/ClipboardUtilities.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebClipboard.h"
 
 namespace WebCore {
 
-PassRefPtr<DataObject> DataObject::createFromPasteboard(PasteMode pasteMode)
+DEFINE_GC_INFO(DataObject);
+
+PassRefPtrWillBeRawPtr<DataObject> DataObject::createFromPasteboard(PasteMode pasteMode)
 {
-    RefPtr<DataObject> dataObject = create();
+    RefPtrWillBeRawPtr<DataObject> dataObject = create();
     blink::WebClipboard::Buffer buffer = Pasteboard::generalPasteboard()->buffer();
     uint64_t sequenceNumber = blink::Platform::current()->clipboard()->sequenceNumber(buffer);
     bool ignored;
     blink::WebVector<blink::WebString> webTypes = blink::Platform::current()->clipboard()->readAvailableTypes(buffer, &ignored);
     ListHashSet<String> types;
     for (size_t i = 0; i < webTypes.size(); ++i)
         types.add(webTypes[i]);
     for (ListHashSet<String>::const_iterator it = types.begin(); it != types.end(); ++it) {
         if (pasteMode == PlainTextOnly && *it != mimeTypeTextPlain)
             continue;
         dataObject->m_itemList.append(DataObjectItem::createFromPasteboard(*it, sequenceNumber));
     }
     return dataObject.release();
 }
 
-PassRefPtr<DataObject> DataObject::create()
+PassRefPtrWillBeRawPtr<DataObject> DataObject::create()
 {
-    return adoptRef(new DataObject());
+    return adoptRefWillBeNoop(new DataObject());
 }
 
-PassRefPtr<DataObject> DataObject::copy() const
+PassRefPtrWillBeRawPtr<DataObject> DataObject::copy() const
 {
-    return adoptRef(new DataObject(*this));
+    return adoptRefWillBeNoop(new DataObject(*this));
 }
 
 size_t DataObject::length() const
 {
     return m_itemList.size();
 }
 
-PassRefPtr<DataObjectItem> DataObject::item(unsigned long index)
+PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::item(unsigned long index)
 {
     if (index >= length())
         return nullptr;
     return m_itemList[index];
 }
 
 void DataObject::deleteItem(unsigned long index)
 {
     if (index >= length())
         return;
     m_itemList.remove(index);
 }
 
 void DataObject::clearAll()
 {
     m_itemList.clear();
 }
 
-PassRefPtr<DataObjectItem> DataObject::add(const String& data, const String& type)
+PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::add(const String& data, const String& type)
 {
-    RefPtr<DataObjectItem> item = DataObjectItem::createFromString(type, data);
+    RefPtrWillBeRawPtr<DataObjectItem> item = DataObjectItem::createFromString(type, data);
     if (!internalAddStringItem(item))
         return nullptr;
     return item;
 }
 
-PassRefPtr<DataObjectItem> DataObject::add(PassRefPtr<File> file)
+PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::add(PassRefPtr<File> file)
 {
     if (!file)
         return nullptr;
 
-    RefPtr<DataObjectItem> item = DataObjectItem::createFromFile(file);
+    RefPtrWillBeRawPtr<DataObjectItem> item = DataObjectItem::createFromFile(file);
     m_itemList.append(item);
     return item;
 }
 
 void DataObject::clearData(const String& type)
 {
     for (size_t i = 0; i < m_itemList.size(); ++i) {
         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == type) {
             // Per the spec, type must be unique among all items of kind 'string'.
             m_itemList.remove(i);
@@ skipping 44 matching lines @@
 bool DataObject::setData(const String& type, const String& data)
 {
     clearData(type);
     if (!add(data, type))
         ASSERT_NOT_REACHED();
     return true;
 }
 
 void DataObject::urlAndTitle(String& url, String* title) const
 {
-    RefPtr<DataObjectItem> item = findStringItem(mimeTypeTextURIList);
+    RefPtrWillBeRawPtr<DataObjectItem> item = findStringItem(mimeTypeTextURIList);
     if (!item)
         return;
     url = convertURIListToURL(item->getAsString());
     if (title)
         *title = item->title();
 }
 
 void DataObject::setURLAndTitle(const String& url, const String& title)
 {
     clearData(mimeTypeTextURIList);
     internalAddStringItem(DataObjectItem::createFromURL(url, title));
 }
 
 void DataObject::htmlAndBaseURL(String& html, KURL& baseURL) const
 {
-    RefPtr<DataObjectItem> item = findStringItem(mimeTypeTextHTML);
+    RefPtrWillBeRawPtr<DataObjectItem> item = findStringItem(mimeTypeTextHTML);
     if (!item)
         return;
     html = item->getAsString();
     baseURL = item->baseURL();
 }
 
 void DataObject::setHTMLAndBaseURL(const String& html, const KURL& baseURL)
 {
     clearData(mimeTypeTextHTML);
     internalAddStringItem(DataObjectItem::createFromHTML(html, baseURL));
@@ skipping 27 matching lines @@
 {
     internalAddFileItem(DataObjectItem::createFromSharedBuffer(name, buffer));
 }
 
 DataObject::DataObject()
     : m_modifierKeyState(0)
 {
 }
 
 DataObject::DataObject(const DataObject& other)
-    : RefCounted<DataObject>()
-    , m_itemList(other.m_itemList)
+    : m_itemList(other.m_itemList)
     , m_modifierKeyState(0)
 {
 }
 
-PassRefPtr<DataObjectItem> DataObject::findStringItem(const String& type) const
+PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::findStringItem(const String& type) const
 {
     for (size_t i = 0; i < m_itemList.size(); ++i) {
         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == type)
             return m_itemList[i];
     }
     return nullptr;
 }
 
-bool DataObject::internalAddStringItem(PassRefPtr<DataObjectItem> item)
+bool DataObject::internalAddStringItem(PassRefPtrWillBeRawPtr<DataObjectItem> item)
 {
     ASSERT(item->kind() == DataObjectItem::StringKind);
     for (size_t i = 0; i < m_itemList.size(); ++i) {
         if (m_itemList[i]->kind() == DataObjectItem::StringKind && m_itemList[i]->type() == item->type())
             return false;
     }
 
     m_itemList.append(item);
     return true;
 }
 
-void DataObject::internalAddFileItem(PassRefPtr<DataObjectItem> item)
+void DataObject::internalAddFileItem(PassRefPtrWillBeRawPtr<DataObjectItem> item)
 {
     ASSERT(item->kind() == DataObjectItem::FileKind);
     m_itemList.append(item);
 }
 
+void DataObject::trace(Visitor* visitor)
+{
+    visitor->trace(m_itemList);
+}
+
 } // namespace WebCore