Accurate transfer of SerializedScriptValue allocation costs.

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

 /*
  * 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 84 matching lines @@
   static void freeMemory(void*);
   static DataHandle createDataHandle(size_t, InitializationPolicy);
   static void initialize(
       AdjustAmountOfExternalAllocatedMemoryFunction function) {
     DCHECK(isMainThread());
     DCHECK_EQ(s_adjustAmountOfExternalAllocatedMemoryFunction,
               defaultAdjustAmountOfExternalAllocatedMemoryFunction);
     s_adjustAmountOfExternalAllocatedMemoryFunction = function;
   }
 
-  enum LeaveOrEnter {
-    Leave,
-    Enter,
-  };
+  void registerExternalAllocationWithCurrentContext() {
+    if (m_holder)
+      m_holder->registerExternalAllocationWithCurrentContext();
+  }
 
-  // Externally allocated memory is kept track of per context (isolate),
-  // hence when moving ArrayBufferContents to another context, its
-  // externally allocated memory needs to be registered with its
-  // destination context.
-  //
-  // Expose |adjustExternalAllocatedMemoryUponContextTransfer| in order to do
-  // so, which postMessage() implementations make use of when transferring
-  // array buffers.
-  void adjustExternalAllocatedMemoryUponContextTransfer(
-      LeaveOrEnter direction) {
-    int64_t diff = static_cast<int64_t>(sizeInBytes());
-    if (!diff)
-      return;
-    if (direction == Leave)
-      diff = -diff;
-    m_holder->adjustAmountOfExternalAllocatedMemory(diff);
+  void unregisterExternalAllocationWithCurrentContext() {
+    if (m_holder)
+      m_holder->unregisterExternalAllocationWithCurrentContext();
   }
 
  private:
   static void* allocateMemoryWithFlags(size_t, InitializationPolicy, int);
 
   static void defaultAdjustAmountOfExternalAllocatedMemoryFunction(
       int64_t diff);
 
   class DataHolder : public ThreadSafeRefCounted<DataHolder> {
     WTF_MAKE_NONCOPYABLE(DataHolder);
 
    public:
     DataHolder();
     ~DataHolder();
 
     void allocateNew(unsigned sizeInBytes,
                      SharingType isShared,
                      InitializationPolicy);
     void adopt(DataHandle, unsigned sizeInBytes, SharingType isShared);
     void copyMemoryFrom(const DataHolder& source);
 
     const void* data() const { return m_data.get(); }
     void* data() { return m_data.get(); }
     unsigned sizeInBytes() const { return m_sizeInBytes; }
     bool isShared() const { return m_isShared == Shared; }
 
+    void registerExternalAllocationWithCurrentContext();
+    void unregisterExternalAllocationWithCurrentContext();
+
+   private:
     void adjustAmountOfExternalAllocatedMemory(int64_t diff) {
+      m_hasRegisteredExternalAllocation = !m_hasRegisteredExternalAllocation;
+      DCHECK(!diff || (m_hasRegisteredExternalAllocation == (diff > 0)));
       checkIfAdjustAmountOfExternalAllocatedMemoryIsConsistent();
       s_adjustAmountOfExternalAllocatedMemoryFunction(diff);
     }
 
-   private:
     void adjustAmountOfExternalAllocatedMemory(unsigned diff) {
       adjustAmountOfExternalAllocatedMemory(static_cast<int64_t>(diff));
     }
 
     void checkIfAdjustAmountOfExternalAllocatedMemoryIsConsistent() {
       DCHECK(s_adjustAmountOfExternalAllocatedMemoryFunction);
 
 #if DCHECK_IS_ON()
       // Make sure that the function actually used is always the same.
       // Shouldn't be updated during its use.
       if (!s_lastUsedAdjustAmountOfExternalAllocatedMemoryFunction) {
         s_lastUsedAdjustAmountOfExternalAllocatedMemoryFunction =
             s_adjustAmountOfExternalAllocatedMemoryFunction;
       }
       DCHECK_EQ(s_adjustAmountOfExternalAllocatedMemoryFunction,
                 s_lastUsedAdjustAmountOfExternalAllocatedMemoryFunction);
 #endif
     }
 
     DataHandle m_data;
     unsigned m_sizeInBytes;
     SharingType m_isShared;
+    bool m_hasRegisteredExternalAllocation;
   };
 
   RefPtr<DataHolder> m_holder;
   static AdjustAmountOfExternalAllocatedMemoryFunction
       s_adjustAmountOfExternalAllocatedMemoryFunction;
 #if DCHECK_IS_ON()
   static AdjustAmountOfExternalAllocatedMemoryFunction
       s_lastUsedAdjustAmountOfExternalAllocatedMemoryFunction;
 #endif
 };
 
 }  // namespace WTF
 
 #endif  // ArrayBufferContents_h