[Compiler] Ensure we enter the correct context for compiler-dispatcher jobs.

test/unittests/compiler-dispatcher/compiler-dispatcher-unittest.cc

 // 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.
 
 #include "src/compiler-dispatcher/compiler-dispatcher.h"
 
 #include "include/v8-platform.h"
 #include "src/base/platform/semaphore.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
 #include "src/compiler.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/objects-inl.h"
 #include "src/parsing/parse-info.h"
 #include "src/v8.h"
 #include "test/unittests/compiler-dispatcher/compiler-dispatcher-helper.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace internal {
 
+class CompilerDispatcherTestFlags {
+ public:
+  static void SetFlagsForTest() {
+    old_compiler_dispatcher_flag_ = i::FLAG_compiler_dispatcher;
+    i::FLAG_compiler_dispatcher = true;
+    old_ignition_flag_ = i::FLAG_ignition;
+    i::FLAG_ignition = true;
+    old_allow_natives_syntax_flag_ = i::FLAG_allow_natives_syntax;
+    i::FLAG_allow_natives_syntax = true;
+  }
+
+  static void RestoreFlags() {
+    i::FLAG_compiler_dispatcher = old_compiler_dispatcher_flag_;
+    i::FLAG_ignition = old_ignition_flag_;
+    i::FLAG_allow_natives_syntax = old_allow_natives_syntax_flag_;
+  }
+
+ private:
+  static bool old_compiler_dispatcher_flag_;
+  static bool old_ignition_flag_;
+  static bool old_allow_natives_syntax_flag_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(CompilerDispatcherTestFlags);
+};
+
+bool CompilerDispatcherTestFlags::old_compiler_dispatcher_flag_;
+bool CompilerDispatcherTestFlags::old_ignition_flag_;
+bool CompilerDispatcherTestFlags::old_allow_natives_syntax_flag_;
+
 class CompilerDispatcherTest : public TestWithContext {
  public:
   CompilerDispatcherTest() = default;
   ~CompilerDispatcherTest() override = default;
 
   static void SetUpTestCase() {
-    old_flag_ = i::FLAG_ignition;
-    i::FLAG_compiler_dispatcher = true;
-    old_ignition_flag_ = i::FLAG_ignition;
-    i::FLAG_ignition = true;
+    CompilerDispatcherTestFlags::SetFlagsForTest();
     TestWithContext::SetUpTestCase();
   }
 
   static void TearDownTestCase() {
     TestWithContext::TearDownTestCase();
-    i::FLAG_compiler_dispatcher = old_flag_;
-    i::FLAG_ignition = old_ignition_flag_;
+    CompilerDispatcherTestFlags::RestoreFlags();
   }
 
  private:
-  static bool old_flag_;
-  static bool old_ignition_flag_;
-
   DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherTest);
 };
 
-bool CompilerDispatcherTest::old_flag_;
-bool CompilerDispatcherTest::old_ignition_flag_;
+class CompilerDispatcherTestWithoutContext : public v8::TestWithIsolate {
+ public:
+  CompilerDispatcherTestWithoutContext() = default;
+  ~CompilerDispatcherTestWithoutContext() override = default;
+
+  static void SetUpTestCase() {
+    CompilerDispatcherTestFlags::SetFlagsForTest();
+    TestWithContext::SetUpTestCase();
+  }
+
+  static void TearDownTestCase() {
+    TestWithContext::TearDownTestCase();
+    CompilerDispatcherTestFlags::RestoreFlags();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherTestWithoutContext);
+};
 
 namespace {
 
 class MockPlatform : public v8::Platform {
  public:
   MockPlatform() : time_(0.0), time_step_(0.0), idle_task_(nullptr), sem_(0) {}
   ~MockPlatform() override {
     base::LockGuard<base::Mutex> lock(&mutex_);
     EXPECT_TRUE(foreground_tasks_.empty());
     EXPECT_TRUE(background_tasks_.empty());
@@ skipping 831 matching lines @@
 
   // Finishing removes the SFI from the queue.
   ASSERT_FALSE(dispatcher.IsEnqueued(shared1));
   ASSERT_FALSE(dispatcher.IsEnqueued(shared2));
   ASSERT_TRUE(shared1->is_compiled());
   ASSERT_TRUE(shared2->is_compiled());
   ASSERT_TRUE(platform.IdleTaskPending());
   platform.ClearIdleTask();
 }
 
+static const char kExtensionSource[] = "native function Dummy();";

[jochen (gone - plz use gerrit), 2017/02/08 18:52:58]

put this (and the class) in an anonymous namespace, then you con't need static

[rmcilroy, 2017/02/08 22:49:23]

Done.

+
+class MockNativeFunctionExtension : public Extension {
+ public:
+  MockNativeFunctionExtension()
+      : Extension("mock-extension", kExtensionSource), function_(&Dummy) {}
+
+  virtual v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
+      v8::Isolate* isolate, v8::Local<v8::String> name) {
+    return v8::FunctionTemplate::New(isolate, function_);
+  }
+
+  static void Dummy(const v8::FunctionCallbackInfo<v8::Value>& args) { return; }
+
+ private:
+  v8::FunctionCallback function_;
+};

[jochen (gone - plz use gerrit), 2017/02/08 18:52:58]

disallow copy/assign

[rmcilroy, 2017/02/08 22:49:23]

Done.

+
+TEST_F(CompilerDispatcherTestWithoutContext, CompileExtensionWithoutContext) {
+  MockPlatform platform;
+  CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
+  Local<v8::Context> context = v8::Context::New(isolate());
+
+  MockNativeFunctionExtension extension;
+  Handle<String> script_str =
+      i_isolate()
+          ->factory()
+          ->NewStringFromUtf8(CStrVector(kExtensionSource))
+          .ToHandleChecked();
+  Handle<Script> script = i_isolate()->factory()->NewScript(script_str);
+  script->set_type(Script::TYPE_EXTENSION);
+
+  ParseInfo parse_info(script);
+  parse_info.set_extension(&extension);
+
+  std::shared_ptr<DeferredHandles> handles;
+  Handle<SharedFunctionInfo> shared;
+  {
+    v8::Context::Scope scope(context);
+    ASSERT_TRUE(Compiler::ParseAndAnalyze(&parse_info));
+
+    shared = i_isolate()->factory()->NewSharedFunctionInfoForLiteral(
+        parse_info.literal(), script);
+    parse_info.set_shared_info(shared);
+
+    ASSERT_FALSE(platform.IdleTaskPending());
+    ASSERT_TRUE(dispatcher.Enqueue(shared, parse_info.literal(),
+                                   parse_info.zone_shared(), handles, handles));
+    ASSERT_TRUE(platform.IdleTaskPending());
+  }
+  // Exit the context scope before running the idle task.
+
+  // Since time doesn't progress on the MockPlatform, this is enough idle time
+  // to finish compiling the function.
+  platform.RunIdleTask(1000.0, 0.0);
+
+  ASSERT_FALSE(dispatcher.IsEnqueued(shared));
+  ASSERT_TRUE(shared->is_compiled());
+}
+
 }  // namespace internal
 }  // namespace v8