meta: merge node/master into node-chakracore/master

Merge 52e869b as of 2018-03-13
This commit was automatically generated. For any problems, please contact jackhorton

Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>

doc/STYLE_GUIDE.md

@@ -14,9 +14,8 @@
   "color" vs. "colour", etc.
 * Use [serial commas][].
 * Avoid personal pronouns in reference documentation ("I", "you", "we").
-  * Pronouns are acceptable in more colloquial documentation, like guides.
-  * Use gender-neutral pronouns and mass nouns. Non-comprehensive
-    examples:
+  * Personal pronouns are acceptable in colloquial documentation such as guides.
+  * Use gender-neutral pronouns and gender-neutral plural nouns.
     * OK: "they", "their", "them", "folks", "people", "developers"
     * NOT OK: "his", "hers", "him", "her", "guys", "dudes"
 * When combining wrapping elements (parentheses and quotes), terminal

doc/api/vm.md

@@ -495,6 +495,14 @@ added: v0.3.1
     value of the [`url.origin`][] property of a [`URL`][] object. Most notably,
     this string should omit the trailing slash, as that denotes a path.
     **Default:** `''`.
+  * `contextCodeGeneration` {Object}
+    * `strings` {boolean} If set to false any calls to `eval` or function
+      constructors (`Function`, `GeneratorFunction`, etc) will throw an
+      `EvalError`.
+      **Default**: `true`.
+    * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
+      module will throw a `WebAssembly.CompileError`.
+      **Default**: `true`.
 
 First contextifies the given `sandbox`, runs the compiled code contained by
 the `vm.Script` object within the created sandbox, and returns the result.
@@ -578,6 +586,14 @@ added: v0.3.1
     the [`url.origin`][] property of a [`URL`][] object. Most notably, this
     string should omit the trailing slash, as that denotes a path.
     **Default:** `''`.
+  * `codeGeneration` {Object}
+    * `strings` {boolean} If set to false any calls to `eval` or function
+      constructors (`Function`, `GeneratorFunction`, etc) will throw an
+      `EvalError`.
+      **Default**: `true`.
+    * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
+      module will throw a `WebAssembly.CompileError`.
+      **Default**: `true`.
 
 If given a `sandbox` object, the `vm.createContext()` method will [prepare
 that sandbox][contextified] so that it can be used in calls to

lib/vm.js

@@ -84,14 +84,36 @@ function validateString(prop, propName) {
     throw new ERR_INVALID_ARG_TYPE(propName, 'string', prop);
 }
 
