[inspector] Cleanup inspector test

test/inspector/isolate-data.h

 // Copyright 2017 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_ISOLATE_DATA_H_
 #define V8_TEST_INSPECTOR_PROTOCOL_ISOLATE_DATA_H_
 
 #include <map>
 
 #include "include/v8-inspector.h"
 #include "include/v8-platform.h"
 #include "include/v8.h"
 #include "src/base/macros.h"
 #include "src/base/platform/platform.h"
 #include "src/vector.h"
 
 class TaskRunner;
 
 class IsolateData : public v8_inspector::V8InspectorClient {
  public:
   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>>;
 
-  class FrontendChannel {
-   public:
-    virtual ~FrontendChannel() = default;
-    virtual void SendMessageToFrontend(
-        int session_id, const v8_inspector::StringView& message) = 0;
-  };
-
   IsolateData(TaskRunner* task_runner, SetupGlobalTasks setup_global_tasks,
-              v8::StartupData* startup_data, FrontendChannel* channel);
+              v8::StartupData* startup_data, bool with_inspector);
   static IsolateData* FromContext(v8::Local<v8::Context> context);
 
   v8::Isolate* isolate() const { return isolate_; }
-  v8_inspector::V8Inspector* inspector() const { return inspector_.get(); }
   TaskRunner* task_runner() const { return task_runner_; }
 
   // Setting things up.
   int CreateContextGroup();
   v8::Local<v8::Context> GetContext(int context_group_id);
   int GetContextGroupId(v8::Local<v8::Context> context);
   void RegisterModule(v8::Local<v8::Context> context,
                       v8::internal::Vector<uint16_t> name,
                       v8::ScriptCompiler::Source* source);
 
   // Working with V8Inspector api.
   int ConnectSession(int context_group_id,
-                     const v8_inspector::StringView& state);
+                     const v8_inspector::StringView& state,
+                     v8_inspector::V8Inspector::Channel* channel);
   std::unique_ptr<v8_inspector::StringBuffer> DisconnectSession(int session_id);
   void SendMessage(int session_id, const v8_inspector::StringView& message);
   void BreakProgram(int context_group_id,
                     const v8_inspector::StringView& reason,
                     const v8_inspector::StringView& details);
   void SchedulePauseOnNextStatement(int context_group_id,
                                     const v8_inspector::StringView& reason,
                                     const v8_inspector::StringView& details);
   void CancelPauseOnNextStatement(int context_group_id);
+  void AsyncTaskScheduled(const v8_inspector::StringView& name, void* task,
+                          bool recurring);
+  void AsyncTaskStarted(void* task);
+  void AsyncTaskFinished(void* task);
 
   // Test utilities.
   void SetCurrentTimeMS(double time);
   void SetMemoryInfo(v8::Local<v8::Value> memory_info);
   void SetLogConsoleApiMessageCalls(bool log);
+  void SetMaxAsyncTaskStacksForTest(int limit);
+  void DumpAsyncTaskStacksStateForTest();
   void FireContextCreated(v8::Local<v8::Context> context, int context_group_id);
   void FireContextDestroyed(v8::Local<v8::Context> context);
 
  private:
   struct VectorCompare {
     bool operator()(const v8::internal::Vector<uint16_t>& lhs,
                     const v8::internal::Vector<uint16_t>& rhs) const {
       for (int i = 0; i < lhs.length() && i < rhs.length(); ++i) {
         if (lhs[i] != rhs[i]) return lhs[i] < rhs[i];
       }
@@ skipping 28 matching lines @@
   v8::Isolate* isolate_;
   std::unique_ptr<v8_inspector::V8Inspector> inspector_;
   int last_context_group_id_ = 0;
   std::map<int, v8::Global<v8::Context>> contexts_;
   std::map<v8::internal::Vector<uint16_t>, v8::Global<v8::Module>,
            VectorCompare>
       modules_;
   int last_session_id_ = 0;
   std::map<int, std::unique_ptr<v8_inspector::V8InspectorSession>> sessions_;
   std::map<v8_inspector::V8InspectorSession*, int> context_group_by_session_;
-  std::map<int, std::unique_ptr<v8_inspector::V8Inspector::Channel>> channels_;
   v8::Global<v8::Value> memory_info_;
-  FrontendChannel* frontend_channel_;
   bool current_time_set_ = false;
   double current_time_ = 0.0;
   bool log_console_api_message_calls_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateData);
 };
 
 #endif  //  V8_TEST_INSPECTOR_PROTOCOL_ISOLATE_DATA_H_