[inspector] Extract IsolateData out of TaskRunner

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 99 matching lines @@
  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; }
 
  private:
   void Run() override {
     v8::HandleScope handle_scope(isolate());
-    client_->connect(default_context());
+    client_->connect();
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   InspectorClientImpl* client_;
   v8::base::Semaphore* ready_semaphore_;
 };
 
 class DisconnectTask : public TaskRunner::Task {
  public:
   explicit DisconnectTask(InspectorClientImpl* client, bool reset_inspector,
@@ skipping 12 matching lines @@
   }
 
   InspectorClientImpl* client_;
   bool reset_inspector_;
   v8::base::Semaphore* ready_semaphore_;
 };
 
 class CreateContextGroupTask : public TaskRunner::Task {
  public:
   CreateContextGroupTask(InspectorClientImpl* client,
-                         TaskRunner::SetupGlobalTasks setup_global_tasks,
+                         IsolateData::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; }
 
  private:
   void Run() override {
     *context_group_id_ = client_->createContextGroup(setup_global_tasks_);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   InspectorClientImpl* client_;
-  TaskRunner::SetupGlobalTasks setup_global_tasks_;
+  IsolateData::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) {
   task_runner_->Append(new ConnectTask(this, ready_semaphore));
 }
 
 InspectorClientImpl::~InspectorClientImpl() {}
 
-void InspectorClientImpl::connect(v8::Local<v8::Context> context) {
-  isolate_ = context->GetIsolate();
+void InspectorClientImpl::connect() {
+  isolate_ = task_runner_->data()->isolate();
   isolate_->AddMessageListener(MessageHandler);
   channel_.reset(new ChannelImpl(frontend_channel_));
   inspector_ = v8_inspector::V8Inspector::create(isolate_, this);
 
   if (states_.empty()) {
-    int context_group_id = TaskRunner::GetContextGroupId(context);
-    v8_inspector::StringView state;
-    sessions_[context_group_id] =
-        inspector_->connect(context_group_id, channel_.get(), state);
-    context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
-    v8_inspector::V8ContextInfo info(context, context_group_id,
-                                     v8_inspector::StringView());
-    info.hasMemoryOnConsole = true;
-    inspector_->contextCreated(info);
+    ConnectToContextGroup(task_runner_->default_context_group_id(),
+                          v8_inspector::StringView());
   } else {
-    for (const auto& it : states_) {
-      int context_group_id = it.first;
-      v8::Local<v8::Context> context =
-          task_runner_->GetContext(context_group_id);
-      v8_inspector::StringView state = it.second->string();
-      sessions_[context_group_id] =
-          inspector_->connect(context_group_id, channel_.get(), state);
-      context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
-      v8_inspector::V8ContextInfo info(context, context_group_id,
-                                       v8_inspector::StringView());
-      info.hasMemoryOnConsole = true;
-      inspector_->contextCreated(info);
-    }
+    for (const auto& it : states_)
+      ConnectToContextGroup(it.first, it.second->string());
   }
   states_.clear();
 }
 
+void InspectorClientImpl::ConnectToContextGroup(
+    int context_group_id, v8_inspector::StringView state) {
+  v8::Local<v8::Context> context =
+      task_runner_->data()->GetContext(context_group_id);
+  sessions_[context_group_id] =
+      inspector_->connect(context_group_id, channel_.get(), state);
+  context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
+  v8_inspector::V8ContextInfo info(context, context_group_id,
+                                   v8_inspector::StringView());
+  info.hasMemoryOnConsole = true;
+  inspector_->contextCreated(info);
+}
+
 void InspectorClientImpl::scheduleReconnect(
     v8::base::Semaphore* ready_semaphore) {
   task_runner_->Append(
       new DisconnectTask(this, /* reset_inspector */ true, nullptr));
   task_runner_->Append(new ConnectTask(this, ready_semaphore));
 }
 
 void InspectorClientImpl::scheduleDisconnect(
     v8::base::Semaphore* ready_semaphore) {
   task_runner_->Append(
       new DisconnectTask(this, /* reset_inspector */ false, ready_semaphore));
 }
 
 void InspectorClientImpl::disconnect(bool reset_inspector) {
   for (const auto& it : sessions_) {
     states_[it.first] = it.second->stateJSON();
   }
   sessions_.clear();
   if (reset_inspector) inspector_.reset();
 }
 
 void InspectorClientImpl::scheduleCreateContextGroup(
-    TaskRunner::SetupGlobalTasks setup_global_tasks,
+    IsolateData::SetupGlobalTasks setup_global_tasks,
     v8::base::Semaphore* ready_semaphore, int* context_group_id) {
   task_runner_->Append(new CreateContextGroupTask(
       this, std::move(setup_global_tasks), ready_semaphore, context_group_id));
 }
 
 int InspectorClientImpl::createContextGroup(
-    const TaskRunner::SetupGlobalTasks& setup_global_tasks) {
+    const IsolateData::SetupGlobalTasks& setup_global_tasks) {
   v8::HandleScope handle_scope(isolate_);
+  int context_group_id = task_runner_->data()->CreateContextGroup();
   v8::Local<v8::Context> context =
-      task_runner_->NewContextGroup(setup_global_tasks);
+      task_runner_->data()->GetContext(context_group_id);
   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;
 }
 
 bool InspectorClientImpl::formatAccessorsAsProperties(
     v8::Local<v8::Value> object) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Private> shouldFormatAccessorsPrivate = v8::Private::ForApi(
       isolate, v8::String::NewFromUtf8(isolate, "allowAccessorFormatting",
                                        v8::NewStringType::kNormal)
                    .ToLocalChecked());
   CHECK(object->IsObject());
   return object.As<v8::Object>()
       ->HasPrivate(context, shouldFormatAccessorsPrivate)
       .FromMaybe(false);
 }
 
 v8::Local<v8::Context> InspectorClientImpl::ensureDefaultContextInGroup(
     int context_group_id) {
   CHECK(isolate_);
-  return task_runner_->GetContext(context_group_id);
+  return task_runner_->data()->GetContext(context_group_id);
 }
 
 void InspectorClientImpl::setCurrentTimeMSForTest(double time) {
   current_time_ = time;
   current_time_set_for_test_ = true;
 }
 
 double InspectorClientImpl::currentTimeMS() {
   if (current_time_set_for_test_) return current_time_;
   return v8::base::OS::TimeCurrentMillis();
@@ skipping 36 matching lines @@
   fprintf(stdout, "\n");
 }
 
 v8_inspector::V8Inspector* InspectorClientImpl::InspectorFromContext(
     v8::Local<v8::Context> context) {
   return InspectorClientFromContext(context)->inspector_.get();
 }
 
 v8_inspector::V8InspectorSession* InspectorClientImpl::SessionFromContext(
     v8::Local<v8::Context> context) {
-  int context_group_id = TaskRunner::GetContextGroupId(context);
-  return InspectorClientFromContext(context)->sessions_[context_group_id].get();
+  InspectorClientImpl* client = InspectorClientFromContext(context);
+  for (auto& it : client->sessions_) {
+    if (client->task_runner_->data()->GetContext(it.first) == context)
+      return it.second.get();
+  }
+  return nullptr;
 }
 
 v8_inspector::V8InspectorSession* InspectorClientImpl::session(
     int context_group_id) {
   if (context_group_id) {
     return sessions_[context_group_id].get();
   } else {
     return sessions_.begin()->second.get();
   }
 }
@@ skipping 41 matching lines @@
 }
 
 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()));
 }