深入理解 V8 Inspector中几个关键的角色

[[430568]]

前言：本文介绍一下 V8 关于 Inspector 的实现，不过不会涉及到具体命令的实现，V8 Inspector 的命令非常多，了解了处理流程后，如果对某个命令感兴趣的话，可以单独去分析。

首先来看一下 V8 Inspector 中几个关键的角色。

 V8InspectorSession

class V8_EXPORT V8InspectorSession { 
 public: 
  // 收到对端端消息，调用这个方法判断是否可以分发 
  static bool canDispatchMethod(StringView method); 
  // 收到对端端消息，调用这个方法判断分发 
  virtual void dispatchProtocolMessage(StringView message) = 0; 
 
}; 

V8InspectorSession 是一个基类，本身实现了 canDispatchMethod 方法，由子类实现 dispatchProtocolMessage 方法。看一下 canDispatchMethod 的实现。

bool V8InspectorSession::canDispatchMethod(StringView method) { 
  return stringViewStartsWith(method, 
                              protocol::Runtime::Metainfo::commandPrefix) || 
         stringViewStartsWith(method, 
                              protocol::Debugger::Metainfo::commandPrefix) || 
         stringViewStartsWith(method, 
                              protocol::Profiler::Metainfo::commandPrefix) || 
         stringViewStartsWith( 
             method, protocol::HeapProfiler::Metainfo::commandPrefix) || 
         stringViewStartsWith(method, 
                              protocol::Console::Metainfo::commandPrefix) || 
         stringViewStartsWith(method, 
                              protocol::Schema::Metainfo::commandPrefix); 
 
} 

canDispatchMethod 决定了 V8 目前支持哪些命令。接着看一下 V8InspectorSession 子类的实现。

class V8InspectorSessionImpl : public V8InspectorSession, 
                               public protocol::FrontendChannel { 
 public: 
  // 静态方法，用于创建 V8InspectorSessionImpl 
  static std::unique_ptr<V8InspectorSessionImpl> create(V8InspectorImpl*, 
                                                        int contextGroupId, 
                                                        int sessionId, 
                                                        V8Inspector::Channel*, 
                                                        StringView state); 
  // 实现命令的分发 
  void dispatchProtocolMessage(StringView message) override; 
  // 支持哪些命令 
  std::vector<std::unique_ptr<protocol::Schema::API::Domain>> supportedDomains() override; 
 
 private: 
  // 发送消息给对端 
  void SendProtocolResponse(int callId, std::unique_ptr<protocol::Serializable> message) override; 
  void SendProtocolNotification(std::unique_ptr<protocol::Serializable> message) override; 
 
  // 会话 id 
  int m_sessionId; 
  // 关联的 V8Inspector 对象 
  V8InspectorImpl* m_inspector; 
  // 关联的 channel，channel 表示会话的两端 
  V8Inspector::Channel* m_channel; 
  // 处理命令分发对象 
  protocol::UberDispatcher m_dispatcher; 
  // 处理某种命令的代理对象 
  std::unique_ptr<V8RuntimeAgentImpl> m_runtimeAgent; 
  std::unique_ptr<V8DebuggerAgentImpl> m_debuggerAgent; 
  std::unique_ptr<V8HeapProfilerAgentImpl> m_heapProfilerAgent; 
  std::unique_ptr<V8ProfilerAgentImpl> m_profilerAgent; 
  std::unique_ptr<V8ConsoleAgentImpl> m_consoleAgent; 
  std::unique_ptr<V8SchemaAgentImpl> m_schemaAgent; 
 
}; 

下面看一下核心方法的具体实现。

创建 V8InspectorSessionImpl

