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

test/inspector/inspector-impl.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/inspector-impl.h"
 
 #include "include/v8.h"
 
 #include "src/vector.h"
 
@@ skipping 128 matching lines @@
     client_->disconnect();
   }
 
  private:
   InspectorClientImpl* client_;
 };
 
 class CreateContextGroupTask : public TaskRunner::Task {
  public:
   CreateContextGroupTask(InspectorClientImpl* client,
-                         v8::ExtensionConfiguration* extensions,
+                         TaskRunner::SetupGlobalTasks setup_global_tasks,
                          v8::base::Semaphore* ready_semaphore,
                          int* context_group_id)
       : client_(client),
-        extensions_(extensions),
+        setup_global_tasks_(std::move(setup_global_tasks)),
         ready_semaphore_(ready_semaphore),
         context_group_id_(context_group_id) {}
   virtual ~CreateContextGroupTask() = default;
 
   bool is_inspector_task() final { return true; }
 
   void Run(v8::Isolate* isolate,
            const v8::Global<v8::Context>& global_context) {
-    *context_group_id_ = client_->createContextGroup(extensions_);
+    *context_group_id_ = client_->createContextGroup(setup_global_tasks_);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
  private:
   InspectorClientImpl* client_;
-  v8::ExtensionConfiguration* extensions_;
+  TaskRunner::SetupGlobalTasks setup_global_tasks_;
   v8::base::Semaphore* ready_semaphore_;
   int* context_group_id_;
 };
 
 InspectorClientImpl::InspectorClientImpl(TaskRunner* task_runner,
                                          FrontendChannel* frontend_channel,
                                          v8::base::Semaphore* ready_semaphore)
     : isolate_(nullptr),
       task_runner_(task_runner),
       frontend_channel_(frontend_channel) {
@@ skipping 44 matching lines @@
 
 void InspectorClientImpl::disconnect() {
   for (const auto& it : sessions_) {
     states_[it.first] = it.second->stateJSON();
   }
   sessions_.clear();
   inspector_.reset();
 }
 
 void InspectorClientImpl::scheduleCreateContextGroup(
-    v8::ExtensionConfiguration* extensions,
+    TaskRunner::SetupGlobalTasks setup_global_tasks,
     v8::base::Semaphore* ready_semaphore, int* context_group_id) {
   task_runner_->Append(new CreateContextGroupTask(
-      this, extensions, ready_semaphore, context_group_id));
+      this, std::move(setup_global_tasks), ready_semaphore, context_group_id));
 }
 
 int InspectorClientImpl::createContextGroup(
-    v8::ExtensionConfiguration* extensions) {
+    const TaskRunner::SetupGlobalTasks& setup_global_tasks) {
   v8::HandleScope handle_scope(isolate_);
-  v8::Local<v8::Context> context = task_runner_->NewContextGroup();
+  v8::Local<v8::Context> context =
+      task_runner_->NewContextGroup(setup_global_tasks);
   context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
   int context_group_id = TaskRunner::GetContextGroupId(context);
   v8_inspector::StringView state;
   sessions_[context_group_id] =
       inspector_->connect(context_group_id, channel_.get(), state);
   inspector_->contextCreated(v8_inspector::V8ContextInfo(
       context, context_group_id, v8_inspector::StringView()));
   return context_group_id;
 }
 
@@ skipping 111 matching lines @@
     session->dispatchProtocolMessage(message_view);
   }
 
  private:
   v8::internal::Vector<uint16_t> message_;
   int context_group_id_;
 };
 
 TaskRunner* SendMessageToBackendExtension::backend_task_runner_ = nullptr;
 
-v8::Local<v8::FunctionTemplate>
-SendMessageToBackendExtension::GetNativeFunctionTemplate(
-    v8::Isolate* isolate, v8::Local<v8::String> name) {
-  return v8::FunctionTemplate::New(
-      isolate, SendMessageToBackendExtension::SendMessageToBackend);
+void SendMessageToBackendExtension::Run(v8::Isolate* isolate,
+                                        v8::Local<v8::ObjectTemplate> global) {
+  global->Set(
+      v8::String::NewFromUtf8(isolate, "sendMessageToBackend",
+                              v8::NewStringType::kNormal)
+          .ToLocalChecked(),
+      v8::FunctionTemplate::New(
+          isolate, &SendMessageToBackendExtension::SendMessageToBackend));
 }
 
 void SendMessageToBackendExtension::SendMessageToBackend(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(backend_task_runner_);
   CHECK(args.Length() == 2 && args[0]->IsString() && args[1]->IsInt32());
   v8::Local<v8::String> message = args[0].As<v8::String>();
   backend_task_runner_->Append(new SendMessageToBackendTask(
       ToVector(message), args[1].As<v8::Int32>()->Value()));
 }