Introduce HasPendingMicrotasks API.

test/cctest/test-api.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 21128 matching lines @@
 void* g_passed_to_three = NULL;
 
 
 static void MicrotaskThree(void* data) {
   g_passed_to_three = data;
 }
 
 
 TEST(EnqueueMicrotask) {
   LocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   CompileRun(
       "var ext1Calls = 0;"
       "var ext2Calls = 0;");
   CompileRun("1+1;");
   CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskOne));
+  CHECK(!isolate->HasPendingMicrotasks());
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
+  CHECK(isolate->HasPendingMicrotasks());
   CompileRun("1+1;");
   CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskOne));
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  CHECK(!isolate->HasPendingMicrotasks());
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
+  CHECK(isolate->HasPendingMicrotasks());
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
 
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
 
   g_passed_to_three = NULL;
-  env->GetIsolate()->EnqueueMicrotask(MicrotaskThree);
+  isolate->EnqueueMicrotask(MicrotaskThree);
   CompileRun("1+1;");
   CHECK_EQ(NULL, g_passed_to_three);
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
 
   int dummy;
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskOne));
-  env->GetIsolate()->EnqueueMicrotask(MicrotaskThree, &dummy);
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
+  isolate->EnqueueMicrotask(MicrotaskThree, &dummy);
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(&dummy, g_passed_to_three);
   CHECK_EQ(3, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
   g_passed_to_three = NULL;
 }
 
 
 static void MicrotaskExceptionOne(
     const v8::FunctionCallbackInfo<Value>& info) {
@@ skipping 13 matching lines @@
 }
 
 
 TEST(RunMicrotasksIgnoresThrownExceptions) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   CompileRun(
       "var exception1Calls = 0;"
       "var exception2Calls = 0;");
-  isolate->EnqueueMicrotask(
-      Function::New(isolate, MicrotaskExceptionOne));
-  isolate->EnqueueMicrotask(
-      Function::New(isolate, MicrotaskExceptionTwo));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskExceptionOne));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskExceptionTwo));
   TryCatch try_catch;
   CompileRun("1+1;");
   CHECK(!try_catch.HasCaught());
   CHECK_EQ(1, CompileRun("exception1Calls")->Int32Value());
   CHECK_EQ(1, CompileRun("exception2Calls")->Int32Value());
 }
 
 
 TEST(SetAutorunMicrotasks) {
   LocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   CompileRun(
       "var ext1Calls = 0;"
       "var ext2Calls = 0;");
   CompileRun("1+1;");
   CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskOne));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
   CompileRun("1+1;");
   CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->SetAutorunMicrotasks(false);
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskOne));
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->SetAutorunMicrotasks(false);
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->RunMicrotasks();
+  isolate->RunMicrotasks();
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->RunMicrotasks();
+  isolate->RunMicrotasks();
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->SetAutorunMicrotasks(true);
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->SetAutorunMicrotasks(true);
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
 
-  env->GetIsolate()->EnqueueMicrotask(
-      Function::New(env->GetIsolate(), MicrotaskTwo));
+  isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskTwo));
   {
-    v8::Isolate::SuppressMicrotaskExecutionScope scope(env->GetIsolate());
+    v8::Isolate::SuppressMicrotaskExecutionScope scope(isolate);
     CompileRun("1+1;");
     CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
     CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
   }
 
   CompileRun("1+1;");
   CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
   CHECK_EQ(4, CompileRun("ext2Calls")->Int32Value());
 }
 
@@ skipping 10 matching lines @@
   }
   isolate->RunMicrotasks();
   {
     Context::Scope context_scope(context);
     CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
   }
   isolate->SetAutorunMicrotasks(true);
 }
 
 
+bool g_the_only_microtask_called = false;
+
+
+static void TheOnlyMicrotask(void* data) {
+  g_the_only_microtask_called = true;
+  v8::Isolate* isolate = static_cast<v8::Isolate*>(data);
+  CHECK(!isolate->HasPendingMicrotasks());
+}
+
+
+TEST(HasPendingMicrotasks) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  g_the_only_microtask_called = false;
+  CHECK(!isolate->HasPendingMicrotasks());
+  isolate->EnqueueMicrotask(TheOnlyMicrotask, isolate);
+  CHECK(isolate->HasPendingMicrotasks());
+  CompileRun("1+1;");
+  CHECK(g_the_only_microtask_called);
+  CHECK(!isolate->HasPendingMicrotasks());
+}
+
+
 static void DebugEventInObserver(const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   if (event != v8::Break) return;
   Handle<Object> exec_state = event_details.GetExecutionState();
   Handle<Value> break_id = exec_state->Get(v8_str("break_id"));
   CompileRun("function f(id) { new FrameDetails(id, 0); }");
   Handle<Function> fun = Handle<Function>::Cast(
       CcTest::global()->Get(v8_str("f"))->ToObject());
   fun->Call(CcTest::global(), 1, &break_id);
 }
@@ skipping 2371 matching lines @@
       "  var foobXXXXX";  // Too many bytes which look like incomplete chars!
   char chunk2[] =
       "r = 13;\n"
       "  return foob\xeb\x91\x80\x80\x80r;\n"
       "}\n";
   for (int i = 0; i < 5; ++i) chunk1[strlen(chunk1) - 5 + i] = reference[i];
 
   const char* chunks[] = {chunk1, chunk2, "foo();", NULL};
   RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8, false);
 }