V8InspectorSessionImpl::V8InspectorSessionImpl(V8InspectorImpl* inspector, 
                                               int contextGroupId, 
                                               int sessionId, 
                                               V8Inspector::Channel* channel, 
                                               StringView savedState) 
    : m_contextGroupId(contextGroupId), 
      m_sessionId(sessionId), 
      m_inspector(inspector), 
      m_channel(channel), 
      m_customObjectFormatterEnabled(false), 
      m_dispatcher(this), 
      m_state(ParseState(savedState)), 
      m_runtimeAgent(nullptr), 
      m_debuggerAgent(nullptr), 
      m_heapProfilerAgent(nullptr), 
      m_profilerAgent(nullptr), 
      m_consoleAgent(nullptr), 
      m_schemaAgent(nullptr) { 
 
  m_runtimeAgent.reset(new V8RuntimeAgentImpl(this, this, agentState(protocol::Runtime::Metainfo::domainName))); 
  protocol::Runtime::Dispatcher::wire(&m_dispatcher, m_runtimeAgent.get()); 
 
  m_debuggerAgent.reset(new V8DebuggerAgentImpl(this, this, agentState(protocol::Debugger::Metainfo::domainName))); 
  protocol::Debugger::Dispatcher::wire(&m_dispatcher, m_debuggerAgent.get()); 
 
  m_profilerAgent.reset(new V8ProfilerAgentImpl(this, this, agentState(protocol::Profiler::Metainfo::domainName))); 
  protocol::Profiler::Dispatcher::wire(&m_dispatcher, m_profilerAgent.get()); 
 
  m_heapProfilerAgent.reset(new V8HeapProfilerAgentImpl(this, this, agentState(protocol::HeapProfiler::Metainfo::domainName))); 
  protocol::HeapProfiler::Dispatcher::wire(&m_dispatcher,m_heapProfilerAgent.get()); 
 
  m_consoleAgent.reset(new V8ConsoleAgentImpl(this, this, agentState(protocol::Console::Metainfo::domainName))); 
  protocol::Console::Dispatcher::wire(&m_dispatcher, m_consoleAgent.get()); 
 
  m_schemaAgent.reset(new V8SchemaAgentImpl(this, this, agentState(protocol::Schema::Metainfo::domainName))); 
  protocol::Schema::Dispatcher::wire(&m_dispatcher, m_schemaAgent.get()); 
 
} 

V8 支持很多种命令，在创建 V8InspectorSessionImpl 对象时，会注册所有命令和处理该命令的处理器。我们一会单独分析。

 接收请求

void V8InspectorSessionImpl::dispatchProtocolMessage(StringView message) { 
  using v8_crdtp::span; 
  using v8_crdtp::SpanFrom; 
  span<uint8_t> cbor; 
  std::vector<uint8_t> converted_cbor; 
  if (IsCBORMessage(message)) { 
    use_binary_protocol_ = true; 
    m_state->setBoolean("use_binary_protocol", true); 
    cbor = span<uint8_t>(message.characters8(), message.length()); 
  } else { 
    auto status = ConvertToCBOR(message, &converted_cbor); 
    cbor = SpanFrom(converted_cbor); 
  } 
  v8_crdtp::Dispatchable dispatchable(cbor); 
  // 消息分发 
  m_dispatcher.Dispatch(dispatchable).Run(); 
 
} 

接收消息后，在内部通过 m_dispatcher.Dispatch 进行分发，这就好比我们在 Node.js 里收到请求后，根据路由分发一样。具体的分发逻辑一会单独分析。3. 响应请求

void V8InspectorSessionImpl::SendProtocolResponse( 
    int callId, std::unique_ptr<protocol::Serializable> message) { 
  m_channel->sendResponse(callId, serializeForFrontend(std::move(message))); 
 
} 

具体的处理逻辑由 channel 实现，channel 由 V8 的使用者实现，比如 Node.js。

数据推送

void V8InspectorSessionImpl::SendProtocolNotification( 
    std::unique_ptr<protocol::Serializable> message) { 
  m_channel->sendNotification(serializeForFrontend(std::move(message))); 
 
} 

除了一个请求对应一个响应，V8 Inspector 还需要主动推送的能力，具体处理逻辑也是由 channel 实现。从上面点分析可以看到 V8InspectorSessionImpl 的概念相当于一个服务器，在启动的时候注册了一系列路由，当建立一个连接时，就会创建一个 Channel 对象表示。调用方可以通过 Channel 完成请求和接收响应。结构如下图所示。

 V8Inspector

class V8_EXPORT V8Inspector { 
 public: 
  // 静态方法，用于创建 V8Inspector 
  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*); 
  // 用于创建一个 V8InspectorSession 
  virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId, 
                                                      Channel*, 
                                                      StringView state) = 0; 
 
}; 

V8Inspector 是一个通信的总管，他不负责具体的通信，他只是负责管理通信者，Channel 才是负责通信的角色。下面看一下 V8Inspector 子类的实现 。

