Replace SmartArrayPointer<T> with unique_ptr<T[]>

test/cctest/wasm/test-run-wasm-interpreter.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <memory>
+
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "src/wasm/wasm-interpreter.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/test-signatures.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
 using namespace v8::base;
@@ skipping 112 matching lines @@
 
   CHECK_EQ(11, r.Call(1, 1));
   CHECK_EQ(12, r.Call(1, 0));
   CHECK_EQ(13, r.Call(0, 1));
   CHECK_EQ(14, r.Call(0, 0));
 }
 
 // Make tests more robust by not hard-coding offsets of various operations.
 // The {Find} method finds the offsets for the given bytecodes, returning
 // the offsets in an array.
-SmartArrayPointer<int> Find(byte* code, size_t code_size, int n, ...) {
+std::unique_ptr<int[]> Find(byte* code, size_t code_size, int n, ...) {
   va_list vl;
   va_start(vl, n);
 
-  SmartArrayPointer<int> offsets(new int[n]);
+  std::unique_ptr<int[]> offsets(new int[n]);
 
   for (int i = 0; i < n; i++) {
     offsets[i] = -1;
   }
 
   int pos = 0;
   WasmOpcode current = static_cast<WasmOpcode>(va_arg(vl, int));
   for (size_t i = 0; i < code_size; i++) {
     if (code[i] == current) {
       offsets[pos++] = static_cast<int>(i);
       if (pos == n) break;
       current = static_cast<WasmOpcode>(va_arg(vl, int));
     }
   }
   va_end(vl);
 
   return offsets;
 }
 
 TEST(Breakpoint_I32Add) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 3;
   byte code[] = {WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
-  SmartArrayPointer<int> offsets =
+  std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
            kExprI32Add);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
@@ skipping 58 matching lines @@
       uint32_t expected = (*a) * (b);
       CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
     }
   }
 }
 
 TEST(Breakpoint_I32And_disable) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 1;
   byte code[] = {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
-  SmartArrayPointer<int> offsets =
+  std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
@@ skipping 21 matching lines @@
         uint32_t expected = (*a) & (b);
         CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
       }
     }
   }
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8