[promises] Add %WaitForPromise runtime call to allow tests to reliably wait for promises to be fini…

src/d8.cc

 // Copyright 2012 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 <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 1562 matching lines @@
           .ToLocalChecked(),
       worker_fun_template);
 
   Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
   AddOSMethods(isolate, os_templ);
   global_template->Set(
       String::NewFromUtf8(isolate, "os", NewStringType::kNormal)
           .ToLocalChecked(),
       os_templ);
 
   return global_template;

[ulan, 2017/03/16 11:50:14]

How about adding "increment", "decrement" functions to d8 specific global object
instead of isolate?

 }
 
 static void PrintNonErrorsMessageCallback(Local<Message> message,
                                           Local<Value> error) {
   // Nothing to do here for errors, exceptions thrown up to the shell will be
   // reported
   // separately by {Shell::ReportException} after they are caught.
   // Do print other kinds of messages.
   switch (message->ErrorLevel()) {
     case v8::Isolate::kMessageWarning:
@@ skipping 984 matching lines @@
         g_platform->MonotonicallyIncreasingTime() + kLongIdlePauseInSeconds);
   }
   if (options.invoke_weak_callbacks) {
     // By sending a low memory notifications, we will try hard to collect all
     // garbage and will therefore also invoke all weak callbacks of actually
     // unreachable persistent handles.
     isolate->LowMemoryNotification();
   }
 }
 
-
 void Shell::EmptyMessageQueues(Isolate* isolate) {
-  if (!i::FLAG_verify_predictable) {
-    while (v8::platform::PumpMessageLoop(g_platform, isolate)) continue;
+  if (i::FLAG_verify_predictable) return;
+  while (true) {
+    // Pump the message loop until it is empty.
+    while (v8::platform::PumpMessageLoop(g_platform, isolate)) {
+      isolate->RunMicrotasks();
+    }
+    // Run the idle tasks.
     v8::platform::RunIdleTasks(g_platform, isolate,
                                50.0 / base::Time::kMillisecondsPerSecond);
+    // If there are still outstanding waiters, sleep a little (to wait for
+    // background tasks) and then try everything again.
+    if (reinterpret_cast<i::Isolate*>(isolate)->GetWaitCount() > 0) {
+      base::OS::Sleep(base::TimeDelta::FromMilliseconds(1));
+    } else {
+      break;
+    }
   }
 }
 
 class Serializer : public ValueSerializer::Delegate {
  public:
   explicit Serializer(Isolate* isolate)
       : isolate_(isolate),
         serializer_(isolate, this),
         current_memory_usage_(0) {}
 
@@ skipping 439 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif