Make SharedBuffer in Resource non-discardable and remove PurgeableVector

third_party/WebKit/Source/platform/SharedBuffer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 36 matching lines @@
     return static_cast<char*>(WTF::Partitions::fastMalloc(SharedBuffer::kSegmentSize, "blink::SharedBuffer"));
 }
 
 static inline void freeSegment(char* p)
 {
     WTF::Partitions::fastFree(p);
 }
 
 SharedBuffer::SharedBuffer()
     : m_size(0)
-    , m_buffer(PurgeableVector::NotPurgeable)
 {
 }
 
 SharedBuffer::SharedBuffer(size_t size)
     : m_size(size)
-    , m_buffer(PurgeableVector::NotPurgeable)
+    , m_buffer(size)
 {
-    m_buffer.reserveCapacity(size);
-    m_buffer.grow(size);
 }
 
 SharedBuffer::SharedBuffer(const char* data, size_t size)
     : m_size(0)
-    , m_buffer(PurgeableVector::NotPurgeable)
-{
-    appendInternal(data, size);
-}
-
-SharedBuffer::SharedBuffer(const char* data, size_t size, PurgeableVector::PurgeableOption purgeable)
-    : m_size(0)
-    , m_buffer(purgeable)
 {
     appendInternal(data, size);
 }
 
 SharedBuffer::SharedBuffer(const unsigned char* data, size_t size)
     : m_size(0)
-    , m_buffer(PurgeableVector::NotPurgeable)
 {
     appendInternal(reinterpret_cast<const char*>(data), size);
 }
 
 SharedBuffer::~SharedBuffer()
 {
     clear();
 }
 
 PassRefPtr<SharedBuffer> SharedBuffer::adoptVector(Vector<char>& vector)
 {
     RefPtr<SharedBuffer> buffer = create();
-    buffer->m_buffer.adopt(vector);
+    buffer->m_buffer.swap(vector);
     buffer->m_size = buffer->m_buffer.size();
     return buffer.release();
 }
 
 size_t SharedBuffer::size() const
 {
     return m_size;
 }
 
 const char* SharedBuffer::data() const
@@ skipping 62 matching lines @@
 
     m_segments.clear();
     m_size = 0;
     m_buffer.clear();
 }
 
 PassRefPtr<SharedBuffer> SharedBuffer::copy() const
 {
     RefPtr<SharedBuffer> clone(adoptRef(new SharedBuffer));
     clone->m_size = m_size;
-    clone->m_buffer.reserveCapacity(m_size);
+    clone->m_buffer.reserveInitialCapacity(m_size);
     clone->m_buffer.append(m_buffer.data(), m_buffer.size());
     if (!m_segments.isEmpty()) {
         const char* segment = 0;
         size_t position = m_buffer.size();
         while (size_t segmentSize = getSomeDataInternal(segment, position)) {
             clone->m_buffer.append(segment, segmentSize);
             position += segmentSize;
         }
         ASSERT(position == clone->size());
     }
@@ skipping 85 matching lines @@
         ASSERT_NOT_REACHED();
         // Don't return the incomplete SkData.
         return nullptr;
     }
     return data;
 }
 
 void SharedBuffer::onMemoryDump(const String& dumpPrefix, WebProcessMemoryDump* memoryDump) const
 {
     if (m_buffer.size()) {
-        m_buffer.onMemoryDump(dumpPrefix + "/shared_buffer", memoryDump);
+        WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpPrefix + "/shared_buffer");
+        dump->addScalar("size", "bytes", m_buffer.size());
+        memoryDump->addSuballocation(dump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
     } else {
         // If there is data in the segments, then it should have been allocated
         // using fastMalloc.
         const String dataDumpName = dumpPrefix + "/segments";
         auto dump = memoryDump->createMemoryAllocatorDump(dataDumpName);
         dump->addScalar("size", "bytes", m_size);
         memoryDump->addSuballocation(dump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
     }
 }
 
 } // namespace blink