[inspector] Merge InspectorClientImpl into IsolateData

test/inspector/inspector-test.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.
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif               // !defined(_WIN32) && !defined(_WIN64)
 
 #include <locale.h>
 
 #include "include/libplatform/libplatform.h"
 #include "include/v8.h"
 
 #include "src/base/platform/platform.h"
 #include "src/flags.h"
 #include "src/inspector/test-interface.h"
 #include "src/utils.h"
 #include "src/vector.h"
 
-#include "test/inspector/inspector-impl.h"
+#include "test/inspector/isolate-data.h"
 #include "test/inspector/task-runner.h"
 
 namespace {
 
 std::vector<TaskRunner*> task_runners;
 
 void Terminate() {
   for (size_t i = 0; i < task_runners.size(); ++i) {
     task_runners[i]->Terminate();
     task_runners[i]->Join();
@@ skipping 60 matching lines @@
       : ready_semaphore_(ready_semaphore),
         context_group_id_(context_group_id),
         state_(state),
         session_id_(session_id) {}
   virtual ~ConnectSessionTask() = default;
   bool is_inspector_task() final { return true; }
 
  private:
   void Run() override {
     v8_inspector::StringView state(state_.start(), state_.length());
-    *session_id_ =
-        data()->inspector()->ConnectSession(context_group_id_, state);
+    *session_id_ = data()->ConnectSession(context_group_id_, state);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   v8::base::Semaphore* ready_semaphore_;
   int context_group_id_;
   const v8::internal::Vector<uint16_t>& state_;
   int* session_id_;
 };
 
 class DisconnectSessionTask : public TaskRunner::Task {
  public:
   DisconnectSessionTask(v8::base::Semaphore* ready_semaphore, int session_id,
                         v8::internal::Vector<uint16_t>* state)
       : ready_semaphore_(ready_semaphore),
         session_id_(session_id),
         state_(state) {}
   virtual ~DisconnectSessionTask() = default;
   bool is_inspector_task() final { return true; }
 
  private:
   void Run() override {
     std::unique_ptr<v8_inspector::StringBuffer> state =
-        data()->inspector()->DisconnectSession(session_id_);
+        data()->DisconnectSession(session_id_);
     *state_ = ToVector(state->string());
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   v8::base::Semaphore* ready_semaphore_;
   int session_id_;
   v8::internal::Vector<uint16_t>* state_;
 };
 
 class SendMessageToBackendTask : public TaskRunner::Task {
  public:
   explicit SendMessageToBackendTask(
       int session_id, const v8::internal::Vector<uint16_t>& message)
       : session_id_(session_id), message_(message) {}
   bool is_inspector_task() final { return true; }
 
  private:
   void Run() override {
     v8_inspector::StringView message_view(message_.start(), message_.length());
-    data()->inspector()->SendMessage(session_id_, message_view);
+    data()->SendMessage(session_id_, message_view);
   }
 
   int session_id_;
   v8::internal::Vector<uint16_t> message_;
 };
 
 class SchedulePauseOnNextStatementTask : public TaskRunner::Task {
  public:
   SchedulePauseOnNextStatementTask(
       v8::base::Semaphore* ready_semaphore, int context_group_id,
       const v8::internal::Vector<uint16_t>& reason,
       const v8::internal::Vector<uint16_t>& details)
       : ready_semaphore_(ready_semaphore),
         context_group_id_(context_group_id),
         reason_(reason),
         details_(details) {}
   virtual ~SchedulePauseOnNextStatementTask() = default;
   bool is_inspector_task() final { return true; }
 
  private:
   void Run() override {
     v8_inspector::StringView reason(reason_.start(), reason_.length());
     v8_inspector::StringView details(details_.start(), details_.length());
-    data()->inspector()->SchedulePauseOnNextStatement(context_group_id_, reason,
-                                                      details);
+    data()->SchedulePauseOnNextStatement(context_group_id_, reason, details);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   v8::base::Semaphore* ready_semaphore_;
   int context_group_id_;
   const v8::internal::Vector<uint16_t>& reason_;
   const v8::internal::Vector<uint16_t>& details_;
 };
 
 class CancelPauseOnNextStatementTask : public TaskRunner::Task {
  public:
   CancelPauseOnNextStatementTask(v8::base::Semaphore* ready_semaphore,
                                  int context_group_id)
       : ready_semaphore_(ready_semaphore),
         context_group_id_(context_group_id) {}
   virtual ~CancelPauseOnNextStatementTask() = default;
   bool is_inspector_task() final { return true; }
 
  private:
   void Run() override {
-    data()->inspector()->CancelPauseOnNextStatement(context_group_id_);
+    data()->CancelPauseOnNextStatement(context_group_id_);
     if (ready_semaphore_) ready_semaphore_->Signal();
   }
 
   v8::base::Semaphore* ready_semaphore_;
   int context_group_id_;
 };
 
 class SendMessageToFrontendTask : public TaskRunner::Task {
  public:
   SendMessageToFrontendTask(int context_group_id, int session_id,
@@ skipping 203 matching lines @@
         args[3].As<v8::Int32>(), args[4].As<v8::Int32>(),
         args[5].As<v8::Boolean>()));
   }
 
   static void SetCurrentTimeMSForTest(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1 || !args[0]->IsNumber()) {
       fprintf(stderr, "Internal error: setCurrentTimeMSForTest(time).");
       Exit();
     }
-    backend_runner_->data()->inspector()->SetCurrentTimeMSForTest(
+    backend_runner_->data()->SetCurrentTimeMS(
         args[0].As<v8::Number>()->Value());
   }
 
   static void SetMemoryInfoForTest(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1) {
       fprintf(stderr, "Internal error: setMemoryInfoForTest(value).");
       Exit();
     }
-    backend_runner_->data()->inspector()->SetMemoryInfoForTest(args[0]);
+    backend_runner_->data()->SetMemoryInfo(args[0]);
   }
 
   static void SchedulePauseOnNextStatement(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 3 || !args[0]->IsInt32() || !args[1]->IsString() ||
         !args[2]->IsString()) {
       fprintf(stderr,
               "Internal error: schedulePauseOnNextStatement(context_group_id, "
               "'reason', 'details').");
       Exit();
@@ skipping 18 matching lines @@
         &ready_semaphore, args[0].As<v8::Int32>()->Value()));
     ready_semaphore.Wait();
   }
 
   static void SetLogConsoleApiMessageCalls(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1 || !args[0]->IsBoolean()) {
       fprintf(stderr, "Internal error: setLogConsoleApiMessageCalls(bool).");
       Exit();
     }
-    backend_runner_->data()->inspector()->SetLogConsoleApiMessageCalls(
+    backend_runner_->data()->SetLogConsoleApiMessageCalls(
         args[0].As<v8::Boolean>()->Value());
   }
 
   static void CreateContextGroup(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 0) {
       fprintf(stderr, "Internal error: createContextGroup().");
       Exit();
     }
     v8::base::Semaphore ready_semaphore(0);
@@ skipping 165 matching lines @@
                    v8::FunctionTemplate::New(
                        isolate, &InspectorExtension::AllowAccessorFormatting));
     global->Set(ToV8String(isolate, "inspector"), inspector);
   }
 
  private:
   static void FireContextCreated(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
     IsolateData* data = IsolateData::FromContext(context);
-    data->inspector()->ContextCreated(context,
-                                      data->GetContextGroupId(context));
+    data->FireContextCreated(context, data->GetContextGroupId(context));
   }
 
   static void FireContextDestroyed(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
     IsolateData* data = IsolateData::FromContext(context);
-    data->inspector()->ContextDestroyed(context);
+    data->FireContextDestroyed(context);
   }
 
   static void SetMaxAsyncTaskStacks(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1 || !args[0]->IsInt32()) {
       fprintf(stderr, "Internal error: setMaxAsyncTaskStacks(max).");
       Exit();
     }
     v8_inspector::SetMaxAsyncTaskStacksForTest(
         IsolateData::FromContext(args.GetIsolate()->GetCurrentContext())
-            ->inspector()
             ->inspector(),
         args[0].As<v8::Int32>()->Value());
   }
 
   static void DumpAsyncTaskStacksStateForTest(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 0) {
       fprintf(stderr, "Internal error: dumpAsyncTaskStacksStateForTest().");
       Exit();
     }
     v8_inspector::DumpAsyncTaskStacksStateForTest(
         IsolateData::FromContext(args.GetIsolate()->GetCurrentContext())
-            ->inspector()
             ->inspector());
   }
 
   static void BreakProgram(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString()) {
       fprintf(stderr, "Internal error: breakProgram('reason', 'details').");
       Exit();
     }
     v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
     IsolateData* data = IsolateData::FromContext(context);
     v8::internal::Vector<uint16_t> reason = ToVector(args[0].As<v8::String>());
     v8_inspector::StringView reason_view(reason.start(), reason.length());
     v8::internal::Vector<uint16_t> details = ToVector(args[1].As<v8::String>());
     v8_inspector::StringView details_view(details.start(), details.length());
