Adds support for ArrayBufferContents with external buffer.

third_party/WebKit/Source/wtf/typed_arrays/ArrayBufferContents.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 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:
  * 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 50 matching lines @@
   unsigned totalSize = numElements * elementByteSize;
   if (numElements) {
     if (totalSize / numElements != elementByteSize) {
       return;
     }
   }
 
   m_holder->allocateNew(totalSize, isShared, policy);
 }
 
-ArrayBufferContents::ArrayBufferContents(void* data,
+ArrayBufferContents::ArrayBufferContents(DataHandle data,
                                          unsigned sizeInBytes,
                                          SharingType isShared)
     : m_holder(adoptRef(new DataHolder())) {
   if (data) {
-    m_holder->adopt(data, sizeInBytes, isShared);
+    m_holder->adopt(std::move(data), sizeInBytes, isShared);
   } else {
     DCHECK_EQ(sizeInBytes, 0u);
     sizeInBytes = 0;
     // Allow null data if size is 0 bytes, make sure data is valid pointer.
     // (PartitionAlloc guarantees valid pointer for size 0)
     m_holder->allocateNew(sizeInBytes, isShared, ZeroInitialize);
   }
 }
 
 ArrayBufferContents::~ArrayBufferContents() {}
@@ skipping 13 matching lines @@
   DCHECK(isShared());
   DCHECK(!other.m_holder->data());
   other.m_holder = m_holder;
 }
 
 void ArrayBufferContents::copyTo(ArrayBufferContents& other) {
   DCHECK(!m_holder->isShared() && !other.m_holder->isShared());
   other.m_holder->copyMemoryFrom(*m_holder);
 }
 
-void ArrayBufferContents::allocateMemoryWithFlags(size_t size,
-                                                  InitializationPolicy policy,
-                                                  int flags,
-                                                  void*& data) {
-  data = PartitionAllocGenericFlags(
+void* ArrayBufferContents::allocateMemoryWithFlags(size_t size,
+                                                   InitializationPolicy policy,
+                                                   int flags) {
+  void* data = PartitionAllocGenericFlags(
       Partitions::arrayBufferPartition(), flags, size,
       WTF_HEAP_PROFILER_TYPE_NAME(ArrayBufferContents));
   if (policy == ZeroInitialize && data)
     memset(data, '\0', size);
+  return data;
 }
 
-void ArrayBufferContents::allocateMemory(size_t size,
-                                         InitializationPolicy policy,
-                                         void*& data) {
-  allocateMemoryWithFlags(size, policy, 0, data);
+void* ArrayBufferContents::allocateMemoryOrNull(size_t size,
+                                                InitializationPolicy policy) {
+  return allocateMemoryWithFlags(size, policy, base::PartitionAllocReturnNull);
 }
 
-void ArrayBufferContents::allocateMemoryOrNull(size_t size,
-                                               InitializationPolicy policy,
-                                               void*& data) {
-  allocateMemoryWithFlags(size, policy, base::PartitionAllocReturnNull, data);
-}
-
-void ArrayBufferContents::freeMemory(void* data, size_t size) {
+void ArrayBufferContents::freeMemory(void* data) {
   PartitionFreeGeneric(Partitions::arrayBufferPartition(), data);
 }
 
+ArrayBufferContents::DataHandle ArrayBufferContents::createDataHandle(
+    size_t size,
+    InitializationPolicy policy) {
+  return DataHandle(ArrayBufferContents::allocateMemoryOrNull(size, policy),
+                    freeMemory);
+}
+
 ArrayBufferContents::DataHolder::DataHolder()
-    : m_data(nullptr), m_sizeInBytes(0), m_isShared(NotShared) {}
+    : m_data(nullptr, freeMemory), m_sizeInBytes(0), m_isShared(NotShared) {}
 
 ArrayBufferContents::DataHolder::~DataHolder() {
-  ArrayBufferContents::freeMemory(m_data, m_sizeInBytes);
-
   adjustAmountOfExternalAllocatedMemory(-static_cast<int64_t>(m_sizeInBytes));
 
-  m_data = nullptr;
+  m_data.reset();
   m_sizeInBytes = 0;
   m_isShared = NotShared;
 }
 
 void ArrayBufferContents::DataHolder::allocateNew(unsigned sizeInBytes,
                                                   SharingType isShared,
                                                   InitializationPolicy policy) {
   DCHECK(!m_data);
   DCHECK_EQ(m_sizeInBytes, 0u);
 
-  ArrayBufferContents::allocateMemory(sizeInBytes, policy, m_data);
+  m_data = createDataHandle(sizeInBytes, policy);
   if (!m_data)
     return;
 
   m_sizeInBytes = sizeInBytes;
   m_isShared = isShared;
 
   adjustAmountOfExternalAllocatedMemory(m_sizeInBytes);
 }
 
-void ArrayBufferContents::DataHolder::adopt(void* data,
+void ArrayBufferContents::DataHolder::adopt(DataHandle data,
                                             unsigned sizeInBytes,
                                             SharingType isShared) {
   DCHECK(!m_data);
   DCHECK_EQ(m_sizeInBytes, 0u);
 
-  m_data = data;
+  m_data = std::move(data);
   m_sizeInBytes = sizeInBytes;
   m_isShared = isShared;
 
   adjustAmountOfExternalAllocatedMemory(m_sizeInBytes);
 }
 
 void ArrayBufferContents::DataHolder::copyMemoryFrom(const DataHolder& source) {
   DCHECK(!m_data);
   DCHECK_EQ(m_sizeInBytes, 0u);
 
-  ArrayBufferContents::allocateMemory(source.sizeInBytes(), DontInitialize,
-                                      m_data);
+  m_data = createDataHandle(source.sizeInBytes(), DontInitialize);
   if (!m_data)
     return;
 
   m_sizeInBytes = source.sizeInBytes();
-  memcpy(m_data, source.data(), source.sizeInBytes());
+  memcpy(m_data.get(), source.data(), source.sizeInBytes());
 
   adjustAmountOfExternalAllocatedMemory(m_sizeInBytes);
 }
 
 }  // namespace WTF