Support tasks injection into a running VM.

test/cctest/test-debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 7378 matching lines @@
   CHECK_EQ(1, CountNativeContexts());
 
   v8::Debug::SetDebugEventListener(NopListener);
   CompileRun("debugger;");
   CHECK_EQ(2, CountNativeContexts());
 
   v8::Debug::SetDebugEventListener(NULL);
 }
 
 
+class AsyncTask : public v8::base::Thread {
+ public:
+  AsyncTask(v8::Isolate* isolate, v8::Task* task)
+      : Thread(Options("AsyncTask")), isolate_(isolate), task_(task) {}
+  void Run() override {

[Sven Panne, 2014/12/18 14:53:31]

Use OVERRIDE, not all our toolchains support override yet.

[alph, 2014/12/18 15:05:01]

Done.

+    v8::Debug::BreakAndRun(isolate_, task_);
+    task_ = NULL;
+  }
+
+ private:
+  v8::Isolate* isolate_;
+  v8::Task* task_;
+};
+
+
+class StopExecutionTask : public v8::Task {
+ public:
+  explicit StopExecutionTask(LocalContext& context) : context_(context) {}
+  void Run() override {

[Sven Panne, 2014/12/18 14:53:31]

Same here.

[alph, 2014/12/18 15:05:01]

Done.

+    context_->Global()->Set(v8_str("stop"), v8::True(context_->GetIsolate()));
+  }
+
+ private:
+  LocalContext& context_;
+};
+
+
+TEST(RunTaskWhileLooping) {
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+
+  v8::Task* task = new StopExecutionTask(env);
+  // Delaying the task increases probability the task is injected while the
+  // loop is already running.

[Sven Panne, 2014/12/18 14:53:31]

Remove the comment, there's no delay anymore.

[alph, 2014/12/18 15:05:01]

Done.

+  AsyncTask async_task(env->GetIsolate(), task);
+  CompileRun("var stop = false;");
+  async_task.Start();
+  CompileRun("while (!stop) {}");

[Sven Panne, 2014/12/18 14:53:31]

Well, without any kind of handshake (via a native function), the test itself
might not be flaky, but the thing it tests is. In a nutshell: Our test coverage
is flaky now, but if that's OK for you...

[alph, 2014/12/18 15:05:01]

Technically the test doesn't care what was the VM state when the task was
injected. It tests that the task is injected from another thread, and the task
is executed. So I think the synchronization is not needed here.

+}
+
+
 TEST(LiveEditEnabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetLiveEditEnabled(env->GetIsolate(), true);
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 TEST(LiveEditDisabled) {
@@ skipping 263 matching lines @@
       "let y = 2;               \n"
       "debugger;                \n"
       "x * y",
       30);
   ExpectInt32(
       "x = 1; y = 2; \n"
       "debugger;"
       "x * y",
       30);
 }