[inspector] finish test runner gracefully..

test/inspector/task-runner.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 "test/inspector/task-runner.h"
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif               // !defined(_WIN32) && !defined(_WIN64)
 
@@ skipping 45 matching lines @@
   if (ready_semaphore_) ready_semaphore_->Signal();
 }
 
 void TaskRunner::Run() {
   InitializeContext();
   RunMessageLoop(false);
 }
 
 void TaskRunner::RunMessageLoop(bool only_protocol) {
   int loop_number = ++nested_loop_count_;
-  while (nested_loop_count_ == loop_number) {
+  while (nested_loop_count_ == loop_number && !is_terminated_.Value()) {
     TaskRunner::Task* task = GetNext(only_protocol);
+    if (!task) return;
     v8::Isolate::Scope isolate_scope(isolate_);
     if (catch_exceptions_) {
       v8::TryCatch try_catch(isolate_);
       task->Run(isolate_, context_);
       delete task;
       if (try_catch.HasCaught()) {
         ReportUncaughtException(isolate_, try_catch);
         fflush(stdout);
         fflush(stderr);
         _exit(0);
       }
     } else {
       task->Run(isolate_, context_);
       delete task;
     }
   }
 }
 
 void TaskRunner::QuitMessageLoop() {
   DCHECK(nested_loop_count_ > 0);
   --nested_loop_count_;
 }
 
 void TaskRunner::Append(Task* task) {
   queue_.Enqueue(task);
   process_queue_semaphore_.Signal();
 }
 
+void TaskRunner::Terminate() {
+  is_terminated_.Increment(1);
+  process_queue_semaphore_.Signal();
+}
+
 TaskRunner::Task* TaskRunner::GetNext(bool only_protocol) {
   for (;;) {
+    if (is_terminated_.Value()) return nullptr;
     if (only_protocol) {
       Task* task = nullptr;
       if (queue_.Dequeue(&task)) {
         if (task->is_inspector_task()) return task;
         deffered_queue_.Enqueue(task);
       }
     } else {
       Task* task = nullptr;
       if (deffered_queue_.Dequeue(&task)) return task;
       if (queue_.Dequeue(&task)) return task;
     }
     process_queue_semaphore_.Wait();
   }
-  UNREACHABLE();
   return nullptr;
 }
 
 TaskRunner* TaskRunner::FromContext(v8::Local<v8::Context> context) {
   return static_cast<TaskRunner*>(
       context->GetAlignedPointerFromEmbedderData(kTaskRunnerIndex));
 }
 
 ExecuteStringTask::ExecuteStringTask(
     const v8::internal::Vector<uint16_t>& expression)
@@ skipping 26 matching lines @@
   }
 
   v8::ScriptCompiler::Source scriptSource(source, origin);
   v8::Local<v8::Script> script;
   if (!v8::ScriptCompiler::Compile(local_context, &scriptSource)
            .ToLocal(&script))
     return;
   v8::MaybeLocal<v8::Value> result;
   result = script->Run(local_context);
 }