Enable Oilpan for core/clipboard/

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 23 matching lines @@
 #include "core/clipboard/DraggedIsolatedFileSystem.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"
 #include "public/platform/WebDragData.h"
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<DataObject> DataObject::createFromPasteboard(PasteMode pasteMode)
+DataObject* DataObject::createFromPasteboard(PasteMode pasteMode)
 {
-    RefPtrWillBeRawPtr<DataObject> dataObject = create();
+    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 (const String& type : types) {
         if (pasteMode == PlainTextOnly && type != mimeTypeTextPlain)
             continue;
         dataObject->m_itemList.append(DataObjectItem::createFromPasteboard(type, sequenceNumber));
     }
-    return dataObject.release();
+    return dataObject;
 }
 
-PassRefPtrWillBeRawPtr<DataObject> DataObject::create()
+DataObject* DataObject::create()
 {
-    return adoptRefWillBeNoop(new DataObject());
+    return new DataObject;
 }
 
 DataObject::~DataObject()
 {
 }
 
 size_t DataObject::length() const
 {
     return m_itemList.size();
 }
 
-PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::item(unsigned long index)
+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();
 }
 
-PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::add(const String& data, const String& type)
+DataObjectItem* DataObject::add(const String& data, const String& type)
 {
-    RefPtrWillBeRawPtr<DataObjectItem> item = DataObjectItem::createFromString(type, data);
+    DataObjectItem* item = DataObjectItem::createFromString(type, data);
     if (!internalAddStringItem(item))
         return nullptr;
     return item;
 }
 
-PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::add(File* file)
+DataObjectItem* DataObject::add(File* file)
 {
     if (!file)
         return nullptr;
 
-    RefPtrWillBeRawPtr<DataObjectItem> item = DataObjectItem::createFromFile(file);
+    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 32 matching lines @@
 
 void DataObject::setData(const String& type, const String& data)
 {
     clearData(type);
     if (!add(data, type))
         ASSERT_NOT_REACHED();
 }
 
 void DataObject::urlAndTitle(String& url, String* title) const
 {
-    RefPtrWillBeRawPtr<DataObjectItem> item = findStringItem(mimeTypeTextURIList);
+    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
 {
-    RefPtrWillBeRawPtr<DataObjectItem> item = findStringItem(mimeTypeTextHTML);
+    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 26 matching lines @@
 void DataObject::addSharedBuffer(const String& name, PassRefPtr<SharedBuffer> buffer)
 {
     internalAddFileItem(DataObjectItem::createFromSharedBuffer(name, buffer));
 }
 
 DataObject::DataObject()
     : m_modifiers(0)
 {
 }
 
-PassRefPtrWillBeRawPtr<DataObjectItem> DataObject::findStringItem(const String& type) const
+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(PassRefPtrWillBeRawPtr<DataObjectItem> item)
+bool DataObject::internalAddStringItem(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(PassRefPtrWillBeRawPtr<DataObjectItem> item)
+void DataObject::internalAddFileItem(DataObjectItem* item)
 {
     ASSERT(item->kind() == DataObjectItem::FileKind);
     m_itemList.append(item);
 }
 
 DEFINE_TRACE(DataObject)
 {
-#if ENABLE(OILPAN)
     visitor->trace(m_itemList);
     HeapSupplementable<DataObject>::trace(visitor);
-#endif
 }
 
-PassRefPtrWillBeRawPtr<DataObject> DataObject::create(WebDragData data)
+DataObject* DataObject::create(WebDragData data)
 {
-    RefPtrWillBeRawPtr<DataObject> dataObject = create();
+    DataObject* dataObject = create();
 
     WebVector<WebDragData::Item> items = data.items();
     for (unsigned i = 0; i < items.size(); ++i) {
         WebDragData::Item item = items[i];
 
         switch (item.storageType) {
         case WebDragData::Item::StorageTypeString:
             if (String(item.stringType) == mimeTypeTextURIList)
                 dataObject->setURLAndTitle(item.stringData, item.title);
             else if (String(item.stringType) == mimeTypeTextHTML)
@@ skipping 12 matching lines @@
                 // FIXME: The file system URL may refer a user visible file, see http://crbug.com/429077
                 FileMetadata fileMetadata;
                 fileMetadata.length = item.fileSystemFileSize;
                 dataObject->add(File::createForFileSystemFile(item.fileSystemURL, fileMetadata, File::IsNotUserVisible));
             }
             break;
         }
     }
 
     if (!data.filesystemId().isNull())
-        DraggedIsolatedFileSystem::prepareForDataObject(dataObject.get(), data.filesystemId());
-    return dataObject.release();
+        DraggedIsolatedFileSystem::prepareForDataObject(dataObject, data.filesystemId());
+    return dataObject;
 }
 
 WebDragData DataObject::toWebDragData()
 {
     WebDragData data;
     data.initialize();
     WebVector<WebDragData::Item> itemList(length());
 
     for (size_t i = 0; i < length(); ++i) {
-        DataObjectItem* originalItem = item(i).get();
+        DataObjectItem* originalItem = item(i);
         WebDragData::Item item;
         if (originalItem->kind() == DataObjectItem::StringKind) {
             item.storageType = WebDragData::Item::StorageTypeString;
             item.stringType = originalItem->type();
             item.stringData = originalItem->getAsString();
         } else if (originalItem->kind() == DataObjectItem::FileKind) {
             if (originalItem->sharedBuffer()) {
                 item.storageType = WebDragData::Item::StorageTypeBinaryData;
                 item.binaryData = originalItem->sharedBuffer();
             } else if (originalItem->isFilename()) {
@@ skipping 25 matching lines @@
         }
         item.title = originalItem->title();
         item.baseURL = originalItem->baseURL();
         itemList[i] = item;
     }
     data.swapItems(itemList);
     return data;
 }
 
 } // namespace blink