class V8InspectorImpl : public V8Inspector { 
 public: 
  V8InspectorImpl(v8::Isolate*, V8InspectorClient*); 
  // 创建一个会话 
  std::unique_ptr<V8InspectorSession> connect(int contextGroupId, 
                                              V8Inspector::Channel*, 
                                              StringView state) override; 
 
 private: 
  v8::Isolate* m_isolate; 
  // 关联的 V8InspectorClient 对象，V8InspectorClient 封装了 V8Inspector，由调用方实现 
  V8InspectorClient* m_client; 
  // 保存所有的会话 
  std::unordered_map<int, std::map<int, V8InspectorSessionImpl*>> m_sessions; 
 
}; 

V8InspectorImpl 提供了创建会话的方法并保存了所有创建的会话，看一下创建会话的逻辑。

std::unique_ptr<V8InspectorSession> V8InspectorImpl::connect(int contextGroupId, V8Inspector::Channel* channel, StringView state) { 
  int sessionId = ++m_lastSessionId; 
  std::unique_ptr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId, sessionId, channel, state); 
  m_sessions[contextGroupId][sessionId] = session.get(); 
  return std::move(session); 
 
} 

connect 是创建了一个 V8InspectorSessionImpl 对象，并通过 id 保存到 map中。结构图如下。

UberDispatcher

UberDispatcher 是一个命令分发器。

class UberDispatcher { 
 public: 
  // 表示分发结果的对象 
  class DispatchResult {}; 
  // 分发处理函数 
  DispatchResult Dispatch(const Dispatchable& dispatchable) const; 
  // 注册命令和处理器  
  void WireBackend(span<uint8_t> domain, 
                   const std::vector<std::pair<span<uint8_t>, span<uint8_t>>>&, 
                   std::unique_ptr<DomainDispatcher> dispatcher); 
 
 private: 
  // 查找命令对应的处理器，Dispatch 中使用 
  DomainDispatcher* findDispatcher(span<uint8_t> method); 
  // 关联的 channel 
  FrontendChannel* const frontend_channel_; 
  std::vector<std::pair<span<uint8_t>, span<uint8_t>>> redirects_; 
  // 命令处理器队列 
  std::vector<std::pair<span<uint8_t>, std::unique_ptr<DomainDispatcher>>> 
      dispatchers_; 
 
}; 

下面看一下注册和分发的实现。

注册

void UberDispatcher::WireBackend(span<uint8_t> domain, std::unique_ptr<DomainDispatcher> dispatcher) { 
  dispatchers_.insert(dispatchers_.end(), std::make_pair(domain, std::move(dispatcher)));); 
 
} 

WireBackend 就是在队列里插入一个新的 domain 和 处理器组合。

分发命令

UberDispatcher::DispatchResult UberDispatcher::Dispatch( 
    const Dispatchable& dispatchable) const { 
  span<uint8_t> method = FindByFirst(redirects_, dispatchable.Method(), 
                                     /*default_value=*/dispatchable.Method()); 
  // 找到 . 的偏移，命令格式是 A.B                                    
  size_t dot_idx = DotIdx(method); 
  // 拿到 domain，即命令的第一部分 
  span<uint8_t> domain = method.subspan(0, dot_idx); 
  // 拿到命令 
  span<uint8_t> command = method.subspan(dot_idx + 1); 
  // 通过 domain 查找对应的处理器 
  DomainDispatcher* dispatcher = FindByFirst(dispatchers_, domain); 
  if (dispatcher) { 
    // 交给 domain 对应的处理器继续处理 
    std::function<void(const Dispatchable&)> dispatched = 
        dispatcher->Dispatch(command); 
    if (dispatched) { 
      return DispatchResult( 
          true, [dispatchable, dispatched = std::move(dispatched)]() { 
            dispatched(dispatchable); 
          }); 
    } 
  } 
 
} 

 DomainDispatcher

刚才分析了 UberDispatcher，UberDispatcher 是一个命令一级分发器，因为命令是 domain.cmd 的格式，UberDispatcher 是根据 domain 进行初步分发，DomainDispatcher 则是找到具体命令对应的处理器。

class DomainDispatcher { 
  // 分发逻辑，子类实现 
  virtual std::function<void(const Dispatchable&)> Dispatch(span<uint8_t> command_name) = 0; 
 
