Pass ArrayBuffer::Allocator via Isolate::CreateParams

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 3218 matching lines @@
 
 
 /**
  * An instance of the built-in ArrayBuffer constructor (ES6 draft 15.13.5).
  * This API is experimental and may change significantly.
  */
 class V8_EXPORT ArrayBuffer : public Object {
  public:
   /**
    * Allocator that V8 uses to allocate |ArrayBuffer|'s memory.
-   * The allocator is a global V8 setting. It should be set with
-   * V8::SetArrayBufferAllocator prior to creation of a first ArrayBuffer.
+   * The allocator is a global V8 setting. It has to be set via
+   * Isolate::CreateParams.
    *
    * This API is experimental and may change significantly.
    */
   class V8_EXPORT Allocator { // NOLINT
    public:
     virtual ~Allocator() {}
 
     /**
      * Allocate |length| bytes. Return NULL if allocation is not successful.
      * Memory should be initialized to zeroes.
@@ skipping 11 matching lines @@
      */
     virtual void Free(void* data, size_t length) = 0;
   };
 
   /**
    * The contents of an |ArrayBuffer|. Externalization of |ArrayBuffer|
    * returns an instance of this class, populated, with a pointer to data
    * and byte length.
    *
    * The Data pointer of ArrayBuffer::Contents is always allocated with
-   * Allocator::Allocate that is set with V8::SetArrayBufferAllocator.
+   * Allocator::Allocate that is set via Isolate::CreateParams.
    *
    * This API is experimental and may change significantly.
    */
   class V8_EXPORT Contents { // NOLINT
    public:
     Contents() : data_(NULL), byte_length_(0) {}
 
     void* Data() const { return data_; }
     size_t ByteLength() const { return byte_length_; }
 
@@ skipping 47 matching lines @@
    */
   void Neuter();
 
   /**
    * Make this ArrayBuffer external. The pointer to underlying memory block
    * and byte length are returned as |Contents| structure. After ArrayBuffer
    * had been etxrenalized, it does no longer owns the memory block. The caller
    * should take steps to free memory when it is no longer needed.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|
-   * that has been set with V8::SetArrayBufferAllocator.
+   * that has been set via Isolate::CreateParams.
    */
   Contents Externalize();
 
   /**
    * Get a pointer to the ArrayBuffer's underlying memory block without
    * externalizing it. If the ArrayBuffer is not externalized, this pointer
    * will become invalid as soon as the ArrayBuffer became garbage collected.
    *
    * The embedder should make sure to hold a strong reference to the
    * ArrayBuffer while accessing this pointer.
@@ skipping 1595 matching lines @@
   /**
    * Initial configuration parameters for a new Isolate.
    */
   struct CreateParams {
     CreateParams()
         : entry_hook(NULL),
           code_event_handler(NULL),
           snapshot_blob(NULL),
           counter_lookup_callback(NULL),
           create_histogram_callback(NULL),
-          add_histogram_sample_callback(NULL) {}
+          add_histogram_sample_callback(NULL),
+          array_buffer_allocator(NULL) {}
 
     /**
      * The optional entry_hook allows the host application to provide the
      * address of a function that's invoked on entry to every V8-generated
      * function.  Note that entry_hook is invoked at the very start of each
      * generated function. Furthermore, if an  entry_hook is given, V8 will
      * always run without a context snapshot.
      */
     FunctionEntryHook entry_hook;
 
@@ skipping 21 matching lines @@
     CounterLookupCallback counter_lookup_callback;
 
     /**
      * Enables the host application to provide a mechanism for recording
      * histograms. The CreateHistogram function returns a
      * histogram which will later be passed to the AddHistogramSample
      * function.
      */
     CreateHistogramCallback create_histogram_callback;
     AddHistogramSampleCallback add_histogram_sample_callback;
+
+    /**
+     * The ArrayBuffer::Allocator to use for allocating and freeing the backing
+     * store of ArrayBuffers.
+     */
+    ArrayBuffer::Allocator* array_buffer_allocator;
   };
 
 
   /**
    * Stack-allocated class which sets the isolate for all operations
    * executed within a local scope.
    */
   class V8_EXPORT Scope {
    public:
     explicit Scope(Isolate* isolate) : isolate_(isolate) {
@@ skipping 99 matching lines @@
 
   /**
    * Creates a new isolate.  Does not change the currently entered
    * isolate.
    *
    * When an isolate is no longer used its resources should be freed
    * by calling Dispose().  Using the delete operator is not allowed.
    *
    * V8::Initialize() must have run prior to this.
    */
-  static Isolate* New(const CreateParams& params = CreateParams());
+  static Isolate* New(const CreateParams& params);
+
+  static V8_DEPRECATED("Always pass CreateParams", Isolate* New());
 
   /**
    * Returns the entered isolate for the current thread or NULL in
    * case there is no current isolate.
    *
    * This method must not be invoked before V8::Initialize() was invoked.
    */
   static Isolate* GetCurrent();
 
   /**
@@ skipping 569 matching lines @@
   V8_INLINE static V8_DEPRECATE_SOON(
       "Use isolate version", void SetAllowCodeGenerationFromStringsCallback(
                                  AllowCodeGenerationFromStringsCallback that));
 
   /**
    * Set allocator to use for ArrayBuffer memory.
    * The allocator should be set only once. The allocator should be set
    * before any code tha uses ArrayBuffers is executed.
    * This allocator is used in all isolates.
    */
-  static void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator);
+  static V8_DEPRECATE_SOON(
+      "Use isolate version",
+      void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator));
 
   /**
   * Check if V8 is dead and therefore unusable.  This is the case after
   * fatal errors such as out-of-memory situations.
   */
   V8_INLINE static V8_DEPRECATE_SOON("no alternative", bool IsDead());
 
   /**
    * Hand startup data to V8, in case the embedder has chosen to build
    * V8 with external startup data.
@@ skipping 2290 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_