Named all zones in the project

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 1603 matching lines @@
         if (target->kind() == Code::WASM_FUNCTION) {
           ++wasm_count;
           code = handle(target);
         }
       }
       DCHECK(wasm_count == 1);
       return code;
     } else {
       // Copy the signature to avoid a raw pointer into a heap object when
       // GC can happen.
-      Zone zone(isolate_->allocator());
+      Zone zone(isolate_->allocator(), ZONE_NAME);
       MachineRepresentation* reps =
           zone.NewArray<MachineRepresentation>(sig_data_size);
       memcpy(reps, sig_data->GetDataStartAddress(),
              sizeof(MachineRepresentation) * sig_data_size);
       FunctionSig sig(ret_count, param_count, reps);
 
       return compiler::CompileWasmToJSWrapper(isolate_, target, &sig, index,
                                               module_name, import_name);
     }
   }
@@ skipping 489 matching lines @@
   return module_obj;
 }
 
 // TODO(clemensh): origin can be inferred from asm_js_script; remove it.
 MaybeHandle<JSObject> wasm::CreateModuleObjectFromBytes(
     Isolate* isolate, const byte* start, const byte* end, ErrorThrower* thrower,
     ModuleOrigin origin, Handle<Script> asm_js_script,
     const byte* asm_js_offset_tables_start,
     const byte* asm_js_offset_tables_end) {
   MaybeHandle<JSObject> nothing;
-  Zone zone(isolate->allocator());
+  Zone zone(isolate->allocator(), ZONE_NAME);
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   std::unique_ptr<const WasmModule> decoded_module(result.val);
   if (result.failed()) {
     thrower->CompileFailed("Wasm decoding failed", result);
     return nothing;
   }
   MaybeHandle<WasmCompiledModule> maybe_compiled_module =
       decoded_module->CompileFunctions(isolate, thrower);
   if (maybe_compiled_module.is_null()) return nothing;
@@ skipping 14 matching lines @@
            offset_tables_len);
     compiled_module->set_asm_js_offset_tables(offset_tables);
   }
 
   return CreateCompiledModuleObject(isolate, compiled_module, origin);
 }
 
 bool wasm::ValidateModuleBytes(Isolate* isolate, const byte* start,
                                const byte* end, ErrorThrower* thrower,
                                ModuleOrigin origin) {
-  Zone zone(isolate->allocator());
+  Zone zone(isolate->allocator(), ZONE_NAME);
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   if (result.ok()) {
     DCHECK_NOT_NULL(result.val);
     delete result.val;
     return true;
   }
   return false;
 }
 
@@ skipping 114 matching lines @@
 }
 
 void testing::ValidateOrphanedInstance(Isolate* isolate,
                                        Handle<JSObject> instance) {
   DisallowHeapAllocation no_gc;
   CHECK(IsWasmObject(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }