third_party/WebKit/Source/wtf/ArrayBufferContents.cpp

   1 /*
   2  * Copyright (C) 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2013 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "wtf/ArrayBufferContents.h"
  29
  30 #include "wtf/Assertions.h"
  31 #include "wtf/PartitionAlloc.h"
  32 #include "wtf/Partitions.h"
  33 #include <string.h>
  34
  35 namespace WTF {
  36
  37 AdjustAmountOfExternalAllocatedMemoryFunction ArrayBufferContents::s_adjustAmountOfExternalAllocatedMemoryFunction;
  38
  39 ArrayBufferContents::ArrayBufferContents()
  40     : m_holder(adoptRef(new DataHolder())) { }
  41
  42 ArrayBufferContents::ArrayBufferContents(unsigned numElements, unsigned elementByteSize, SharingType isShared, ArrayBufferContents::InitializationPolicy policy)
  43     : m_holder(adoptRef(new DataHolder()))
  44 {
  45     // Do not allow 32-bit overflow of the total size.
  46     unsigned totalSize = numElements * elementByteSize;
  47     if (numElements) {
  48         if (totalSize / numElements != elementByteSize) {
  49             return;
  50         }
  51     }
  52
  53     m_holder->allocateNew(totalSize, isShared, policy);
  54 }
  55
  56 ArrayBufferContents::ArrayBufferContents(
  57     void* data, unsigned sizeInBytes, SharingType isShared)
  58     : m_holder(adoptRef(new DataHolder()))
  59 {
  60     if (data) {
  61         m_holder->adopt(data, sizeInBytes, isShared);
  62     } else {
  63         ASSERT(!sizeInBytes);
  64         sizeInBytes = 0;
  65         // Allow null data if size is 0 bytes, make sure data is valid pointer.
  66         // (PartitionAlloc guarantees valid pointer for size 0)
  67         m_holder->allocateNew(sizeInBytes, isShared, ZeroInitialize);
  68     }
  69 }
  70
  71 ArrayBufferContents::~ArrayBufferContents()
  72 {
  73 }
  74
  75 void ArrayBufferContents::neuter()
  76 {
  77     m_holder.clear();
  78 }
  79
  80 void ArrayBufferContents::transfer(ArrayBufferContents& other)
  81 {
  82     ASSERT(!isShared());
  83     ASSERT(!other.m_holder->data());
  84     other.m_holder = m_holder;
  85     neuter();
  86 }
  87
  88 void ArrayBufferContents::shareWith(ArrayBufferContents& other)
  89 {
  90     ASSERT(isShared());
  91     ASSERT(!other.m_holder->data());
  92     other.m_holder = m_holder;
  93 }
  94
  95 void ArrayBufferContents::copyTo(ArrayBufferContents& other)
  96 {
  97     ASSERT(!m_holder->isShared() && !other.m_holder->isShared());
  98     m_holder->copyMemoryTo(*other.m_holder);
  99 }
 100
 101 void ArrayBufferContents::allocateMemory(size_t size, InitializationPolicy policy, void*& data)
 102 {
 103     if (s_adjustAmountOfExternalAllocatedMemoryFunction)
 104         s_adjustAmountOfExternalAllocatedMemoryFunction(static_cast<int>(size));
 105     data = partitionAllocGeneric(WTF::Partitions::bufferPartition(), size);
 106     if (policy == ZeroInitialize && data)
 107         memset(data, '\0', size);
 108 }
 109
 110 void ArrayBufferContents::freeMemory(void* data, size_t size)
 111 {
 112     Partitions::bufferFree(data);
 113     if (s_adjustAmountOfExternalAllocatedMemoryFunction)
 114         s_adjustAmountOfExternalAllocatedMemoryFunction(-static_cast<int>(size));
 115 }
 116
 117 ArrayBufferContents::DataHolder::DataHolder()
 118     : m_data(nullptr)
 119     , m_sizeInBytes(0)
 120     , m_isShared(NotShared) { }
 121
 122 ArrayBufferContents::DataHolder::~DataHolder()
 123 {
 124     ArrayBufferContents::freeMemory(m_data, m_sizeInBytes);
 125
 126     m_data = nullptr;
 127     m_sizeInBytes = 0;
 128     m_isShared = NotShared;
 129 }
 130
 131 void ArrayBufferContents::DataHolder::allocateNew(unsigned sizeInBytes, SharingType isShared, InitializationPolicy policy)
 132 {
 133     ASSERT(!m_data);
 134     void* data = nullptr;
 135     allocateMemory(sizeInBytes, policy, data);
 136     m_data = data;
 137     m_sizeInBytes = data ? sizeInBytes : 0;
 138     m_isShared = isShared;
 139 }
 140
 141 void ArrayBufferContents::DataHolder::adopt(void* data, unsigned sizeInBytes, SharingType isShared)
 142 {
 143     ASSERT(!m_data);
 144     m_data = data;
 145     m_sizeInBytes = sizeInBytes;
 146     m_isShared = isShared;
 147 }
 148
 149 void ArrayBufferContents::DataHolder::copyMemoryTo(DataHolder& other)
 150 {
 151     ASSERT(!other.m_sizeInBytes);
 152     ArrayBufferContents::freeMemory(other.m_data, other.m_sizeInBytes);
 153     ArrayBufferContents::allocateMemory(m_sizeInBytes, DontInitialize, other.m_data);
 154     if (!other.m_data)
 155         return;
 156     memcpy(other.m_data, m_data, m_sizeInBytes);
 157     other.m_sizeInBytes = m_sizeInBytes;
 158 }
 159
 160 } // namespace WTF