-    data->inspector()->BreakProgram(data->GetContextGroupId(context),
-                                    reason_view, details_view);
+    data->BreakProgram(data->GetContextGroupId(context), reason_view,
+                       details_view);
   }
 
   static void CreateObjectWithStrictCheck(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 0) {
       fprintf(stderr, "Internal error: createObjectWithStrictCheck().");
       Exit();
     }
     v8::Local<v8::ObjectTemplate> templ =
         v8::ObjectTemplate::New(args.GetIsolate());
@@ skipping 11 matching lines @@
               "Internal error: callWithScheduledBreak('reason', 'details').");
       Exit();
     }
     v8::internal::Vector<uint16_t> reason = ToVector(args[1].As<v8::String>());
     v8_inspector::StringView reason_view(reason.start(), reason.length());
     v8::internal::Vector<uint16_t> details = ToVector(args[2].As<v8::String>());
     v8_inspector::StringView details_view(details.start(), details.length());
     v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
     IsolateData* data = IsolateData::FromContext(context);
     int context_group_id = data->GetContextGroupId(context);
-    data->inspector()->SchedulePauseOnNextStatement(context_group_id,
-                                                    reason_view, details_view);
+    data->SchedulePauseOnNextStatement(context_group_id, reason_view,
+                                       details_view);
     v8::MaybeLocal<v8::Value> result;
     result = args[0].As<v8::Function>()->Call(context, context->Global(), 0,
                                               nullptr);
-    data->inspector()->CancelPauseOnNextStatement(context_group_id);
+    data->CancelPauseOnNextStatement(context_group_id);
   }
 
   static void AllowAccessorFormatting(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1 || !args[0]->IsObject()) {
       fprintf(stderr, "Internal error: allowAccessorFormatting('object').");
       Exit();
     }
     v8::Local<v8::Object> object = args[0].As<v8::Object>();
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Private> shouldFormatAccessorsPrivate = v8::Private::ForApi(
         isolate, v8::String::NewFromUtf8(isolate, "allowAccessorFormatting",
                                          v8::NewStringType::kNormal)
                      .ToLocalChecked());
     object
         ->SetPrivate(isolate->GetCurrentContext(), shouldFormatAccessorsPrivate,
                      v8::Null(isolate))
         .ToChecked();
   }
 };
 
-class FrontendChannelImpl : public InspectorClientImpl::FrontendChannel {
+class FrontendChannelImpl : public IsolateData::FrontendChannel {
  public:
   FrontendChannelImpl(TaskRunner* frontend_task_runner, int context_group_id)
       : frontend_task_runner_(frontend_task_runner),
         context_group_id_(context_group_id) {}
   virtual ~FrontendChannelImpl() {}
 
   void SendMessageToFrontend(int session_id,
                              const v8_inspector::StringView& message) final {
     frontend_task_runner_->Append(new SendMessageToFrontendTask(
         context_group_id_, session_id, ToVector(message)));
@@ skipping 66 matching lines @@
     frontend_runner.Append(
         new ExecuteStringTask(chars, frontend_context_group_id));
   }
 
   frontend_runner.Join();
   backend_runner.Join();
 
   delete startup_data.data;
   return 0;
 }