  // 处理完后响应 
  void sendResponse(int call_id, 
                    const DispatchResponse&, 
                    std::unique_ptr<Serializable> result = nullptr); 
 private: 
  // 关联的 channel 
  FrontendChannel* frontend_channel_; 
 
}; 

DomainDispatcher 定义了命令分发和响应的逻辑，不同的 domain 的分发逻辑会有不同的实现，但是响应逻辑是一样的，所以基类实现了。

void DomainDispatcher::sendResponse(int call_id, 
                                    const DispatchResponse& response, 
                                    std::unique_ptr<Serializable> result) { 
  std::unique_ptr<Serializable> serializable; 
  if (response.IsError()) { 
    serializable = CreateErrorResponse(call_id, response); 
  } else { 
    serializable = CreateResponse(call_id, std::move(result)); 
  } 
  frontend_channel_->SendProtocolResponse(call_id, std::move(serializable)); 
 
} 

通过 frontend_channel_ 返回响应。接下来看子类的实现，这里以 HeapProfiler 为例。

class DomainDispatcherImpl : public protocol::DomainDispatcher { 
public: 
    DomainDispatcherImpl(FrontendChannel* frontendChannel, Backend* backend) 
        : DomainDispatcher(frontendChannel) 
        , m_backend(backend) {} 
    ~DomainDispatcherImpl() override { } 
 
    using CallHandler = void (DomainDispatcherImpl::*)(const v8_crdtp::Dispatchable& dispatchable); 
    // 分发的实现 
    std::function<void(const v8_crdtp::Dispatchable&)> Dispatch(v8_crdtp::span<uint8_t> command_name) override; 
    // HeapProfiler 支持的命令 
    void addInspectedHeapObject(const v8_crdtp::Dispatchable& dispatchable); 
    void collectGarbage(const v8_crdtp::Dispatchable& dispatchable); 
    void disable(const v8_crdtp::Dispatchable& dispatchable); 
    void enable(const v8_crdtp::Dispatchable& dispatchable); 
    void getHeapObjectId(const v8_crdtp::Dispatchable& dispatchable); 
    void getObjectByHeapObjectId(const v8_crdtp::Dispatchable& dispatchable); 
    void getSamplingProfile(const v8_crdtp::Dispatchable& dispatchable); 
    void startSampling(const v8_crdtp::Dispatchable& dispatchable); 
    void startTrackingHeapObjects(const v8_crdtp::Dispatchable& dispatchable); 
    void stopSampling(const v8_crdtp::Dispatchable& dispatchable); 
    void stopTrackingHeapObjects(const v8_crdtp::Dispatchable& dispatchable); 
    void takeHeapSnapshot(const v8_crdtp::Dispatchable& dispatchable); 
 protected: 
    Backend* m_backend; 
 
}; 

DomainDispatcherImpl 定义了 HeapProfiler 支持的命令，下面分析一下命令的注册和分发的处理逻辑。下面是 HeapProfiler 注册 domain 和 处理器的逻辑(创建 V8InspectorSessionImpl 时)

// backend 是处理命令的具体对象，对于 HeapProfiler domain 是 V8HeapProfilerAgentImpl 
 
void Dispatcher::wire(UberDispatcher* uber, Backend* backend){    
     
 
    // channel 是通信的对端 
    auto dispatcher = std::make_unique<DomainDispatcherImpl>(uber->channel(), backend); 
    // 注册 domain 对应的处理器 
    uber->WireBackend(v8_crdtp::SpanFrom("HeapProfiler"), std::move(dispatcher)); 
 
} 

接下来看一下收到命令时具体的分发逻辑。

std::function<void(const v8_crdtp::Dispatchable&)> DomainDispatcherImpl::Dispatch(v8_crdtp::span<uint8_t> command_name) { 
  // 根据命令查找处理函数 
  CallHandler handler = CommandByName(command_name); 
  // 返回个函数，外层执行 
  return [this, handler](const v8_crdtp::Dispatchable& dispatchable) { 
    (this->*handler)(dispatchable); 
  }; 
 
} 

看一下查找的逻辑。

