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

src/wasm/module-decoder.cc

 // Copyright 2015 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 "src/wasm/module-decoder.h"
 
 #include "src/base/functional.h"
 #include "src/base/platform/platform.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
@@ skipping 26 matching lines @@
     if (limit_ < start_) {
       error(start_, "end is less than start");
       limit_ = start_;
     }
   }
 
   virtual void onFirstError() {
     pc_ = limit_;  // On error, terminate section decoding loop.
   }
 
-  static void DumpModule(WasmModule* module, ModuleResult result) {
+  static void DumpModule(WasmModule* module, const ModuleResult& result) {
     std::string path;
     if (FLAG_dump_wasm_module_path) {
       path = FLAG_dump_wasm_module_path;
       if (path.size() &&
           !base::OS::isDirectorySeparator(path[path.size() - 1])) {
         path += base::OS::DirectorySeparator();
       }
     }
     // File are named `HASH.{ok,failed}.wasm`.
     size_t hash = base::hash_range(module->module_start, module->module_end);
@@ skipping 498 matching lines @@
       str << result;
       std::string strval = str.str();
       const char* raw = strval.c_str();
       size_t len = strlen(raw);
       char* buffer = new char[len];
       strncpy(buffer, raw, len);
       buffer[len - 1] = 0;
 
       // Copy error code and location.
       result_.CopyFrom(result);
-      result_.error_msg.Reset(buffer);
+      result_.error_msg.reset(buffer);
     }
   }
 
   // Reads a single 32-bit unsigned integer interpreted as an offset, checking
   // the offset is within bounds and advances.
   uint32_t consume_offset(const char* name = nullptr) {
     uint32_t offset = consume_u32(name ? name : "offset");
     if (offset > static_cast<uint32_t>(limit_ - start_)) {
       error(pc_ - sizeof(uint32_t), "offset out of bounds of module");
     }
@@ skipping 106 matching lines @@
 
 // Helpers for nice error messages.
 class ModuleError : public ModuleResult {
  public:
   explicit ModuleError(const char* msg) {
     error_code = kError;
     size_t len = strlen(msg) + 1;
     char* result = new char[len];
     strncpy(result, msg, len);
     result[len - 1] = 0;
-    error_msg.Reset(result);
+    error_msg.reset(result);
   }
 };
 
 // Helpers for nice error messages.
 class FunctionError : public FunctionResult {
  public:
   explicit FunctionError(const char* msg) {
     error_code = kError;
     size_t len = strlen(msg) + 1;
     char* result = new char[len];
     strncpy(result, msg, len);
     result[len - 1] = 0;
-    error_msg.Reset(result);
+    error_msg.reset(result);
   }
 };
 
 Vector<const byte> FindSection(const byte* module_start, const byte* module_end,
                                WasmSection::Code code) {
   Decoder decoder(module_start, module_end);
 
   uint32_t magic_word = decoder.consume_u32("wasm magic");
   if (magic_word != kWasmMagic) decoder.error("wrong magic word");
 
@@ skipping 91 matching lines @@
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8