[inspector] Pass TaskRunner instead of Context to all tasks

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 96 matching lines @@
 }  //  namespace
 
 class ConnectTask : public TaskRunner::Task {
  public:
   ConnectTask(InspectorClientImpl* client, v8::base::Semaphore* ready_semaphore)
       : client_(client), ready_semaphore_(ready_semaphore) {}
   virtual ~ConnectTask() = default;
 
   bool is_inspector_task() final { return true; }
 
-  void Run(v8::Isolate* isolate,
-           const v8::Global<v8::Context>& global_context) {
-    v8::HandleScope handle_scope(isolate);
-    v8::Local<v8::Context> context = global_context.Get(isolate);
-    client_->connect(context);
+ private:
+  void Run() override {
+    v8::HandleScope handle_scope(isolate());
+    client_->connect(default_context());
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
- private:
   InspectorClientImpl* client_;
   v8::base::Semaphore* ready_semaphore_;
 };
 
 class DisconnectTask : public TaskRunner::Task {
  public:
   explicit DisconnectTask(InspectorClientImpl* client, bool reset_inspector,
                           v8::base::Semaphore* ready_semaphore)
       : client_(client),
         reset_inspector_(reset_inspector),
         ready_semaphore_(ready_semaphore) {}
   virtual ~DisconnectTask() = default;
 
   bool is_inspector_task() final { return true; }
 
-  void Run(v8::Isolate* isolate,
-           const v8::Global<v8::Context>& global_context) {
+ private:
+  void Run() override {
     client_->disconnect(reset_inspector_);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
- private:
   InspectorClientImpl* client_;
   bool reset_inspector_;
   v8::base::Semaphore* ready_semaphore_;
 };
 
 class CreateContextGroupTask : public TaskRunner::Task {
  public:
   CreateContextGroupTask(InspectorClientImpl* client,
                          TaskRunner::SetupGlobalTasks setup_global_tasks,
                          v8::base::Semaphore* ready_semaphore,
                          int* context_group_id)
       : client_(client),
         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) {
+ private:
+  void Run() override {
     *context_group_id_ = client_->createContextGroup(setup_global_tasks_);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
- private:
   InspectorClientImpl* client_;
   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),
@@ skipping 169 matching lines @@
 }
 
 class SendMessageToBackendTask : public TaskRunner::Task {
  public:
   explicit SendMessageToBackendTask(
       const v8::internal::Vector<uint16_t>& message, int context_group_id)
       : message_(message), context_group_id_(context_group_id) {}
 
   bool is_inspector_task() final { return true; }
 
-  void Run(v8::Isolate* isolate,
-           const v8::Global<v8::Context>& global_context) override {
+ private:
+  void Run() override {
     v8_inspector::V8InspectorSession* session = nullptr;
     {
-      v8::HandleScope handle_scope(isolate);
-      v8::Local<v8::Context> context = global_context.Get(isolate);
+      v8::HandleScope handle_scope(isolate());
       if (!context_group_id_) {
-        session = InspectorClientImpl::SessionFromContext(context);
+        session = InspectorClientImpl::SessionFromContext(default_context());
       } else {
-        session = InspectorClientFromContext(context)
+        session = InspectorClientFromContext(default_context())
                       ->sessions_[context_group_id_]
                       .get();
       }
       if (!session) return;
     }
     v8_inspector::StringView message_view(message_.start(), message_.length());
     session->dispatchProtocolMessage(message_view);
   }
 
- private:
   v8::internal::Vector<uint16_t> message_;
   int context_group_id_;
 };
 
 TaskRunner* SendMessageToBackendExtension::backend_task_runner_ = nullptr;
 
 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()));
 }