[wasm] Enable content policy for wasm compilation.

test/cctest/wasm/test-run-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 <stdlib.h>
 #include <string.h>
 
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
 #include "src/wasm/module-decoder.h"
@@ skipping 200 matching lines @@
 }
 
 // Approximate gtest TEST_F style, in case we adopt gtest.
 class WasmSerializationTest {
  public:
   WasmSerializationTest() : zone_(&allocator_, ZONE_NAME) {
     // Don't call here if we move to gtest.
     SetUp();
   }
 
+  static void BuildWireBytes(Zone* zone, ZoneBuffer* buffer) {
+    WasmModuleBuilder* builder = new (zone) WasmModuleBuilder(zone);
+    TestSignatures sigs;
+
+    WasmFunctionBuilder* f = builder->AddFunction(sigs.i_i());
+    byte code[] = {WASM_GET_LOCAL(0), kExprI32Const, 1, kExprI32Add};
+    EMIT_CODE_WITH_END(f, code);
+    f->ExportAs(CStrVector(kFunctionName));
+
+    builder->WriteTo(*buffer);
+  }
+
   void ClearSerializedData() {
     serialized_bytes_.first = nullptr;
     serialized_bytes_.second = 0;
   }
 
   void InvalidateVersion() {
     uint32_t* buffer = reinterpret_cast<uint32_t*>(
         const_cast<uint8_t*>(serialized_bytes_.first));
     buffer[SerializedCodeData::kVersionHashOffset] = Version::Hash() + 1;
   }
@@ skipping 41 matching lines @@
 
   Isolate* current_isolate() {
     return reinterpret_cast<Isolate*>(current_isolate_v8_);
   }
 
   ~WasmSerializationTest() {
     // Don't call from here if we move to gtest
     TearDown();
   }
 
+  v8::Isolate* current_isolate_v8() { return current_isolate_v8_; }
+
  private:
   static const char* kFunctionName;
 
   Zone* zone() { return &zone_; }
   const v8::WasmCompiledModule::CallerOwnedBuffer& wire_bytes() const {
     return wire_bytes_;
   }
 
   const v8::WasmCompiledModule::CallerOwnedBuffer& serialized_bytes() const {
     return serialized_bytes_;
   }
 
-  v8::Isolate* current_isolate_v8() { return current_isolate_v8_; }
-
   void SetUp() {
-    WasmModuleBuilder* builder = new (zone()) WasmModuleBuilder(zone());
-    TestSignatures sigs;
-
-    WasmFunctionBuilder* f = builder->AddFunction(sigs.i_i());
-    byte code[] = {WASM_GET_LOCAL(0), kExprI32Const, 1, kExprI32Add};
-    EMIT_CODE_WITH_END(f, code);
-    f->ExportAs(CStrVector(kFunctionName));
-
     ZoneBuffer buffer(&zone_);
-    builder->WriteTo(buffer);
+    WasmSerializationTest::BuildWireBytes(zone(), &buffer);
 
     Isolate* serialization_isolate = CcTest::InitIsolateOnce();
     ErrorThrower thrower(serialization_isolate, "");
     uint8_t* bytes = nullptr;
     size_t bytes_size = 0;
     {
       HandleScope scope(serialization_isolate);
       testing::SetupIsolateForWasmModule(serialization_isolate);
 
       ModuleResult decoding_result =
@@ skipping 95 matching lines @@
   {
     HandleScope scope(test.current_isolate());
     test.InvalidateVersion();
     test.InvalidateWireBytes();
     test.Deserialize();
   }
   Cleanup(test.current_isolate());
   Cleanup();
 }
 
+bool False(v8::Local<v8::Context> context) { return false; }
+
+TEST(BlockWasmCodeGen) {
+  v8::internal::AccountingAllocator allocator;
+  Zone zone(&allocator, ZONE_NAME);
+  ZoneBuffer buffer(&zone);
+  WasmSerializationTest::BuildWireBytes(&zone, &buffer);
+  Isolate* isolate = CcTest::InitIsolateOnce();
+  HandleScope scope(isolate);
+  testing::SetupIsolateForWasmModule(isolate);
+  CcTest::isolate()->SetAllowCodeGenerationFromStringsCallback(False);
+
+  ErrorThrower thrower(isolate, "block codegen");
+  MaybeHandle<WasmModuleObject> ret = wasm::CreateModuleObjectFromBytes(
+      isolate, buffer.begin(), buffer.end(), &thrower,
+      wasm::ModuleOrigin::kWasmOrigin, Handle<v8::internal::Script>::null(),
+      Vector<const byte>::empty());
+  CcTest::isolate()->SetAllowCodeGenerationFromStringsCallback(nullptr);
+  CHECK(ret.is_null());
+  CHECK(thrower.error());
+}
+
+TEST(BlockWasmCodeGenAtDeserialization) {
+  WasmSerializationTest test;
+  {
+    HandleScope scope(test.current_isolate());
+    test.current_isolate_v8()->SetAllowCodeGenerationFromStringsCallback(False);
+    v8::MaybeLocal<v8::WasmCompiledModule> nothing = test.Deserialize();
+    CHECK(nothing.IsEmpty());
+  }
+  Cleanup(test.current_isolate());
+  Cleanup();
+}
+
 TEST(MemorySize) {
   {
     // Initial memory size is 16, see wasm-module-builder.cc
     static const int kExpectedValue = 16;
     TestSignatures sigs;
     v8::internal::AccountingAllocator allocator;
     Zone zone(&allocator, ZONE_NAME);
 
     WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
     WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
@@ skipping 485 matching lines @@
     };
 
     testing::CompileInstantiateWasmModuleForTesting(isolate, &thrower, data,
                                                     data + arraysize(data),
                                                     ModuleOrigin::kWasmOrigin);
     // It should be possible to instantiate this module.
     CHECK(!thrower.error());
   }
   Cleanup();
 }