Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	inspector/main_thread_interface.cc	Lines:	157	158	99.4 %
Date:	2022-09-11 04:22:34	Branches:	25	36	69.4 %


#include "main_thread_interface.h"

#include "env-inl.h"
#include "node_mutex.h"
#include "v8-inspector.h"
#include "util-inl.h"

#include <unicode/unistr.h>

#include <functional>
#include <memory>

namespace node {
namespace inspector {
namespace {

using v8_inspector::StringBuffer;
using v8_inspector::StringView;

template <typename T>
class DeletableWrapper : public Deletable {
 public:
  explicit DeletableWrapper(std::unique_ptr<T> object)
                        : object_(std::move(object)) {}
  ~DeletableWrapper() override = default;

  static T* get(MainThreadInterface* thread, int id) {
    return
        static_cast<DeletableWrapper<T>*>(thread->GetObject(id))->object_.get();
  }

 private:
  std::unique_ptr<T> object_;
};

template <typename T>
std::unique_ptr<Deletable> WrapInDeletable(std::unique_ptr<T> object) {
  return std::unique_ptr<DeletableWrapper<T>>(
      new DeletableWrapper<T>(std::move(object)));
}

template <typename Factory>
class CreateObjectRequest : public Request {
 public:
  CreateObjectRequest(int object_id, Factory factory)
                      : object_id_(object_id), factory_(std::move(factory)) {}

  void Call(MainThreadInterface* thread) override {
    thread->AddObject(object_id_, WrapInDeletable(factory_(thread)));
  }

 private:
  int object_id_;
  Factory factory_;
};

template <typename Factory>
std::unique_ptr<Request> NewCreateRequest(int object_id, Factory factory) {
  return std::unique_ptr<Request>(
      new CreateObjectRequest<Factory>(object_id, std::move(factory)));
}

class DeleteRequest : public Request {
 public:
  explicit DeleteRequest(int object_id) : object_id_(object_id) {}

  void Call(MainThreadInterface* thread) override {
    thread->RemoveObject(object_id_);
  }

 private:
  int object_id_;
};

template <typename Target, typename Fn>
class CallRequest : public Request {
 public:
  CallRequest(int id, Fn fn) : id_(id), fn_(std::move(fn)) {}

  void Call(MainThreadInterface* thread) override {
    fn_(DeletableWrapper<Target>::get(thread, id_));
  }

 private:
  int id_;
  Fn fn_;
};

template <typename T>
class AnotherThreadObjectReference {
 public:
  AnotherThreadObjectReference(
      std::shared_ptr<MainThreadHandle> thread, int object_id)
      : thread_(thread), object_id_(object_id) {}

  template <typename Factory>
  AnotherThreadObjectReference(
      std::shared_ptr<MainThreadHandle> thread, Factory factory)
      : AnotherThreadObjectReference(thread, thread->newObjectId()) {
    thread_->Post(NewCreateRequest(object_id_, std::move(factory)));
  }
  AnotherThreadObjectReference(AnotherThreadObjectReference&) = delete;

  ~AnotherThreadObjectReference() {
    // Disappearing thread may cause a memory leak
    thread_->Post(std::make_unique<DeleteRequest>(object_id_));
  }

  template <typename Fn>
  void Call(Fn fn) const {
    using Request = CallRequest<T, Fn>;
    thread_->Post(std::unique_ptr<Request>(
        new Request(object_id_, std::move(fn))));
  }

  template <typename Arg>
  void Call(void (T::*fn)(Arg), Arg argument) const {
    Call(std::bind(Apply<Arg>, std::placeholders::_1, fn, std::move(argument)));
  }

 private:
  // This has to use non-const reference to support std::bind with non-copyable
  // types
  template <typename Argument>
  static void Apply(T* target, void (T::*fn)(Argument),
    /* NOLINT (runtime/references) */ Argument& argument) {
    (target->*fn)(std::move(argument));
  }

  std::shared_ptr<MainThreadHandle> thread_;
  const int object_id_;
};

class MainThreadSessionState {
 public:
  MainThreadSessionState(MainThreadInterface* thread, bool prevent_shutdown)
                         : thread_(thread),
                           prevent_shutdown_(prevent_shutdown) {}

  static std::unique_ptr<MainThreadSessionState> Create(
      MainThreadInterface* thread, bool prevent_shutdown) {
    return std::make_unique<MainThreadSessionState>(thread, prevent_shutdown);
  }

  void Connect(std::unique_ptr<InspectorSessionDelegate> delegate) {
    Agent* agent = thread_->inspector_agent();
    if (agent != nullptr)
      session_ = agent->Connect(std::move(delegate), prevent_shutdown_);
  }

  void Dispatch(std::unique_ptr<StringBuffer> message) {
    session_->Dispatch(message->string());
  }

 private:
  MainThreadInterface* thread_;
  bool prevent_shutdown_;
  std::unique_ptr<InspectorSession> session_;
};

class CrossThreadInspectorSession : public InspectorSession {
 public:
  CrossThreadInspectorSession(
      int id,
      std::shared_ptr<MainThreadHandle> thread,
      std::unique_ptr<InspectorSessionDelegate> delegate,
      bool prevent_shutdown)
      : state_(thread, std::bind(MainThreadSessionState::Create,
                                 std::placeholders::_1,
                                 prevent_shutdown)) {
    state_.Call(&MainThreadSessionState::Connect, std::move(delegate));
  }

  void Dispatch(const StringView& message) override {
    state_.Call(&MainThreadSessionState::Dispatch,
                StringBuffer::create(message));
  }

 private:
  AnotherThreadObjectReference<MainThreadSessionState> state_;
};

class ThreadSafeDelegate : public InspectorSessionDelegate {
 public:
  ThreadSafeDelegate(std::shared_ptr<MainThreadHandle> thread, int object_id)
                     : thread_(thread), delegate_(thread, object_id) {}

  void SendMessageToFrontend(const v8_inspector::StringView& message) override {
    delegate_.Call(
        [m = StringBuffer::create(message)]
        (InspectorSessionDelegate* delegate) {
      delegate->SendMessageToFrontend(m->string());
    });
  }

 private:
  std::shared_ptr<MainThreadHandle> thread_;
  AnotherThreadObjectReference<InspectorSessionDelegate> delegate_;
};
}  // namespace


MainThreadInterface::MainThreadInterface(Agent* agent) : agent_(agent) {}

MainThreadInterface::~MainThreadInterface() {
  if (handle_)
    handle_->Reset();
}

void MainThreadInterface::Post(std::unique_ptr<Request> request) {
  CHECK_NOT_NULL(agent_);
  Mutex::ScopedLock scoped_lock(requests_lock_);
  bool needs_notify = requests_.empty();
  requests_.push_back(std::move(request));
  if (needs_notify) {
    std::weak_ptr<MainThreadInterface> weak_self {shared_from_this()};
    agent_->env()->RequestInterrupt([weak_self](Environment*) {
      if (auto iface = weak_self.lock()) iface->DispatchMessages();
    });
  }
  incoming_message_cond_.Broadcast(scoped_lock);
}

bool MainThreadInterface::WaitForFrontendEvent() {
  // We allow DispatchMessages reentry as we enter the pause. This is important
  // to support debugging the code invoked by an inspector call, such
  // as Runtime.evaluate
  dispatching_messages_ = false;
  if (dispatching_message_queue_.empty()) {
    Mutex::ScopedLock scoped_lock(requests_lock_);
    while (requests_.empty()) incoming_message_cond_.Wait(scoped_lock);
  }
  return true;
}

void MainThreadInterface::DispatchMessages() {
  if (dispatching_messages_)
    return;
  dispatching_messages_ = true;
  bool had_messages = false;
  do {
    if (dispatching_message_queue_.empty()) {
      Mutex::ScopedLock scoped_lock(requests_lock_);
      requests_.swap(dispatching_message_queue_);
    }
    had_messages = !dispatching_message_queue_.empty();
    while (!dispatching_message_queue_.empty()) {
      MessageQueue::value_type task;
      std::swap(dispatching_message_queue_.front(), task);
      dispatching_message_queue_.pop_front();

      v8::SealHandleScope seal_handle_scope(agent_->env()->isolate());
      task->Call(this);
    }
  } while (had_messages);
  dispatching_messages_ = false;
}

std::shared_ptr<MainThreadHandle> MainThreadInterface::GetHandle() {
  if (handle_ == nullptr)
    handle_ = std::make_shared<MainThreadHandle>(this);
  return handle_;
}

void MainThreadInterface::AddObject(int id,
                                    std::unique_ptr<Deletable> object) {
  CHECK_NOT_NULL(object);
  managed_objects_[id] = std::move(object);
}

void MainThreadInterface::RemoveObject(int id) {
  CHECK_EQ(1, managed_objects_.erase(id));
}

Deletable* MainThreadInterface::GetObject(int id) {
  Deletable* pointer = GetObjectIfExists(id);
  // This would mean the object is requested after it was disposed, which is
  // a coding error.
  CHECK_NOT_NULL(pointer);
  return pointer;
}

Deletable* MainThreadInterface::GetObjectIfExists(int id) {
  auto iterator = managed_objects_.find(id);
  if (iterator == managed_objects_.end()) {
    return nullptr;
  }
  return iterator->second.get();
}

std::unique_ptr<StringBuffer> Utf8ToStringView(const std::string& message) {
  icu::UnicodeString utf16 = icu::UnicodeString::fromUTF8(
      icu::StringPiece(message.data(), message.length()));
  StringView view(reinterpret_cast<const uint16_t*>(utf16.getBuffer()),
                  utf16.length());
  return StringBuffer::create(view);
}

std::unique_ptr<InspectorSession> MainThreadHandle::Connect(
    std::unique_ptr<InspectorSessionDelegate> delegate,
    bool prevent_shutdown) {
  return std::unique_ptr<InspectorSession>(
      new CrossThreadInspectorSession(++next_session_id_,
                                      shared_from_this(),
                                      std::move(delegate),
                                      prevent_shutdown));
}

bool MainThreadHandle::Post(std::unique_ptr<Request> request) {
  Mutex::ScopedLock scoped_lock(block_lock_);
  if (!main_thread_)
    return false;
  main_thread_->Post(std::move(request));
  return true;
}

void MainThreadHandle::Reset() {
  Mutex::ScopedLock scoped_lock(block_lock_);
  main_thread_ = nullptr;
}

std::unique_ptr<InspectorSessionDelegate>
MainThreadHandle::MakeDelegateThreadSafe(
    std::unique_ptr<InspectorSessionDelegate> delegate) {
  int id = newObjectId();
  main_thread_->AddObject(id, WrapInDeletable(std::move(delegate)));
  return std::unique_ptr<InspectorSessionDelegate>(
      new ThreadSafeDelegate(shared_from_this(), id));
}

bool MainThreadHandle::Expired() {
  Mutex::ScopedLock scoped_lock(block_lock_);
  return main_thread_ == nullptr;
}
}  // namespace inspector
}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "main_thread_interface.h"
2
3			#include "env-inl.h"
4			#include "node_mutex.h"
5			#include "v8-inspector.h"
6			#include "util-inl.h"
7
8			#include <unicode/unistr.h>
9
10			#include <functional>
11			#include <memory>
12
13			namespace node {
14			namespace inspector {
15			namespace {
16
17			using v8_inspector::StringBuffer;
18			using v8_inspector::StringView;
19
20			template <typename T>
21			class DeletableWrapper : public Deletable {
22			public:
23		96	explicit DeletableWrapper(std::unique_ptr<T> object)
24		96	: object_(std::move(object)) {}
25		96	~DeletableWrapper() override = default;
26
27		1934	static T* get(MainThreadInterface* thread, int id) {
28			return
29		1934	static_cast<DeletableWrapper<T>*>(thread->GetObject(id))->object_.get();
30			}
31
32			private:
33			std::unique_ptr<T> object_;
34			};
35
36			template <typename T>
37		96	std::unique_ptr<Deletable> WrapInDeletable(std::unique_ptr<T> object) {
38			return std::unique_ptr<DeletableWrapper<T>>(
39		96	new DeletableWrapper<T>(std::move(object)));
40			}
41
42			template <typename Factory>
43			class CreateObjectRequest : public Request {
44			public:
45		33	CreateObjectRequest(int object_id, Factory factory)
46		33	: object_id_(object_id), factory_(std::move(factory)) {}
47
48		33	void Call(MainThreadInterface* thread) override {
49		33	thread->AddObject(object_id_, WrapInDeletable(factory_(thread)));
50		33	}
51
52			private:
53			int object_id_;
54			Factory factory_;
55			};
56
57			template <typename Factory>
58		33	std::unique_ptr<Request> NewCreateRequest(int object_id, Factory factory) {
59			return std::unique_ptr<Request>(
60		33	new CreateObjectRequest<Factory>(object_id, std::move(factory)));
61			}
62
63			class DeleteRequest : public Request {
64			public:
65		48	explicit DeleteRequest(int object_id) : object_id_(object_id) {}
66
67		35	void Call(MainThreadInterface* thread) override {
68		35	thread->RemoveObject(object_id_);
69		35	}
70
71			private:
72			int object_id_;
73			};
74
75			template <typename Target, typename Fn>
76			class CallRequest : public Request {
77			public:
78		1934	CallRequest(int id, Fn fn) : id_(id), fn_(std::move(fn)) {}
79
80		1934	void Call(MainThreadInterface* thread) override {
81		1934	fn_(DeletableWrapper<Target>::get(thread, id_));
82		1934	}
83
84			private:
85			int id_;
86			Fn fn_;
87			};
88
89			template <typename T>
90			class AnotherThreadObjectReference {
91			public:
92		96	AnotherThreadObjectReference(
93			std::shared_ptr<MainThreadHandle> thread, int object_id)
94		96	: thread_(thread), object_id_(object_id) {}
95
96			template <typename Factory>
97		33	AnotherThreadObjectReference(
98			std::shared_ptr<MainThreadHandle> thread, Factory factory)
99		33	: AnotherThreadObjectReference(thread, thread->newObjectId()) {
100		33	thread_->Post(NewCreateRequest(object_id_, std::move(factory)));
101		33	}
102			AnotherThreadObjectReference(AnotherThreadObjectReference&) = delete;
103
104		96	~AnotherThreadObjectReference() {
105			// Disappearing thread may cause a memory leak
106		96	thread_->Post(std::make_unique<DeleteRequest>(object_id_));
107		96	}
108
109			template <typename Fn>
110		1934	void Call(Fn fn) const {
111			using Request = CallRequest<T, Fn>;
112		5802	thread_->Post(std::unique_ptr<Request>(
113		3868	new Request(object_id_, std::move(fn))));
114		1934	}
115
116			template <typename Arg>
117		378	void Call(void (T::*fn)(Arg), Arg argument) const {
118		378	Call(std::bind(Apply<Arg>, std::placeholders::_1, fn, std::move(argument)));
119		378	}
120
121			private:
122			// This has to use non-const reference to support std::bind with non-copyable
123			// types
124			template <typename Argument>
125		378	static void Apply(T* target, void (T::*fn)(Argument),
126			/* NOLINT (runtime/references) */ Argument& argument) {
127	✗✓	378	(target->*fn)(std::move(argument));
128		378	}
129
130			std::shared_ptr<MainThreadHandle> thread_;
131			const int object_id_;
132			};
133
134			class MainThreadSessionState {
135			public:
136		33	MainThreadSessionState(MainThreadInterface* thread, bool prevent_shutdown)
137		33	: thread_(thread),
138		33	prevent_shutdown_(prevent_shutdown) {}
139
140		33	static std::unique_ptr<MainThreadSessionState> Create(
141			MainThreadInterface* thread, bool prevent_shutdown) {
142		33	return std::make_unique<MainThreadSessionState>(thread, prevent_shutdown);
143			}
144
145		33	void Connect(std::unique_ptr<InspectorSessionDelegate> delegate) {
146		33	Agent* agent = thread_->inspector_agent();
147	✓✗	33	if (agent != nullptr)
148		33	session_ = agent->Connect(std::move(delegate), prevent_shutdown_);
149		33	}
150
151		156	void Dispatch(std::unique_ptr<StringBuffer> message) {
152		156	session_->Dispatch(message->string());
153		156	}
154
155			private:
156			MainThreadInterface* thread_;
157			bool prevent_shutdown_;
158			std::unique_ptr<InspectorSession> session_;
159			};
160
161			class CrossThreadInspectorSession : public InspectorSession {
162			public:
163		33	CrossThreadInspectorSession(
164			int id,
165			std::shared_ptr<MainThreadHandle> thread,
166			std::unique_ptr<InspectorSessionDelegate> delegate,
167			bool prevent_shutdown)
168		99	: state_(thread, std::bind(MainThreadSessionState::Create,
169			std::placeholders::_1,
170		33	prevent_shutdown)) {
171		33	state_.Call(&MainThreadSessionState::Connect, std::move(delegate));
172		33	}
173
174		156	void Dispatch(const StringView& message) override {
175		156	state_.Call(&MainThreadSessionState::Dispatch,
176		312	StringBuffer::create(message));
177		156	}
178
179			private:
180			AnotherThreadObjectReference<MainThreadSessionState> state_;
181			};
182
183			class ThreadSafeDelegate : public InspectorSessionDelegate {
184			public:
185		15	ThreadSafeDelegate(std::shared_ptr<MainThreadHandle> thread, int object_id)
186		15	: thread_(thread), delegate_(thread, object_id) {}
187
188		778	void SendMessageToFrontend(const v8_inspector::StringView& message) override {
189		778	delegate_.Call(
190			[m = StringBuffer::create(message)]
191		778	(InspectorSessionDelegate* delegate) {
192		778	delegate->SendMessageToFrontend(m->string());
193		778	});
194		778	}
195
196			private:
197			std::shared_ptr<MainThreadHandle> thread_;
198			AnotherThreadObjectReference<InspectorSessionDelegate> delegate_;
199			};
200			} // namespace
201
202
203		6283	MainThreadInterface::MainThreadInterface(Agent* agent) : agent_(agent) {}
204
205		5710	MainThreadInterface::~MainThreadInterface() {
206	✓✗	5710	if (handle_)
207		5710	handle_->Reset();
208		5710	}
209
210		10914	void MainThreadInterface::Post(std::unique_ptr<Request> request) {
211	✗✓	10914	CHECK_NOT_NULL(agent_);
212		21828	Mutex::ScopedLock scoped_lock(requests_lock_);
213		10914	bool needs_notify = requests_.empty();
214		10914	requests_.push_back(std::move(request));
215	✓✓	10914	if (needs_notify) {
216		10706	std::weak_ptr<MainThreadInterface> weak_self {shared_from_this()};
217		10706	agent_->env()->RequestInterrupt([weak_self](Environment*) {
218	✓✗	10701	if (auto iface = weak_self.lock()) iface->DispatchMessages();
219		10701	});
220			}
221		10914	incoming_message_cond_.Broadcast(scoped_lock);
222		10914	}
223
224		118	bool MainThreadInterface::WaitForFrontendEvent() {
225			// We allow DispatchMessages reentry as we enter the pause. This is important
226			// to support debugging the code invoked by an inspector call, such
227			// as Runtime.evaluate
228		118	dispatching_messages_ = false;
229	✓✗	118	if (dispatching_message_queue_.empty()) {
230		236	Mutex::ScopedLock scoped_lock(requests_lock_);
231	✓✓	236	while (requests_.empty()) incoming_message_cond_.Wait(scoped_lock);
232			}
233		118	return true;
234			}
235
236		10701	void MainThreadInterface::DispatchMessages() {
237	✓✓	10701	if (dispatching_messages_)
238		50	return;
239		10651	dispatching_messages_ = true;
240		10651	bool had_messages = false;
241	✓✓	21352	do {
242	✓✗	21352	if (dispatching_message_queue_.empty()) {
243		42704	Mutex::ScopedLock scoped_lock(requests_lock_);
244		21352	requests_.swap(dispatching_message_queue_);
245			}
246		21352	had_messages = !dispatching_message_queue_.empty();
247	✓✓	32243	while (!dispatching_message_queue_.empty()) {
248		10891	MessageQueue::value_type task;
249		10891	std::swap(dispatching_message_queue_.front(), task);
250		10891	dispatching_message_queue_.pop_front();
251
252		21782	v8::SealHandleScope seal_handle_scope(agent_->env()->isolate());
253		10891	task->Call(this);
254			}
255			} while (had_messages);
256		10651	dispatching_messages_ = false;
257			}
258
259		13652	std::shared_ptr<MainThreadHandle> MainThreadInterface::GetHandle() {
260	✓✓	13652	if (handle_ == nullptr)
261		6283	handle_ = std::make_shared<MainThreadHandle>(this);
262		13652	return handle_;
263			}
264
265		7304	void MainThreadInterface::AddObject(int id,
266			std::unique_ptr<Deletable> object) {
267	✗✓	7304	CHECK_NOT_NULL(object);
268		7304	managed_objects_[id] = std::move(object);
269		7304	}
270
271		966	void MainThreadInterface::RemoveObject(int id) {
272	✗✓	966	CHECK_EQ(1, managed_objects_.erase(id));
273		966	}
274
275		967	Deletable* MainThreadInterface::GetObject(int id) {
276		967	Deletable* pointer = GetObjectIfExists(id);
277			// This would mean the object is requested after it was disposed, which is
278			// a coding error.
279	✗✓	967	CHECK_NOT_NULL(pointer);
280		967	return pointer;
281			}
282
283		971	Deletable* MainThreadInterface::GetObjectIfExists(int id) {
284		971	auto iterator = managed_objects_.find(id);
285	✗✓	971	if (iterator == managed_objects_.end()) {
286			return nullptr;
287			}
288		971	return iterator->second.get();
289			}
290
291		80413	std::unique_ptr<StringBuffer> Utf8ToStringView(const std::string& message) {
292			icu::UnicodeString utf16 = icu::UnicodeString::fromUTF8(
293		160826	icu::StringPiece(message.data(), message.length()));
294		80413	StringView view(reinterpret_cast<const uint16_t*>(utf16.getBuffer()),
295		80413	utf16.length());
296		80413	return StringBuffer::create(view);
297			}
298
299		33	std::unique_ptr<InspectorSession> MainThreadHandle::Connect(
300			std::unique_ptr<InspectorSessionDelegate> delegate,
301			bool prevent_shutdown) {
302			return std::unique_ptr<InspectorSession>(
303		33	new CrossThreadInspectorSession(++next_session_id_,
304		66	shared_from_this(),
305		33	std::move(delegate),
306		33	prevent_shutdown));
307			}
308
309		16677	bool MainThreadHandle::Post(std::unique_ptr<Request> request) {
310		33354	Mutex::ScopedLock scoped_lock(block_lock_);
311	✓✓	16677	if (!main_thread_)
312		5763	return false;
313		10914	main_thread_->Post(std::move(request));
314		10914	return true;
315			}
316
317		5710	void MainThreadHandle::Reset() {
318		5710	Mutex::ScopedLock scoped_lock(block_lock_);
319		5710	main_thread_ = nullptr;
320		5710	}
321
322			std::unique_ptr<InspectorSessionDelegate>
323		15	MainThreadHandle::MakeDelegateThreadSafe(
324			std::unique_ptr<InspectorSessionDelegate> delegate) {
325		15	int id = newObjectId();
326		15	main_thread_->AddObject(id, WrapInDeletable(std::move(delegate)));
327			return std::unique_ptr<InspectorSessionDelegate>(
328		15	new ThreadSafeDelegate(shared_from_this(), id));
329			}
330
331		726	bool MainThreadHandle::Expired() {
332		726	Mutex::ScopedLock scoped_lock(block_lock_);
333		726	return main_thread_ == nullptr;
334			}
335			} // namespace inspector
336			} // namespace node