Provide a convenience array buffer allocator

test/cctest/interpreter/generate-bytecode-expectations.cc

 // Copyright 2016 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.
 
 #include <cstring>
 #include <fstream>
 #include <vector>
 
 #include "test/cctest/interpreter/bytecode-expectations-printer.h"
 
@@ skipping 75 matching lines @@
   bool top_level_;
   bool do_expressions_;
   bool ignition_generators_;
   bool verbose_;
   BytecodeExpectationsPrinter::ConstantPoolType const_pool_type_;
   std::vector<std::string> input_filenames_;
   std::string output_filename_;
   std::string test_function_name_;
 };
 
-class ArrayBufferAllocator final : public v8::ArrayBuffer::Allocator {
- public:
-  void* Allocate(size_t length) override {
-    void* data = AllocateUninitialized(length);
-    if (data != nullptr) memset(data, 0, length);
-    return data;
-  }
-  void* AllocateUninitialized(size_t length) override { return malloc(length); }
-  void Free(void* data, size_t) override { free(data); }
-};
-
 class V8InitializationScope final {
  public:
   explicit V8InitializationScope(const char* exec_path);
   ~V8InitializationScope();
 
   v8::Platform* platform() const { return platform_.get(); }
   v8::Isolate* isolate() const { return isolate_; }
 
  private:
   v8::base::SmartPointer<v8::Platform> platform_;
+  v8::base::SmartPointer<v8::ArrayBuffer::Allocator> allocator_;
   v8::Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(V8InitializationScope);
 };
 
 BytecodeExpectationsPrinter::ConstantPoolType ParseConstantPoolType(
     const char* type_string) {
   if (strcmp(type_string, "number") == 0) {
     return BytecodeExpectationsPrinter::ConstantPoolType::kNumber;
   } else if (strcmp(type_string, "string") == 0) {
@@ skipping 229 matching lines @@
     : platform_(v8::platform::CreateDefaultPlatform()) {
   i::FLAG_ignition = true;
   i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
 
   v8::V8::InitializeICUDefaultLocation(exec_path);
   v8::V8::InitializeExternalStartupData(exec_path);
   v8::V8::InitializePlatform(platform_.get());
   v8::V8::Initialize();
 
-  ArrayBufferAllocator allocator;
   v8::Isolate::CreateParams create_params;
-  create_params.array_buffer_allocator = &allocator;
+  allocator_.Reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
+  create_params.array_buffer_allocator = allocator_.get();
 
   isolate_ = v8::Isolate::New(create_params);
 }
 
 V8InitializationScope::~V8InitializationScope() {
   isolate_->Dispose();
   v8::V8::Dispose();
   v8::V8::ShutdownPlatform();
 }
 
@@ skipping 196 matching lines @@
     }
   }
 
   if (!options.rebaseline()) {
     if (!WriteExpectationsFile(snippet_list, platform, options,
                                options.output_filename())) {
       return 3;
     }
   }
 }