[wasm] C++ style: ErrorThrower& -> ErrorThrower*

src/wasm/wasm-module.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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 466 matching lines @@
       min_mem_pages(0),
       max_mem_pages(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
       origin(kWasmOrigin),
       globals_size(0),
       pending_tasks(new base::Semaphore(0)) {}
 
 static MaybeHandle<JSFunction> ReportFFIError(
-    ErrorThrower& thrower, const char* error, uint32_t index,
+    ErrorThrower* thrower, const char* error, uint32_t index,
     Handle<String> module_name, MaybeHandle<String> function_name) {
   Handle<String> function_name_handle;
   if (function_name.ToHandle(&function_name_handle)) {
-    thrower.Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
-                  index, module_name->length(), module_name->ToCString().get(),
-                  function_name_handle->length(),
-                  function_name_handle->ToCString().get(), error);
+    thrower->Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
+                   index, module_name->length(), module_name->ToCString().get(),
+                   function_name_handle->length(),
+                   function_name_handle->ToCString().get(), error);
   } else {
-    thrower.Error("Import #%d module=\"%.*s\" error: %s", index,
-                  module_name->length(), module_name->ToCString().get(), error);
+    thrower->Error("Import #%d module=\"%.*s\" error: %s", index,
+                   module_name->length(), module_name->ToCString().get(),
+                   error);
   }
-  thrower.Error("Import ");
+  thrower->Error("Import ");
   return MaybeHandle<JSFunction>();
 }
 
 static MaybeHandle<JSReceiver> LookupFunction(
-    ErrorThrower& thrower, Factory* factory, Handle<JSReceiver> ffi,
+    ErrorThrower* thrower, Factory* factory, Handle<JSReceiver> ffi,
     uint32_t index, Handle<String> module_name,
     MaybeHandle<String> function_name) {
   if (ffi.is_null()) {
     return ReportFFIError(thrower, "FFI is not an object", index, module_name,
                           function_name);
   }
 
   // Look up the module first.
   MaybeHandle<Object> result = Object::GetProperty(ffi, module_name);
   if (result.is_null()) {
@@ skipping 180 matching lines @@
       // it when we rationalize signed/unsigned stuff.
       int ret_count = Smi::cast(data->get(kOutputCount))->value();
       CHECK(ret_count >= 0);
       Handle<ByteArray> sig_data =
           data->GetValueChecked<ByteArray>(isolate, kSignature);
       int sig_data_size = sig_data->length();
       int param_count = sig_data_size - ret_count;
       CHECK(param_count >= 0);
 
       MaybeHandle<JSReceiver> function = LookupFunction(
-          *thrower, isolate->factory(), ffi, index, module_name, function_name);
+          thrower, isolate->factory(), ffi, index, module_name, function_name);
       if (function.is_null()) return false;
       Handle<Code> code;
       Handle<JSReceiver> target = function.ToHandleChecked();
       bool isMatch = false;
       Handle<Code> export_wrapper_code;
       if (target->IsJSFunction()) {
         Handle<JSFunction> func = Handle<JSFunction>::cast(target);
         export_wrapper_code = handle(func->code());
         if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
           int exported_param_count =
@@ skipping 37 matching lines @@
       }
       imports.push_back(code);
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
-    ModuleEnv& module_env, ErrorThrower& thrower) {
+    ModuleEnv& module_env, ErrorThrower* thrower) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); ++i) {
     compilation_units[i] = new compiler::WasmCompilationUnit(
-        &thrower, isolate, &module_env, &functions[i], i);
+        thrower, isolate, &module_env, &functions[i], i);
   }
 }
 
 uint32_t* StartCompilationTasks(
     Isolate* isolate,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     std::queue<compiler::WasmCompilationUnit*>& executed_units,
     base::Semaphore* pending_tasks, base::Mutex& result_mutex,
     base::AtomicNumber<size_t>& next_unit) {
   const size_t num_tasks =
@@ skipping 68 matching lines @@
   //    main thread waits for all {WasmCompilationTask} instances to finish.
   // 5) The main thread finishes the compilation.
 
   // Turn on the {CanonicalHandleScope} so that the background threads can
   // use the node cache.
   CanonicalHandleScope canonical(isolate);
 
   // 1) The main thread allocates a compilation unit for each wasm function
   //    and stores them in the vector {compilation_units}.
   InitializeParallelCompilation(isolate, module->functions, compilation_units,
-                                *module_env, *thrower);
+                                *module_env, thrower);
 
   // Objects for the synchronization with the background threads.
   base::Mutex result_mutex;
   base::AtomicNumber<size_t> next_unit(
       static_cast<size_t>(FLAG_skip_compiling_wasm_funcs));
 
   // 2) The main thread spawns {WasmCompilationTask} instances which run on
   //    the background threads.
   std::unique_ptr<uint32_t[]> task_ids(StartCompilationTasks(
       isolate, compilation_units, executed_units, module->pending_tasks.get(),
@@ skipping 1120 matching lines @@
   FixedArray* compiled_module =
       FixedArray::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK_NOT_NULL(GetModuleObject(compiled_module));
   CHECK(GetModuleObject(compiled_module)->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8