+function validateBool(prop, propName) {
+  if (prop !== undefined && typeof prop !== 'boolean')
+    throw new ERR_INVALID_ARG_TYPE(propName, 'boolean', prop);
+}
+
+function validateObject(prop, propName) {
+  if (prop !== undefined && (typeof prop !== 'object' || prop === null))
+    throw new ERR_INVALID_ARG_TYPE(propName, 'Object', prop);
+}
+
 function getContextOptions(options) {
   if (options) {
+    validateObject(options.contextCodeGeneration,
+                   'options.contextCodeGeneration');
     const contextOptions = {
       name: options.contextName,
-      origin: options.contextOrigin
+      origin: options.contextOrigin,
+      codeGeneration: typeof options.contextCodeGeneration === 'object' ? {
+        strings: options.contextCodeGeneration.strings,
+        wasm: options.contextCodeGeneration.wasm,
+      } : undefined,
     };
     validateString(contextOptions.name, 'options.contextName');
     validateString(contextOptions.origin, 'options.contextOrigin');
+    if (contextOptions.codeGeneration) {
+      validateBool(contextOptions.codeGeneration.strings,
+                   'options.contextCodeGeneration.strings');
+      validateBool(contextOptions.codeGeneration.wasm,
+                   'options.contextCodeGeneration.wasm');
+    }
     return contextOptions;
   }
   return {};
@@ -109,10 +131,21 @@ function createContext(sandbox, options) {
     if (typeof options !== 'object' || options === null) {
       throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
     }
+    validateObject(options.codeGeneration, 'options.codeGeneration');
     options = {
       name: options.name,
-      origin: options.origin
+      origin: options.origin,
+      codeGeneration: typeof options.codeGeneration === 'object' ? {
+        strings: options.codeGeneration.strings,
+        wasm: options.codeGeneration.wasm,
+      } : undefined,
     };
+    if (options.codeGeneration !== undefined) {
+      validateBool(options.codeGeneration.strings,
+                   'options.codeGeneration.strings');
+      validateBool(options.codeGeneration.wasm,
+                   'options.codeGeneration.wasm');
+    }
     if (options.name === undefined) {
       options.name = `VM Context ${defaultContextNameIndex++}`;
     } else if (typeof options.name !== 'string') {

node.gyp

@@ -205,6 +205,9 @@
       'sources': [
         'src/node_main.cc'
       ],
+      'includes': [
+        'node.gypi'
+      ],
       'include_dirs': [
         'src',
       ],
@@ -235,9 +238,6 @@
         }],
         [ 'node_intermediate_lib_type=="static_library" and '
             'node_shared=="false"', {
-          'includes': [
-            'node.gypi'
-          ],
           'xcode_settings': {
             'OTHER_LDFLAGS': [
               '-Wl,-force_load,<(PRODUCT_DIR)/<(STATIC_LIB_PREFIX)'
@@ -500,19 +500,6 @@
               ],
             }],
           ],
-          'defines!': [
-            'NODE_PLATFORM="win"',
-          ],
-          'defines': [
-            'FD_SETSIZE=1024',
-            # we need to use node's preferred "win32" rather than gyp's preferred "win"
-            'NODE_PLATFORM="win32"',
-            # Stop <windows.h> from defining macros that conflict with
-            # std::min() and std::max().  We don't use <windows.h> (much)
-            # but we still inherit it from uv.h.
-            'NOMINMAX',
-            '_UNICODE=1',
-          ],
           'libraries': [ '-lpsapi.lib' ],
           'conditions': [
             # this is only necessary for chakra on windows because chakra is dynamically linked on windows
@@ -521,7 +508,6 @@
             }],
           ],
         }, { # POSIX
-          'defines': [ '__POSIX__' ],
           'sources': [ 'src/backtrace_posix.cc' ],
         }],
         [ 'node_use_etw=="true"', {

node.gypi

@@ -37,6 +37,24 @@
         'NODE_SHARED_MODE',
       ],
     }],
+    [ 'OS=="win"', {
+      'defines!': [
+        'NODE_PLATFORM="win"',
+      ],
+      'defines': [
+        'FD_SETSIZE=1024',
+        # we need to use node's preferred "win32" rather than gyp's preferred "win"
+        'NODE_PLATFORM="win32"',
+        # Stop <windows.h> from defining macros that conflict with
+        # std::min() and std::max().  We don't use <windows.h> (much)
+        # but we still inherit it from uv.h.
+        'NOMINMAX',
+        '_UNICODE=1',
+      ],
+    }, { # POSIX
+      'defines': [ '__POSIX__' ],
+    }],
+
     [ 'node_enable_d8=="true"', {
       'dependencies': [ 'deps/v8/src/d8.gyp:d8' ],
     }],

src/node.cc

@@ -28,6 +28,7 @@
 #include "node_revert.h"
 #include "node_debug_options.h"
 #include "node_perf.h"
+#include "node_context_data.h"
 
 #if defined HAVE_PERFCTR
 #include "node_counters.h"
@@ -4577,6 +4578,8 @@ Local<Context> NewContext(Isolate* isolate,
   HandleScope handle_scope(isolate);
   auto intl_key = FIXED_ONE_BYTE_STRING(isolate, "Intl");
   auto break_iter_key = FIXED_ONE_BYTE_STRING(isolate, "v8BreakIterator");
+  context->SetEmbedderData(
+      ContextEmbedderIndex::kAllowWasmCodeGeneration, True(isolate));
   Local<Value> intl_v;
   if (context->Global()->Get(context, intl_key).ToLocal(&intl_v) &&
       intl_v->IsObject()) {
@@ -4686,6 +4689,13 @@ inline int Start(Isolate* isolate, void* isolate_context,
   return exit_code;
 }
 
+bool AllowWasmCodeGenerationCallback(
+    Local<Context> context, Local<String>) {
+  Local<Value> wasm_code_gen =
+    context->GetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration);
+  return wasm_code_gen->IsUndefined() || wasm_code_gen->IsTrue();
+}
+
 inline int Start(uv_loop_t* event_loop,
                  int argc, const char* const* argv,
                  int exec_argc, const char* const* exec_argv) {
@@ -4718,6 +4728,7 @@ inline int Start(uv_loop_t* event_loop,
   isolate->SetAbortOnUncaughtExceptionCallback(ShouldAbortOnUncaughtException);
   isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
   isolate->SetFatalErrorHandler(OnFatalError);
+  isolate->SetAllowWasmCodeGenerationCallback(AllowWasmCodeGenerationCallback);
 
   {
     Mutex::ScopedLock scoped_lock(node_isolate_mutex);

src/node_context_data.h

@@ -15,9 +15,14 @@ namespace node {
 #define NODE_CONTEXT_SANDBOX_OBJECT_INDEX 33
 #endif
 
+#ifndef NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX
+#define NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX 34
+#endif
+
 enum ContextEmbedderIndex {
   kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
   kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
+  kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
 };
 
 }  // namespace node

src/node_contextify.cc

@@ -190,6 +190,30 @@ Local<Context> ContextifyContext::CreateV8Context(
   CHECK(name->IsString());
   Utf8Value name_val(env->isolate(), name);
 
+  Local<Value> codegen = options_obj->Get(env->context(),
+      FIXED_ONE_BYTE_STRING(env->isolate(), "codeGeneration"))
+          .ToLocalChecked();
+
+  if (!codegen->IsUndefined()) {
+    CHECK(codegen->IsObject());
+    Local<Object> codegen_obj = codegen.As<Object>();
+
+    Local<Value> allow_code_gen_from_strings =
+      codegen_obj->Get(env->context(),
+          FIXED_ONE_BYTE_STRING(env->isolate(), "strings"))
+      .ToLocalChecked();
+    ctx->AllowCodeGenerationFromStrings(
+        allow_code_gen_from_strings->IsUndefined() ||
+            allow_code_gen_from_strings->IsTrue());
+
+    Local<Value> allow_wasm_code_gen = codegen_obj->Get(env->context(),
+        FIXED_ONE_BYTE_STRING(env->isolate(), "wasm"))
+      .ToLocalChecked();
+    ctx->SetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration,
+        Boolean::New(env->isolate(), allow_wasm_code_gen->IsUndefined() ||
+            allow_wasm_code_gen->IsTrue()));
+  }
+
   ContextInfo info(*name_val);
 
   Local<Value> origin =

src/node_contextify.h

@@ -24,6 +24,9 @@ class ContextifyContext {
       v8::Local<v8::Object> sandbox_obj, v8::Local<v8::Object> options_obj);
   static void Init(Environment* env, v8::Local<v8::Object> target);
 
+  static bool AllowWasmCodeGeneration(
+      v8::Local<v8::Context> context, v8::Local<v8::String>);
+
   static ContextifyContext* ContextFromContextifiedSandbox(
       Environment* env,
       const v8::Local<v8::Object>& sandbox);

src/node_main.cc

@@ -82,12 +82,30 @@ int wmain(int argc, wchar_t *wargv[]) {
 #endif  // __LP64__
 extern char** environ;
 #endif  // __linux__
+#if defined(__POSIX__) && defined(NODE_SHARED_MODE)
+#include <string.h>
+#include <signal.h>
+#endif
 
 namespace node {
   extern bool linux_at_secure;
 }  // namespace node
 
 int main(int argc, char *argv[]) {
+#if defined(__POSIX__) && defined(NODE_SHARED_MODE)
+  // In node::PlatformInit(), we squash all signal handlers for non-shared lib
+  // build. In order to run test cases against shared lib build, we also need
+  // to do the same thing for shared lib build here, but only for SIGPIPE for
+  // now. If node::PlatformInit() is moved to here, then this section could be
+  // removed.
+  {
+    struct sigaction act;
+    memset(&act, 0, sizeof(act));
+    act.sa_handler = SIG_IGN;
+    sigaction(SIGPIPE, &act, nullptr);
+  }
+#endif
+
 #if defined(__linux__)
   char** envp = environ;
   while (*envp++ != nullptr) {}

test/addons-napi/test_new_target/binding.c

@@ -37,7 +37,7 @@ napi_value Constructor(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL");
   NAPI_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result));
   NAPI_ASSERT(env, !result, "new.target !== undefined");
-  
+
   // arguments[0] should be Constructor itself (test harness passed it)
   NAPI_CALL(env, napi_strict_equals(env, newTargetArg, argv, &result));
   NAPI_ASSERT(env, result, "new.target === Constructor");