DomainDispatcherImpl::CallHandler CommandByName(v8_crdtp::span<uint8_t> command_name) { 
  static auto* commands = [](){ 
    auto* commands = new std::vector<std::pair<v8_crdtp::span<uint8_t>, DomainDispatcherImpl::CallHandler>>{ 
        // 太多，不一一列举 
        { 
          v8_crdtp::SpanFrom("enable"), 
          &DomainDispatcherImpl::enable 
        }, 
    }; 
    return commands; 
  }(); 
  return v8_crdtp::FindByFirst<DomainDispatcherImpl::CallHandler>(*commands, command_name, nullptr); 
 
} 

再看一下 DomainDispatcherImpl::enable 的实现。

void DomainDispatcherImpl::enable(const v8_crdtp::Dispatchable& dispatchable){ 
    std::unique_ptr<DomainDispatcher::WeakPtr> weak = weakPtr(); 
    // 调用 m_backend 也就是 V8HeapProfilerAgentImpl 的 enable 
    DispatchResponse response = m_backend->enable(); 
    if (response.IsFallThrough()) { 
        channel()->FallThrough(dispatchable.CallId(), v8_crdtp::SpanFrom("HeapProfiler.enable"), dispatchable.Serialized()); 
        return; 
    } 
    if (weak->get()) 
        weak->get()->sendResponse(dispatchable.CallId(), response); 
    return; 
 
} 

DomainDispatcherImpl 只是封装，具体的命令处理交给 m_backend 所指向的对象，这里是 V8HeapProfilerAgentImpl。下面是 V8HeapProfilerAgentImpl enable 的实现。

Response V8HeapProfilerAgentImpl::enable() { 
  m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, true); 
  return Response::Success(); 
 
} 

结构图如下。

V8HeapProfilerAgentImpl

刚才分析了 V8HeapProfilerAgentImpl 的 enable 函数，这里以 V8HeapProfilerAgentImpl 为例子分析一下命令处理器类的逻辑。

class V8HeapProfilerAgentImpl : public protocol::HeapProfiler::Backend { 
 public: 
  V8HeapProfilerAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*, 
                          protocol::DictionaryValue* state); 
 
 private: 
 
  V8InspectorSessionImpl* m_session; 
  v8::Isolate* m_isolate; 
  // protocol::HeapProfiler::Frontend 定义了支持哪些事件 
  protocol::HeapProfiler::Frontend m_frontend; 
  protocol::DictionaryValue* m_state; 
 
}; 

V8HeapProfilerAgentImpl 通过 protocol::HeapProfiler::Frontend 定义了支持的事件，因为 Inspector 不仅可以处理调用方发送的命令，还可以主动给调用方推送消息，这种推送就是以事件的方式触发的。

class  Frontend { 
public: 
  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {} 
    void addHeapSnapshotChunk(const String& chunk); 
    void heapStatsUpdate(std::unique_ptr<protocol::Array<int>> statsUpdate); 
    void lastSeenObjectId(int lastSeenObjectId, double timestamp); 
    void reportHeapSnapshotProgress(int done, int total, Maybe<bool> finished = Maybe<bool>()); 
    void resetProfiles(); 
 
  void flush(); 
  void sendRawNotification(std::unique_ptr<Serializable>); 
 private: 
  // 指向 V8InspectorSessionImpl 对象 
  FrontendChannel* frontend_channel_; 
 
}; 

下面看一下 addHeapSnapshotChunk，这是获取堆快照时用到的逻辑。

void Frontend::addHeapSnapshotChunk(const String& chunk){ 
    v8_crdtp::ObjectSerializer serializer; 
    serializer.AddField(v8_crdtp::MakeSpan("chunk"), chunk); 
    frontend_channel_->SendProtocolNotification(v8_crdtp::CreateNotification("HeapProfiler.addHeapSnapshotChunk", serializer.Finish())); 
 
} 

最终触发了 HeapProfiler.addHeapSnapshotChunk 事件。另外 V8HeapProfilerAgentImpl 继承了 Backend 定义了支持哪些请求命令和 DomainDispatcherImpl 中的函数对应，比如获取堆快照。

class  Backend { 
public: 
    virtual ~Backend() { } 
    // 不一一列举 
    virtual DispatchResponse takeHeapSnapshot(Maybe<bool> in_reportProgress, Maybe<bool> in_treatGlobalObjectsAsRoots, Maybe<bool> in_captureNumericValue) = 0; 
 
}; 

结构图如下。

Node.js 对 V8 Inspector 的封装

接下来看一下 Node.js 中是如何使用 V8 Inspector 的，V8 Inspector 的使用方需要实现 V8InspectorClient 和 V8Inspector::Channel。下面看一下 Node.js 的实现。

class NodeInspectorClient : public V8InspectorClient { 
 public: 
  explicit NodeInspectorClient() { 
    // 创建一个 V8Inspector 
    client_ = V8Inspector::create(env->isolate(), this); 
  } 
 
  int connectFrontend(std::unique_ptr<InspectorSessionDelegate> delegate, 
                      bool prevent_shutdown) { 
    int session_id = next_session_id_++; 
    channels_[session_id] = std::make_unique<ChannelImpl>(env_, 
                                                          client_, 
                                                          getWorkerManager(), 
                                                          // 收到数据后由 delegate 处理 
                                                          std::move(delegate), 
                                                          getThreadHandle(), 
                                                          prevent_shutdown); 
    return session_id; 
  } 
 
  std::unique_ptr<V8Inspector> client_; 
  std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_; 
 
}; 

NodeInspectorClient 封装了 V8Inspector，并且维护了多个 channel。Node.js 的上层代码可以通过 connectFrontend 连接到 V8 Inspector，并拿到 session_id，这个连接用 ChannelImpl 来实现，来看一下 ChannelImpl 的实现。

explicit ChannelImpl(const std::unique_ptr<V8Inspector>& inspector,  
                     std::unique_ptr<InspectorSessionDelegate> delegate):  
                     // delegate_ 负责处理 V8 发过来的数据 
                     delegate_(std::move(delegate)) { 
    session_ = inspector->connect(CONTEXT_GROUP_ID, this, StringView()); 
 
} 

ChannelImpl 是对 V8InspectorSession 的封装，通过 V8InspectorSession 实现发送命令，ChannelImpl 自己实现了接收响应和接收 V8 推送数据的逻辑。了解了封装 V8 Inspector 的能力后，通过一个例子看一下整个处理过程。通常我们通过以下方式和 V8 Inspector 通信。

const { Session } = require('inspector'); 
new Session().connect(); 

我们从 connect 开始分析。

connect() { 
    this[connectionSymbol] = new Connection((message) => this[onMessageSymbol](message)); 
} 

新建一个 C++ 层的对象 JSBindingsConnection。

JSBindingsConnection(Environment* env, 
                       Local<Object> wrap, 
                       Local<Function> callback) 
                       : AsyncWrap(env, wrap, PROVIDER_INSPECTORJSBINDING), 
                         callback_(env->isolate(), callback) { 
    Agent* inspector = env->inspector_agent(); 
    session_ = LocalConnection::Connect(inspector, std::make_unique<JSBindingsSessionDelegate>(env, this));}static std::unique_ptr<InspectorSession> Connect( 
     Agent* inspector, std::unique_ptr<InspectorSessionDelegate> delegate) { 
   return inspector->Connect(std::move(delegate), false); 
 
} 
 
 
std::unique_ptr<InspectorSession> Agent::Connect( 
    std::unique_ptr<InspectorSessionDelegate> delegate, 
    bool prevent_shutdown) { 
  int session_id = client_->connectFrontend(std::move(delegate), 
                                            prevent_shutdown); 
  return std::unique_ptr<InspectorSession>( 
      new SameThreadInspectorSession(session_id, client_)); 
 
} 

JSBindingsConnection 初始化时会通过 agent->Connect 最终调用 Agent::Connect 建立到 V8 的通道，并传入 JSBindingsSessionDelegate 作为数据处理的代理(channel 中使用)。最后返回一个 SameThreadInspectorSession 对象保存到 session_ 中，后续就可以开始通信了，继续看一下 通过 JS 层的 post 发送请求时的逻辑。

post(method, params, callback) { 
    const id = this[nextIdSymbol]++; 
    const message = { id, method }; 
    if (params) { 
      message.params = params; 
    } 
    if (callback) { 
      this[messageCallbacksSymbol].set(id, callback); 
    } 
    this[connectionSymbol].dispatch(JSONStringify(message)); 
} 

为每一个请求生成一个 id，因为是异步返回的，最后调用 dispatch 函数。

static void Dispatch(const FunctionCallbackInfo<Value>& info) { 
    Environment* env = Environment::GetCurrent(info); 
    JSBindingsConnection* session; 
    ASSIGN_OR_RETURN_UNWRAP(&session, info.Holder()); 
 
    if (session->session_) { 
      session->session_->Dispatch( 
          ToProtocolString(env->isolate(), info[0])->string()); 
    } 
} 

看一下 SameThreadInspectorSession::Dispatch (即session->session_->Dispatch)。

void SameThreadInspectorSession::Dispatch( 
    const v8_inspector::StringView& message) { 
  auto client = client_.lock(); 
  if (client) 
    client->dispatchMessageFromFrontend(session_id_, message); 
 
} 

SameThreadInspectorSession 中维护了一个sessionId，继续调用 client->dispatchMessageFromFrontend， client 是 NodeInspectorClient 对象。

void dispatchMessageFromFrontend(int session_id, const StringView& message) { 
   channels_[session_id]->dispatchProtocolMessage(message); 
} 

dispatchMessageFromFrontend 通过 sessionId 找到对应的 channel。继续调 channel 的 dispatchProtocolMessage。

void dispatchProtocolMessage(const StringView& message) { 
    std::string raw_message = protocol::StringUtil::StringViewToUtf8(message); 
    std::unique_ptr<protocol::DictionaryValue> value = 
        protocol::DictionaryValue::cast(protocol::StringUtil::parseMessage( 
            raw_message, false)); 
    int call_id; 
    std::string method; 
    node_dispatcher_->parseCommand(value.get(), &call_id, &method); 
    if (v8_inspector::V8InspectorSession::canDispatchMethod( 
            Utf8ToStringView(method)->string())) { 
      session_->dispatchProtocolMessage(message); 
    } 
} 

最终调用 V8InspectorSessionImpl 的 session_->dispatchProtocolMessage(message)，后面的内容前面就讲过了，就不再分析。最后看一下数据响应或者推送时的逻辑。下面代码来自 ChannelImpl。

void sendResponse( 
  int callId, 
    std::unique_ptr<v8_inspector::StringBuffer> message) override { 
  sendMessageToFrontend(message->string()); 
 
} 
 
 
 
void sendNotification( 
 
    std::unique_ptr<v8_inspector::StringBuffer> message) override { 
  sendMessageToFrontend(message->string()); 
 
} 
 
 
 
void sendMessageToFrontend(const StringView& message) { 
 
  delegate_->SendMessageToFrontend(message); 
 
} 

我们看到最终调用了 delegate_->SendMessageToFrontend， delegate 是 JSBindingsSessionDelegate对象。

void SendMessageToFrontend(const v8_inspector::StringView& message) 
        override { 
  Isolate* isolate = env_->isolate(); 
  HandleScope handle_scope(isolate); 
  Context::Scope context_scope(env_->context()); 
  MaybeLocal<String> v8string = String::NewFromTwoByte(isolate, message.characters16(), 
                             NewStringType::kNormal, message.length()); 
  Local<Value> argument = v8string.ToLocalChecked().As<Value>(); 
  connection_->OnMessage(argument); 
 
} 

接着调用 connection_->OnMessage(argument)，connection 是 JSBindingsConnection 对象。

void OnMessage(Local<Value> value) { 
  MakeCallback(callback_.Get(env()->isolate()), 1, &value); 
 
} 

C++ 层回调 JS 层。

[onMessageSymbol](message) { 
    const parsed = JSONParse(message); 
    try { 
      // 通过有没有 id 判断是响应还是推送 
      if (parsed.id) { 
        const callback = this[messageCallbacksSymbol].get(parsed.id); 
        this[messageCallbacksSymbol].delete(parsed.id); 
        if (callback) { 
          if (parsed.error) { 
            return callback(new ERR_INSPECTOR_COMMAND(parsed.error.code, 
                                                      parsed.error.message)); 
          } 
 
          callback(null, parsed.result); 
        } 
      } else { 
        this.emit(parsed.method, parsed); 
        this.emit('inspectorNotification', parsed); 
      } 
    } catch (error) { 
      process.emitWarning(error); 
    } 
} 

以上就完成了整个链路的分析。整体结构图如下。

总结

V8 Inspector 的设计和实现上比较复杂，对象间关系错综复杂。因为 V8 提供调试和诊断 JS 的文档似乎不多，也不是很完善，就是简单描述一下命令是干啥的，很多时候不一定够用，了解了具体实现后，后续碰到问题，可以自己去看具体实现。