Accurate transfer of SerializedScriptValue allocation costs.

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 117 matching lines @@
 }
 
 ArrayBufferContents::DataHandle ArrayBufferContents::createDataHandle(
     size_t size,
     InitializationPolicy policy) {
   return DataHandle(ArrayBufferContents::allocateMemoryOrNull(size, policy),
                     freeMemory);
 }
 
 ArrayBufferContents::DataHolder::DataHolder()
-    : m_data(nullptr, freeMemory), m_sizeInBytes(0), m_isShared(NotShared) {}
+    : m_data(nullptr, freeMemory),
+      m_sizeInBytes(0),
+      m_isShared(NotShared),
+      m_hasRegisteredExternalAllocation(false) {}
 
 ArrayBufferContents::DataHolder::~DataHolder() {
-  adjustAmountOfExternalAllocatedMemory(-static_cast<int64_t>(m_sizeInBytes));
+  if (m_hasRegisteredExternalAllocation)
+    adjustAmountOfExternalAllocatedMemory(-static_cast<int64_t>(m_sizeInBytes));
 
   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);
+  DCHECK(!m_hasRegisteredExternalAllocation);
 
   m_data = createDataHandle(sizeInBytes, policy);
   if (!m_data)
     return;
 
   m_sizeInBytes = sizeInBytes;
   m_isShared = isShared;
 
   adjustAmountOfExternalAllocatedMemory(m_sizeInBytes);
 }
 
 void ArrayBufferContents::DataHolder::adopt(DataHandle data,
                                             unsigned sizeInBytes,
                                             SharingType isShared) {
   DCHECK(!m_data);
   DCHECK_EQ(m_sizeInBytes, 0u);
+  DCHECK(!m_hasRegisteredExternalAllocation);
 
   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);
+  DCHECK(!m_hasRegisteredExternalAllocation);
 
   m_data = createDataHandle(source.sizeInBytes(), DontInitialize);
   if (!m_data)
     return;
 
   m_sizeInBytes = source.sizeInBytes();
   memcpy(m_data.get(), source.data(), source.sizeInBytes());
 
   adjustAmountOfExternalAllocatedMemory(m_sizeInBytes);
 }
 
+void ArrayBufferContents::DataHolder::
+    registerExternalAllocationWithCurrentContext() {
+  DCHECK(!m_hasRegisteredExternalAllocation);
+  adjustAmountOfExternalAllocatedMemory(static_cast<int64_t>(m_sizeInBytes));
+}
+
+void ArrayBufferContents::DataHolder::
+    unregisterExternalAllocationWithCurrentContext() {
+  if (!m_hasRegisteredExternalAllocation)
+    return;
+  adjustAmountOfExternalAllocatedMemory(-static_cast<int64_t>(m_sizeInBytes));
+}
+
 }  // namespace WTF