Hide WasmModule.origin field behind readable accessors.

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 80 matching lines @@
     instance->globals_start = global_data;
     module_.globals_size = kMaxGlobalsSize;
     instance->mem_start = nullptr;
     instance->mem_size = 0;
     memset(global_data, 0, sizeof(global_data));
     instance_object_ = InitInstanceObject();
   }
 
   ~TestingModule() {
     if (instance->mem_start) {
-      if (EnableGuardRegions() && module_.origin == kWasmOrigin) {
+      if (EnableGuardRegions() && module_.is_wasm()) {
         // See the corresponding code in AddMemory. We use a different
         // allocation path when guard regions are enabled, which means we have
         // to free it differently too.
         const size_t alloc_size =
             RoundUp(kWasmMaxHeapOffset, v8::base::OS::CommitPageSize());
         v8::base::OS::Free(instance->mem_start, alloc_size);
       } else {
         free(instance->mem_start);
       }
     }
     if (interpreter_) delete interpreter_;
   }
 
-  void ChangeOriginToAsmjs() { module_.origin = kAsmJsOrigin; }
+  void ChangeOriginToAsmjs() { module_.set_origin(kAsmJsOrigin); }
 
   byte* AddMemory(uint32_t size) {
     CHECK(!module_.has_memory);
     CHECK_NULL(instance->mem_start);
     CHECK_EQ(0, instance->mem_size);
     module_.has_memory = true;
-    if (EnableGuardRegions() && module_.origin == kWasmOrigin) {
+    if (EnableGuardRegions() && module_.is_wasm()) {
       const size_t alloc_size =
           RoundUp(kWasmMaxHeapOffset, v8::base::OS::CommitPageSize());
       instance->mem_start = reinterpret_cast<byte*>(
           v8::base::OS::AllocateGuarded(alloc_size * 2));
       instance->mem_start += alloc_size;
       const size_t guard_size = RoundUp(size, v8::base::OS::CommitPageSize());
       v8::base::OS::Unprotect(instance->mem_start, guard_size);
     } else {
       instance->mem_start = reinterpret_cast<byte*>(malloc(size));
     }
@@ skipping 95 matching lines @@
     DCHECK_LT(index, kMaxFunctions);  // limited for testing.
     return index;
   }
 
   uint32_t AddJsFunction(FunctionSig* sig, const char* source) {
     Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
         *v8::Local<v8::Function>::Cast(CompileRun(source))));
     uint32_t index = AddFunction(sig, Handle<Code>::null(), nullptr);
     Handle<Code> code = CompileWasmToJSWrapper(
         isolate_, jsfunc, sig, index, Handle<String>::null(),
-        Handle<String>::null(), module->origin);
+        Handle<String>::null(), module->get_origin());
     instance->function_code[index] = code;
     return index;
   }
 
   Handle<JSFunction> WrapCode(uint32_t index) {
     // Wrap the code so it can be called as a JS function.
     Handle<Code> code = instance->function_code[index];
     Handle<Code> ret_code =
         compiler::CompileJSToWasmWrapper(isolate_, &module_, code, index);
     Handle<JSFunction> ret = WasmExportedFunction::New(
@@ skipping 613 matching lines @@
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 #define WASM_EXEC_COMPILED_TEST(name)                                \
   void RunWasm_##name(WasmExecutionMode execution_mode);             \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif