@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/fs_permission.h

@@ -0,0 +1,167 @@
+#ifndef SRC_PERMISSION_FS_PERMISSION_H_
+#define SRC_PERMISSION_FS_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+
+#include <unordered_map>
+#include "permission/permission_base.h"
+#include "util.h"
+
+namespace node {
+
+namespace permission {
+
+class FSPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param) const override;
+
+  struct RadixTree {
+    struct Node {
+      std::string prefix;
+      std::unordered_map<char, Node*> children;
+      Node* wildcard_child;
+      bool is_leaf;
+
+      explicit Node(const std::string& pre)
+          : prefix(pre), wildcard_child(nullptr), is_leaf(false) {}
+
+      Node() : wildcard_child(nullptr), is_leaf(false) {}
+
+      Node* CreateChild(const std::string& path_prefix) {
+        if (path_prefix.empty() && !is_leaf) {
+          is_leaf = true;
+          return this;
+        }
+
+        CHECK(!path_prefix.empty());
+        char label = path_prefix[0];
+
+        Node* child = children[label];
+        if (child == nullptr) {
+          children[label] = new Node(path_prefix);
+          return children[label];
+        }
+
+        // swap prefix
+        size_t i = 0;
+        size_t prefix_len = path_prefix.length();
+        for (; i < child->prefix.length(); ++i) {
+          if (i > prefix_len || path_prefix[i] != child->prefix[i]) {
+            std::string parent_prefix = child->prefix.substr(0, i);
+            std::string child_prefix = child->prefix.substr(i);
+
+            child->prefix = child_prefix;
+            Node* split_child = new Node(parent_prefix);
+            split_child->children[child_prefix[0]] = child;
+            children[parent_prefix[0]] = split_child;
+
+            return split_child->CreateChild(path_prefix.substr(i));
+          }
+        }
+        child->is_leaf = true;
+        return child->CreateChild(path_prefix.substr(i));
+      }
+
+      Node* CreateWildcardChild() {
+        if (wildcard_child != nullptr) {
+          return wildcard_child;
+        }
+        wildcard_child = new Node();
+        return wildcard_child;
+      }
+
+      Node* NextNode(const std::string& path, size_t idx) const {
+        if (idx >= path.length()) {
+          return nullptr;
+        }
+
+        // wildcard node takes precedence
+        if (children.size() > 1) {
+          auto it = children.find('*');
+          if (it != children.end()) {
+            return it->second;
+          }
+        }
+
+        auto it = children.find(path[idx]);
+        if (it == children.end()) {
+          return nullptr;
+        }
+        auto child = it->second;
+        // match prefix
+        size_t prefix_len = child->prefix.length();
+        for (size_t i = 0; i < path.length(); ++i) {
+          if (i >= prefix_len || child->prefix[i] == '*') {
+            return child;
+          }
+
+          // Handle optional trailing
+          // path = /home/subdirectory
+          // child = subdirectory/*
+          if (idx >= path.length() &&
+              child->prefix[i] == node::kPathSeparator) {
+            continue;
+          }
+
+          if (path[idx++] != child->prefix[i]) {
+            return nullptr;
+          }
+        }
+        return child;
+      }
+
+      // A node can be a *end* node and have children
+      // E.g: */slower*, */slown* are inserted:
+      // /slow
+      // ---> er
+      // ---> n
+      // If */slow* is inserted right after, it will create an
+      // empty node
+      // /slow
+      // ---> '\000' ASCII (0) || \0
+      // ---> er
+      // ---> n
+      bool IsEndNode() const {
+        if (children.empty()) {
+          return true;
+        }
+        return is_leaf;
+      }
+    };
+
+    RadixTree();
+    ~RadixTree();
+    void Insert(const std::string& s);
+    bool Lookup(const std::string_view& s) const { return Lookup(s, false); }
+    bool Lookup(const std::string_view& s, bool when_empty_return) const;
+
+   private:
+    Node* root_node_;
+  };
+
+ private:
+  void GrantAccess(PermissionScope scope, const std::string& param);
+  // fs granted on startup
+  RadixTree granted_in_fs_;
+  RadixTree granted_out_fs_;
+
+  bool deny_all_in_ = true;
+  bool deny_all_out_ = true;
+
+  bool allow_all_in_ = false;
+  bool allow_all_out_ = false;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_FS_PERMISSION_H_

package/src/headers/{16 → 24}/handle_wrap.h

@@ -76,6 +76,8 @@ class HandleWrap : public AsyncWrap {
   virtual void Close(
       v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
 
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
@@ -97,6 +99,7 @@ class HandleWrap : public AsyncWrap {
   }
 
   static void OnClose(uv_handle_t* handle);
+  enum { kInitialized, kClosing, kClosed } state_;
 
  private:
   friend class Environment;
@@ -106,10 +109,9 @@ class HandleWrap : public AsyncWrap {
   // class because it is used by src/node_postmortem_metadata.cc to calculate
   // offsets and generate debug symbols for HandleWrap, which assumes that the
   // position of members in memory are predictable. For more information please
-  // refer to `doc/guides/node-postmortem-support.md`
+  // refer to `doc/contributing/node-postmortem-support.md`
   friend int GenDebugSymbols();
   ListNode<HandleWrap> handle_wrap_queue_;
-  enum { kInitialized, kClosing, kClosed } state_;
   uv_handle_t* const handle_;
 };
 

package/src/headers/{16 → 24}/histogram-inl.h

@@ -13,35 +13,49 @@ void Histogram::Reset() {
   Mutex::ScopedLock lock(mutex_);
   hdr_reset(histogram_.get());
   exceeds_ = 0;
+  count_ = 0;
   prev_ = 0;
 }
 
-int64_t Histogram::Min() {
+double Histogram::Add(const Histogram& other) {
+  Mutex::ScopedLock lock(mutex_);
+  count_ += other.count_;
+  exceeds_ += other.exceeds_;
+  if (other.prev_ > prev_)
+    prev_ = other.prev_;
+  return static_cast<double>(hdr_add(histogram_.get(), other.histogram_.get()));
+}
+
+size_t Histogram::Count() const {
+  Mutex::ScopedLock lock(mutex_);
+  return count_;
+}
+
+int64_t Histogram::Min() const {
   Mutex::ScopedLock lock(mutex_);
   return hdr_min(histogram_.get());
 }
 
-int64_t Histogram::Max() {
+int64_t Histogram::Max() const {
   Mutex::ScopedLock lock(mutex_);
   return hdr_max(histogram_.get());
 }
 
-double Histogram::Mean() {
+double Histogram::Mean() const {
   Mutex::ScopedLock lock(mutex_);
   return hdr_mean(histogram_.get());
 }
 
-double Histogram::Stddev() {
+double Histogram::Stddev() const {
   Mutex::ScopedLock lock(mutex_);
   return hdr_stddev(histogram_.get());
 }
 
-double Histogram::Percentile(double percentile) {
+int64_t Histogram::Percentile(double percentile) const {
   Mutex::ScopedLock lock(mutex_);
   CHECK_GT(percentile, 0);
   CHECK_LE(percentile, 100);
-  return static_cast<double>(
-      hdr_value_at_percentile(histogram_.get(), percentile));
+  return hdr_value_at_percentile(histogram_.get(), percentile);
 }
 
 template <typename Iterator>
@@ -51,26 +65,31 @@ void Histogram::Percentiles(Iterator&& fn) {
   hdr_iter_percentile_init(&iter, histogram_.get(), 1);
   while (hdr_iter_next(&iter)) {
     double key = iter.specifics.percentiles.percentile;
-    double value = static_cast<double>(iter.value);
-    fn(key, value);
+    fn(key, iter.value);
   }
 }
 
 bool Histogram::Record(int64_t value) {
   Mutex::ScopedLock lock(mutex_);
-  return hdr_record_value(histogram_.get(), value);
+  bool recorded = hdr_record_value(histogram_.get(), value);
+  if (!recorded)
+    exceeds_++;
+  else
+    count_++;
+  return recorded;
 }
 
 uint64_t Histogram::RecordDelta() {
   Mutex::ScopedLock lock(mutex_);
   uint64_t time = uv_hrtime();
-  uint64_t delta = 0;
+  int64_t delta = 0;
   if (prev_ > 0) {
+    CHECK_GE(time, prev_);
     delta = time - prev_;
-    if (delta > 0) {
-      if (!hdr_record_value(histogram_.get(), delta) && exceeds_ < 0xFFFFFFFF)
-        exceeds_++;
-    }
+    if (hdr_record_value(histogram_.get(), delta))
+      count_++;
+    else
+      exceeds_++;
   }
   prev_ = time;
   return delta;

package/src/headers/24/histogram.h

@@ -0,0 +1,279 @@
+#ifndef SRC_HISTOGRAM_H_
+#define SRC_HISTOGRAM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <hdr/hdr_histogram.h>
+#include "base_object.h"
+#include "memory_tracker.h"
+#include "node_messaging.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <functional>
+#include <limits>
+#include <map>
+#include <string>
+
+namespace node {
+
+class ExternalReferenceRegistry;
+
+constexpr int kDefaultHistogramFigures = 3;
+
+class Histogram : public MemoryRetainer {
+ public:
+  struct Options {
+    int64_t lowest = 1;
+    int64_t highest = std::numeric_limits<int64_t>::max();
+    int figures = kDefaultHistogramFigures;
+  };
+
+  explicit Histogram(const Options& options);
+  virtual ~Histogram() = default;
+
+  inline bool Record(int64_t value);
+  inline void Reset();
+  inline int64_t Min() const;
+  inline int64_t Max() const;
+  inline double Mean() const;
+  inline double Stddev() const;
+  inline int64_t Percentile(double percentile) const;
+  inline size_t Exceeds() const { return exceeds_; }
+  inline size_t Count() const;
+
+  inline uint64_t RecordDelta();
+
+  inline double Add(const Histogram& other);
+
+  // Iterator is a function type that takes two doubles as argument, one for
+  // percentile and one for the value at that percentile.
+  template <typename Iterator>
+  inline void Percentiles(Iterator&& fn);
+
+  inline size_t GetMemorySize() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Histogram)
+  SET_SELF_SIZE(Histogram)
+
+ private:
+  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
+  HistogramPointer histogram_;
+  uint64_t prev_ = 0;
+  size_t exceeds_ = 0;
+  size_t count_ = 0;
+  Mutex mutex_;
+};
+
+class HistogramImpl {
+ public:
+  enum InternalFields {
+    kSlot = BaseObject::kSlot,
+    kImplField = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
+  explicit HistogramImpl(
+      const Histogram::Options& options = Histogram::Options {});
+  explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
+
+  Histogram* operator->() { return histogram_.get(); }
+
+  const std::shared_ptr<Histogram>& histogram() const { return histogram_; }
+
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentileBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentilesBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastReset(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver);
+  static double FastGetCount(v8::Local<v8::Value> unused,
+                             v8::Local<v8::Value> receiver);
+  static double FastGetMin(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMax(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMean(v8::Local<v8::Value> unused,
+                            v8::Local<v8::Value> receiver);
+  static double FastGetExceeds(v8::Local<v8::Value> unused,
+                               v8::Local<v8::Value> receiver);
+  static double FastGetStddev(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+  static double FastGetPercentile(v8::Local<v8::Value> unused,
+                                  v8::Local<v8::Value> receiver,
+                                  const double percentile);
+
+  static void AddMethods(v8::Isolate* isolate,
+                         v8::Local<v8::FunctionTemplate> tmpl);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static HistogramImpl* FromJSObject(v8::Local<v8::Value> value);
+
+ private:
+  std::shared_ptr<Histogram> histogram_;
+
+  static v8::CFunction fast_reset_;
+  static v8::CFunction fast_get_count_;
+  static v8::CFunction fast_get_min_;
+  static v8::CFunction fast_get_max_;
+  static v8::CFunction fast_get_mean_;
+  static v8::CFunction fast_get_exceeds_;
+  static v8::CFunction fast_get_stddev_;
+  static v8::CFunction fast_get_percentile_;
+};
+
+class HistogramBase final : public BaseObject, public HistogramImpl {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  static void Initialize(IsolateData* isolate_data,
+                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      std::shared_ptr<Histogram> histogram);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HistogramBase)
+  SET_SELF_SIZE(HistogramBase)
+
+  static void Record(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RecordDelta(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastRecord(
+      v8::Local<v8::Value> unused,
+      v8::Local<v8::Value> receiver,
+      const int64_t value,
+      v8::FastApiCallbackOptions& options);  // NOLINT(runtime/references)
+  static void FastRecordDelta(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      const Histogram::Options& options = Histogram::Options {});
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      std::shared_ptr<Histogram> histogram);
+
+  BaseObject::TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class HistogramTransferData : public worker::TransferData {
+   public:
+    explicit HistogramTransferData(const HistogramBase* histogram)
+        : histogram_(histogram->histogram()) {}
+
+    explicit HistogramTransferData(std::shared_ptr<Histogram> histogram)
+        : histogram_(std::move(histogram)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(HistogramTransferData)
+    SET_SELF_SIZE(HistogramTransferData)
+
+   private:
+    std::shared_ptr<Histogram> histogram_;
+  };
+
+ private:
+  static v8::CFunction fast_record_;
+  static v8::CFunction fast_record_delta_;
+};
+
+class IntervalHistogram final : public HandleWrap, public HistogramImpl {
+ public:
+  enum class StartFlags {
+    NONE,
+    RESET
+  };
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<IntervalHistogram> Create(
+      Environment* env,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options);
+
+  IntervalHistogram(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      AsyncWrap::ProviderType type,
+      int32_t interval,
+      std::function<void(Histogram&)> on_interval,
+      const Histogram::Options& options = Histogram::Options {});
+
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastStart(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver,
+                        bool reset);
+  static void FastStop(v8::Local<v8::Value> unused,
+                       v8::Local<v8::Value> receiver);
+
+  BaseObject::TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(IntervalHistogram)
+  SET_SELF_SIZE(IntervalHistogram)
+
+ private:
+  static void TimerCB(uv_timer_t* handle);
+  void OnStart(StartFlags flags = StartFlags::RESET);
+  void OnStop();
+
+  bool enabled_ = false;
+  int32_t interval_ = 0;
+  std::function<void(Histogram&)> on_interval_;
+  uv_timer_t timer_;
+
+  static v8::CFunction fast_start_;
+  static v8::CFunction fast_stop_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_H_

package/src/headers/24/http3.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <env.h>
+#include <memory_tracker.h>
+#include "session.h"
+
+namespace node::quic {
+// Provides an implementation of the HTTP/3 Application implementation
+class Http3Application final : public Session::ApplicationProvider {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerIsolate(IsolateData* isolate_data,
+                             v8::Local<v8::ObjectTemplate> target);
+  static void InitPerContext(Realm* realm, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  Http3Application(Environment* env,
+                   v8::Local<v8::Object> object,
+                   const Session::Application_Options& options);
+
+  std::unique_ptr<Session::Application> Create(Session* session) override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(Http3Application)
+  SET_MEMORY_INFO_NAME(Http3Application)
+
+  std::string ToString() const;
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Session::Application_Options options_;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/{18 → 24}/inspector_agent.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "inspector/network_resource_manager.h"
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #if !HAVE_INSPECTOR
@@ -61,11 +62,23 @@ class Agent {
 
   // Blocks till frontend connects and sends "runIfWaitingForDebugger"
   void WaitForConnect();
+  bool WaitForConnectByOptions();
+  void StopIfWaitingForConnect();
+
   // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
   void WaitForDisconnect();
   void ReportUncaughtException(v8::Local<v8::Value> error,
                                v8::Local<v8::Message> message);
 
+  void EmitProtocolEvent(v8::Local<v8::Context> context,
+                         const v8_inspector::StringView& event,
+                         v8::Local<v8::Object> params);
+
+  void SetupNetworkTracking(v8::Local<v8::Function> enable_function,
+                            v8::Local<v8::Function> disable_function);
+  void EnableNetworkTracking();
+  void DisableNetworkTracking();
+
   // Async stack traces instrumentation.
   void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
                           bool recurring);
@@ -81,8 +94,9 @@ class Agent {
   void DisableAsyncHook();
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
-  std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      uint64_t thread_id, const std::string& url);
+  std::unique_ptr<ParentInspectorHandle> GetParentHandle(uint64_t thread_id,
+                                                         std::string_view url,
+                                                         std::string_view name);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
@@ -115,9 +129,11 @@ class Agent {
   std::shared_ptr<WorkerManager> GetWorkerManager();
 
   inline Environment* env() const { return parent_env_; }
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager();
 
  private:
   void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+  void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local<v8::Function> fn);
 
   node::Environment* parent_env_;
   // Encapsulates majority of the Inspector functionality
@@ -136,6 +152,11 @@ class Agent {
 
   bool pending_enable_async_hook_ = false;
   bool pending_disable_async_hook_ = false;
+
+  bool network_tracking_enabled_ = false;
+  bool pending_enable_network_tracking = false;
+  bool pending_disable_network_tracking = false;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 
 }  // namespace inspector