[test/inspector] remove any usage of v8::Extension

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"
 
 #include "test/inspector/inspector-impl.h"
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
@@ skipping 14 matching lines @@
 
 v8::internal::Vector<uint16_t> ToVector(v8::Local<v8::String> str) {
   v8::internal::Vector<uint16_t> buffer =
       v8::internal::Vector<uint16_t>::New(str->Length());
   str->Write(buffer.start(), 0, str->Length());
   return buffer;
 }
 
 }  //  namespace
 
-TaskRunner::TaskRunner(v8::ExtensionConfiguration* extensions,
+TaskRunner::TaskRunner(TaskRunner::SetupGlobalTasks setup_global_tasks,
                        bool catch_exceptions,
                        v8::base::Semaphore* ready_semaphore)
     : Thread(Options("Task Runner")),
-      extensions_(extensions),
+      setup_global_tasks_(std::move(setup_global_tasks)),
       catch_exceptions_(catch_exceptions),
       ready_semaphore_(ready_semaphore),
       isolate_(nullptr),
       process_queue_semaphore_(0),
       nested_loop_count_(0) {
   Start();
 }
 
 TaskRunner::~TaskRunner() { Join(); }
 
 void TaskRunner::InitializeIsolate() {
   v8::Isolate::CreateParams params;
   params.array_buffer_allocator =
       v8::ArrayBuffer::Allocator::NewDefaultAllocator();
   isolate_ = v8::Isolate::New(params);
   isolate_->SetMicrotasksPolicy(v8::MicrotasksPolicy::kScoped);
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
-  NewContextGroup();
+  NewContextGroup(setup_global_tasks_);
   if (ready_semaphore_) ready_semaphore_->Signal();
 }
 
-v8::Local<v8::Context> TaskRunner::NewContextGroup() {
+v8::Local<v8::Context> TaskRunner::NewContextGroup(
+    const TaskRunner::SetupGlobalTasks& setup_global_tasks) {
   v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate_);
+  for (auto it = setup_global_tasks.begin(); it != setup_global_tasks.end();
+       ++it) {
+    (*it)->Run(isolate_, global_template);
+  }
   v8::Local<v8::Context> context =
-      v8::Context::New(isolate_, extensions_, global_template);
+      v8::Context::New(isolate_, nullptr, global_template);
   context->SetAlignedPointerInEmbedderData(kTaskRunnerIndex, this);
   intptr_t context_group_id = ++last_context_group_id_;
   // Should be 2-byte aligned.
   context->SetAlignedPointerInEmbedderData(
       kContextGroupIdIndex, reinterpret_cast<void*>(context_group_id * 2));
   contexts_[context_group_id].Reset(isolate_, context);
   return context;
 }
 
 v8::Local<v8::Context> TaskRunner::GetContext(int context_group_id) {
@@ skipping 173 matching lines @@
       return;
     }
     if (!module->Instantiate(local_context, &TaskRunner::ModuleResolveCallback))
       return;
     v8::Local<v8::Value> result;
     if (!module->Evaluate(local_context).ToLocal(&result)) return;
     TaskRunner* runner = TaskRunner::FromContext(local_context);
     runner->RegisterModule(name_, module);
   }
 }