[wasm] No need to use multiple inheritance for `ModuleBytesEnv`

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/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 303 matching lines @@
     }
     int j = unit->index();
     results[j] = unit->FinishCompilation();
     delete unit;
   }
 }
 
 void CompileInParallel(Isolate* isolate, ModuleBytesEnv* module_env,
                        std::vector<Handle<Code>>& functions,
                        ErrorThrower* thrower) {
-  const WasmModule* module = module_env->module;
+  const WasmModule* module = module_env->module_env.module;
   // Data structures for the parallel compilation.
   std::vector<compiler::WasmCompilationUnit*> compilation_units(
       module->functions.size());
   std::queue<compiler::WasmCompilationUnit*> executed_units;
 
   //-----------------------------------------------------------------------
   // For parallel compilation:
   // 1) The main thread allocates a compilation unit for each wasm function
   //    and stores them in the vector {compilation_units}.
   // 2) The main thread spawns {WasmCompilationTask} instances which run on
@@ skipping 46 matching lines @@
   WaitForCompilationTasks(isolate, task_ids.get(), module->pending_tasks.get());
   // Finish the compilation of the remaining compilation units.
   FinishCompilationUnits(executed_units, functions, result_mutex);
 }
 
 void CompileSequentially(Isolate* isolate, ModuleBytesEnv* module_env,
                          std::vector<Handle<Code>>& functions,
                          ErrorThrower* thrower) {
   DCHECK(!thrower->error());
 
-  const WasmModule* module = module_env->module;
+  const WasmModule* module = module_env->module_env.module;
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
        i < module->functions.size(); ++i) {
     const WasmFunction& func = module->functions[i];
     if (func.imported) continue;  // Imports are compiled at instantiation time.
 
     Handle<Code> code = Handle<Code>::null();
     // Compile the function.
     code = compiler::WasmCompilationUnit::CompileWasmFunction(
         thrower, isolate, module_env, &func);
     if (code.is_null()) {
-      WasmName str = module_env->GetName(&func);
+      WasmName str = module_env->wire_bytes.GetName(&func);
       thrower->CompileError("Compilation of #%d:%.*s failed.", i, str.length(),
                             str.start());
       break;
     }
     // Install the code into the linker table.
     functions[i] = code;
   }
 }
 
 int ExtractDirectCallIndex(wasm::Decoder& decoder, const byte* pc) {
@@ skipping 310 matching lines @@
 
 Handle<Script> CreateWasmScript(Isolate* isolate,
                                 const ModuleWireBytes& wire_bytes) {
   Handle<Script> script =
       isolate->factory()->NewScript(isolate->factory()->empty_string());
   FixedArray* array = isolate->native_context()->embedder_data();
   script->set_context_data(array->get(v8::Context::kDebugIdIndex));
   script->set_type(Script::TYPE_WASM);
 
   int hash = StringHasher::HashSequentialString(
-      reinterpret_cast<const char*>(wire_bytes.module_bytes.start()),
-      wire_bytes.module_bytes.length(), kZeroHashSeed);
+      reinterpret_cast<const char*>(wire_bytes.start()), wire_bytes.length(),
+      kZeroHashSeed);
 
   const int kBufferSize = 50;
   char buffer[kBufferSize];
   int url_chars = SNPrintF(ArrayVector(buffer), "wasm://wasm/%08x", hash);
   DCHECK(url_chars >= 0 && url_chars < kBufferSize);
   MaybeHandle<String> url_str = isolate->factory()->NewStringFromOneByte(
       Vector<const uint8_t>(reinterpret_cast<uint8_t*>(buffer), url_chars),
       TENURED);
   script->set_source_url(*url_str.ToHandleChecked());
 
@@ skipping 218 matching lines @@
   } else {
     script = asm_js_script;
     asm_js_offset_table =
         isolate->factory()->NewByteArray(asm_js_offset_table_bytes.length());
     asm_js_offset_table->copy_in(0, asm_js_offset_table_bytes.start(),
                                  asm_js_offset_table_bytes.length());
   }
   // TODO(wasm): only save the sections necessary to deserialize a
   // {WasmModule}. E.g. function bodies could be omitted.
   Handle<String> module_bytes =
-      factory->NewStringFromOneByte(wire_bytes.module_bytes, TENURED)
+      factory
+          ->NewStringFromOneByte({wire_bytes.start(), wire_bytes.length()},
+                                 TENURED)
           .ToHandleChecked();
   DCHECK(module_bytes->IsSeqOneByteString());
 
   // Create the shared module data.
   // TODO(clemensh): For the same module (same bytes / same hash), we should
   // only have one WasmSharedModuleData. Otherwise, we might only set
   // breakpoints on a (potentially empty) subset of the instances.
 
   Handle<WasmSharedModuleData> shared = WasmSharedModuleData::New(
       isolate, module_wrapper, Handle<SeqOneByteString>::cast(module_bytes),
@@ skipping 1697 matching lines @@
 
     JSObject::AddProperty(entry, name_string, export_name.ToHandleChecked(),
                           NONE);
     JSObject::AddProperty(entry, kind_string, export_kind, NONE);
 
     storage->set(index, *entry);
   }
 
   return array_object;
 }