[inspector] Pass TaskRunner instead of Context to all tasks

test/inspector/task-runner.h

 // 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.
 
 #ifndef V8_TEST_INSPECTOR_PROTOCOL_TASK_RUNNER_H_
 #define V8_TEST_INSPECTOR_PROTOCOL_TASK_RUNNER_H_
 
 #include <map>
 
 #include "include/v8-inspector.h"
@@ skipping 14 matching lines @@
     return false;
   }
 };
 
 class TaskRunner : public v8::base::Thread {
  public:
   class Task {
    public:
     virtual ~Task() {}
     virtual bool is_inspector_task() = 0;
-    virtual void Run(v8::Isolate* isolate,
-                     const v8::Global<v8::Context>& context) = 0;
+    void RunOnTaskRunner(TaskRunner* task_runner) {
+      task_runner_ = task_runner;
+      Run();
+      task_runner_ = nullptr;
+    }
+
+   protected:
+    virtual void Run() = 0;
+    v8::Isolate* isolate() const { return task_runner_->isolate_; }
+    v8::Local<v8::Context> default_context() const {
+      return task_runner_->contexts_.begin()->second.Get(isolate());
+    }
+
+   private:
+    TaskRunner* task_runner_ = nullptr;
   };
 
   class SetupGlobalTask {
    public:
     virtual ~SetupGlobalTask() = default;
     virtual void Run(v8::Isolate* isolate,
                      v8::Local<v8::ObjectTemplate> global) = 0;
   };
   using SetupGlobalTasks = std::vector<std::unique_ptr<SetupGlobalTask>>;
 
@@ skipping 56 matching lines @@
   v8::base::AtomicNumber<int> is_terminated_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskRunner);
 };
 
 class AsyncTask : public TaskRunner::Task {
  public:
   AsyncTask(const char* task_name, v8_inspector::V8Inspector* inspector);
   virtual ~AsyncTask() = default;
 
-  void Run(v8::Isolate* isolate,
-           const v8::Global<v8::Context>& context) override;
-  virtual void AsyncRun(v8::Isolate* isolate,
-                        const v8::Global<v8::Context>& context) = 0;
+ protected:
+  virtual void AsyncRun() = 0;
+  void Run() override;
 
- protected:
   v8_inspector::V8Inspector* inspector_;
 };
 
 class ExecuteStringTask : public AsyncTask {
  public:
   ExecuteStringTask(const v8::internal::Vector<uint16_t>& expression,
                     v8::Local<v8::String> name,
                     v8::Local<v8::Integer> line_offset,
                     v8::Local<v8::Integer> column_offset,
                     v8::Local<v8::Boolean> is_module, const char* task_name,
                     v8_inspector::V8Inspector* inspector);
   explicit ExecuteStringTask(
       const v8::internal::Vector<const char>& expression);
   bool is_inspector_task() override { return false; }
 
-  void AsyncRun(v8::Isolate* isolate,
-                const v8::Global<v8::Context>& context) override;
+ private:
+  void AsyncRun() override;
 
- private:
   v8::internal::Vector<uint16_t> expression_;
   v8::internal::Vector<const char> expression_utf8_;
   v8::internal::Vector<uint16_t> name_;
   int32_t line_offset_ = 0;
   int32_t column_offset_ = 0;
   bool is_module_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(ExecuteStringTask);
 };
 
 #endif  //  V8_TEST_INSPECTOR_PROTOCOL_TASK_RUNNER_H_