Adds support for ArrayBufferContents with external buffer.

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 25 matching lines @@
 #include "wtf/WTFExport.h"
 
 namespace WTF {
 
 class WTF_EXPORT ArrayBufferContents {
   WTF_MAKE_NONCOPYABLE(ArrayBufferContents);
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   using AdjustAmountOfExternalAllocatedMemoryFunction = void (*)(int64_t diff);
+  using DataDeleter = void (*)(void* data);
+  using ScopedData = std::unique_ptr<void, DataDeleter>;

[jbroman, 2017/02/28 20:01:19]

A brief comment about the expected usage of this (namely, that most callers will
want to provide WTF::ArrayBufferContents::freeMemory as the deleter) would be
useful.

[alokp, 2017/02/28 20:56:08]

Done.

 
   enum InitializationPolicy { ZeroInitialize, DontInitialize };
 
   enum SharingType {
     NotShared,
     Shared,
   };
 
   ArrayBufferContents();
   ArrayBufferContents(unsigned numElements,
                       unsigned elementByteSize,
                       SharingType isShared,
                       InitializationPolicy);
-
-  // Use with care. data must be allocated with allocateMemory.
-  // ArrayBufferContents will take ownership of the data and free it (using
-  // freeMemory) upon destruction.
-  // This constructor will not call observer->StartObserving(), so it is a
-  // responsibility of the caller to make sure JS knows about external memory.
-  ArrayBufferContents(void* data, unsigned sizeInBytes, SharingType isShared);
+  ArrayBufferContents(ScopedData, unsigned sizeInBytes, SharingType isShared);
 
   ~ArrayBufferContents();
 
   void neuter();
 
   void* data() const {
     DCHECK(!isShared());
     return dataMaybeShared();
   }
   void* dataShared() const {
     DCHECK(isShared());
     return dataMaybeShared();
   }
   void* dataMaybeShared() const {
     return m_holder ? m_holder->data() : nullptr;
   }
   unsigned sizeInBytes() const {
     return m_holder ? m_holder->sizeInBytes() : 0;
   }
   bool isShared() const { return m_holder ? m_holder->isShared() : false; }
 
   void transfer(ArrayBufferContents& other);
   void shareWith(ArrayBufferContents& other);
   void copyTo(ArrayBufferContents& other);
 
-  static void allocateMemory(size_t, InitializationPolicy, void*&);
-  static void allocateMemoryOrNull(size_t, InitializationPolicy, void*&);
-  static void freeMemory(void*, size_t);
+  static void* allocateMemory(size_t, InitializationPolicy);

[jbroman, 2017/02/28 20:01:19]

Possible bikeshed: but for most callers it might actually be nice this returned
a ScopedData with the right deleter. The couple users that don't could always
use ScopedData::release to get the raw void* out anyhow, and it would make this
less error-prone for callers other than V8.

[alokp, 2017/02/28 20:56:08]

Good idea. Although it would be a bit weird to not expose allocateMemory but
still expose freeMemory (which would be needed by V8Initializer). So I create a
helper createData function instead. I was also able to get rid of allocateMemory
since all usage has been replaced by createData.

+  static void* allocateMemoryOrNull(size_t, InitializationPolicy);
+  static void freeMemory(void*);
   static void initialize(
       AdjustAmountOfExternalAllocatedMemoryFunction function) {
     DCHECK(isMainThread());
     DCHECK_EQ(s_adjustAmountOfExternalAllocatedMemoryFunction,
               defaultAdjustAmountOfExternalAllocatedMemoryFunction);
     s_adjustAmountOfExternalAllocatedMemoryFunction = function;
   }
 
  private:
-  static void allocateMemoryWithFlags(size_t,
-                                      InitializationPolicy,
-                                      int,
-                                      void*&);
+  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(void* data, unsigned sizeInBytes, SharingType isShared);
+    void adopt(ScopedData, unsigned sizeInBytes, SharingType isShared);
     void copyMemoryFrom(const DataHolder& source);
 
-    const void* data() const { return m_data; }
-    void* data() { return m_data; }
+    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; }
 
    private:
     void adjustAmountOfExternalAllocatedMemory(int64_t diff) {
       checkIfAdjustAmountOfExternalAllocatedMemoryIsConsistent();
       s_adjustAmountOfExternalAllocatedMemoryFunction(diff);
     }
     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
     }
 
-    void* m_data;
+    ScopedData m_data;
     unsigned m_sizeInBytes;
     SharingType m_isShared;
   };
 
   RefPtr<DataHolder> m_holder;
   static AdjustAmountOfExternalAllocatedMemoryFunction
       s_adjustAmountOfExternalAllocatedMemoryFunction;
 #if DCHECK_IS_ON()
   static AdjustAmountOfExternalAllocatedMemoryFunction
       s_lastUsedAdjustAmountOfExternalAllocatedMemoryFunction;
 #endif
 };
 
 }  // namespace WTF
 
 #endif  // ArrayBufferContents_h