Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	inspector/worker_inspector.cc	Lines:	64	65	98.5 %
Date:	2022-09-11 04:22:34	Branches:	8	10	80.0 %


#include "worker_inspector.h"
#include "main_thread_interface.h"
#include "util-inl.h"

#include <memory>

namespace node {
namespace inspector {
namespace {

class WorkerStartedRequest : public Request {
 public:
  WorkerStartedRequest(
      uint64_t id,
      const std::string& url,
      std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
      bool waiting)
      : id_(id),
        info_(BuildWorkerTitle(id), url, worker_thread),
        waiting_(waiting) {}
  void Call(MainThreadInterface* thread) override {
    auto manager = thread->inspector_agent()->GetWorkerManager();
    manager->WorkerStarted(id_, info_, waiting_);
  }

 private:
  static std::string BuildWorkerTitle(int id) {
    return "Worker " + std::to_string(id);
  }

  uint64_t id_;
  WorkerInfo info_;
  bool waiting_;
};


void Report(const std::unique_ptr<WorkerDelegate>& delegate,
            const WorkerInfo& info, bool waiting) {
  if (info.worker_thread)
    delegate->WorkerCreated(info.title, info.url, waiting, info.worker_thread);
}

class WorkerFinishedRequest : public Request {
 public:
  explicit WorkerFinishedRequest(uint64_t worker_id) : worker_id_(worker_id) {}

  void Call(MainThreadInterface* thread) override {
    thread->inspector_agent()->GetWorkerManager()->WorkerFinished(worker_id_);
  }

 private:
  uint64_t worker_id_;
};
}  // namespace

ParentInspectorHandle::ParentInspectorHandle(
    uint64_t id,
    const std::string& url,
    std::shared_ptr<MainThreadHandle> parent_thread,
    bool wait_for_connect)
    : id_(id),
      url_(url),
      parent_thread_(parent_thread),
      wait_(wait_for_connect) {}

ParentInspectorHandle::~ParentInspectorHandle() {
  parent_thread_->Post(
      std::unique_ptr<Request>(new WorkerFinishedRequest(id_)));
}

void ParentInspectorHandle::WorkerStarted(
    std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
  std::unique_ptr<Request> request(
      new WorkerStartedRequest(id_, url_, worker_thread, waiting));
  parent_thread_->Post(std::move(request));
}

std::unique_ptr<inspector::InspectorSession> ParentInspectorHandle::Connect(
    std::unique_ptr<inspector::InspectorSessionDelegate> delegate,
    bool prevent_shutdown) {
  return parent_thread_->Connect(std::move(delegate), prevent_shutdown);
}

void WorkerManager::WorkerFinished(uint64_t session_id) {
  children_.erase(session_id);
}

void WorkerManager::WorkerStarted(uint64_t session_id,
                                  const WorkerInfo& info,
                                  bool waiting) {
  if (info.worker_thread->Expired())
    return;
  children_.emplace(session_id, info);
  for (const auto& delegate : delegates_) {
    Report(delegate.second, info, waiting);
  }
}

std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
    uint64_t thread_id, const std::string& url) {
  bool wait = !delegates_waiting_on_start_.empty();
  return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait);
}

void WorkerManager::RemoveAttachDelegate(int id) {
  delegates_.erase(id);
  delegates_waiting_on_start_.erase(id);
}

std::unique_ptr<WorkerManagerEventHandle> WorkerManager::SetAutoAttach(
    std::unique_ptr<WorkerDelegate> attach_delegate) {
  int id = ++next_delegate_id_;
  delegates_[id] = std::move(attach_delegate);
  const auto& delegate = delegates_[id];
  for (const auto& worker : children_) {
    // Waiting is only reported when a worker is started, same as browser
    Report(delegate, worker.second, false);
  }
  return std::make_unique<WorkerManagerEventHandle>(shared_from_this(), id);
}

void WorkerManager::SetWaitOnStartForDelegate(int id, bool wait) {
  if (wait)
    delegates_waiting_on_start_.insert(id);
  else
    delegates_waiting_on_start_.erase(id);
}

void WorkerManagerEventHandle::SetWaitOnStart(bool wait_on_start) {
    manager_->SetWaitOnStartForDelegate(id_, wait_on_start);
}

WorkerManagerEventHandle::~WorkerManagerEventHandle() {
  manager_->RemoveAttachDelegate(id_);
}
}  // namespace inspector
}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "worker_inspector.h"
2			#include "main_thread_interface.h"
3			#include "util-inl.h"
4
5			#include <memory>
6
7			namespace node {
8			namespace inspector {
9			namespace {
10
11			class WorkerStartedRequest : public Request {
12			public:
13		726	WorkerStartedRequest(
14			uint64_t id,
15			const std::string& url,
16			std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
17			bool waiting)
18		726	: id_(id),
19		1452	info_(BuildWorkerTitle(id), url, worker_thread),
20		2178	waiting_(waiting) {}
21		726	void Call(MainThreadInterface* thread) override {
22		1452	auto manager = thread->inspector_agent()->GetWorkerManager();
23		726	manager->WorkerStarted(id_, info_, waiting_);
24		726	}
25
26			private:
27		726	static std::string BuildWorkerTitle(int id) {
28		726	return "Worker " + std::to_string(id);
29			}
30
31			uint64_t id_;
32			WorkerInfo info_;
33			bool waiting_;
34			};
35
36
37		13	void Report(const std::unique_ptr<WorkerDelegate>& delegate,
38			const WorkerInfo& info, bool waiting) {
39	✓✗	13	if (info.worker_thread)
40		13	delegate->WorkerCreated(info.title, info.url, waiting, info.worker_thread);
41		13	}
42
43			class WorkerFinishedRequest : public Request {
44			public:
45		962	explicit WorkerFinishedRequest(uint64_t worker_id) : worker_id_(worker_id) {}
46
47		939	void Call(MainThreadInterface* thread) override {
48		939	thread->inspector_agent()->GetWorkerManager()->WorkerFinished(worker_id_);
49		939	}
50
51			private:
52			uint64_t worker_id_;
53			};
54			} // namespace
55
56		962	ParentInspectorHandle::ParentInspectorHandle(
57			uint64_t id,
58			const std::string& url,
59			std::shared_ptr<MainThreadHandle> parent_thread,
60		962	bool wait_for_connect)
61			: id_(id),
62			url_(url),
63			parent_thread_(parent_thread),
64		962	wait_(wait_for_connect) {}
65
66		962	ParentInspectorHandle::~ParentInspectorHandle() {
67		1924	parent_thread_->Post(
68		1924	std::unique_ptr<Request>(new WorkerFinishedRequest(id_)));
69		962	}
70
71		726	void ParentInspectorHandle::WorkerStarted(
72			std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
73			std::unique_ptr<Request> request(
74		726	new WorkerStartedRequest(id_, url_, worker_thread, waiting));
75		726	parent_thread_->Post(std::move(request));
76		726	}
77
78		2	std::unique_ptr<inspector::InspectorSession> ParentInspectorHandle::Connect(
79			std::unique_ptr<inspector::InspectorSessionDelegate> delegate,
80			bool prevent_shutdown) {
81		2	return parent_thread_->Connect(std::move(delegate), prevent_shutdown);
82			}
83
84		939	void WorkerManager::WorkerFinished(uint64_t session_id) {
85		939	children_.erase(session_id);
86		939	}
87
88		726	void WorkerManager::WorkerStarted(uint64_t session_id,
89			const WorkerInfo& info,
90			bool waiting) {
91	✗✓	726	if (info.worker_thread->Expired())
92			return;
93		726	children_.emplace(session_id, info);
94	✓✓	733	for (const auto& delegate : delegates_) {
95		7	Report(delegate.second, info, waiting);
96			}
97			}
98
99		952	std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
100			uint64_t thread_id, const std::string& url) {
101		952	bool wait = !delegates_waiting_on_start_.empty();
102		952	return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait);
103			}
104
105		8	void WorkerManager::RemoveAttachDelegate(int id) {
106		8	delegates_.erase(id);
107		8	delegates_waiting_on_start_.erase(id);
108		8	}
109
110		8	std::unique_ptr<WorkerManagerEventHandle> WorkerManager::SetAutoAttach(
111			std::unique_ptr<WorkerDelegate> attach_delegate) {
112		8	int id = ++next_delegate_id_;
113		8	delegates_[id] = std::move(attach_delegate);
114		8	const auto& delegate = delegates_[id];
115	✓✓	14	for (const auto& worker : children_) {
116			// Waiting is only reported when a worker is started, same as browser
117		6	Report(delegate, worker.second, false);
118			}
119		8	return std::make_unique<WorkerManagerEventHandle>(shared_from_this(), id);
120			}
121
122		9	void WorkerManager::SetWaitOnStartForDelegate(int id, bool wait) {
123	✓✓	9	if (wait)
124		5	delegates_waiting_on_start_.insert(id);
125			else
126		4	delegates_waiting_on_start_.erase(id);
127		9	}
128
129		9	void WorkerManagerEventHandle::SetWaitOnStart(bool wait_on_start) {
130		9	manager_->SetWaitOnStartForDelegate(id_, wait_on_start);
131		9	}
132
133		8	WorkerManagerEventHandle::~WorkerManagerEventHandle() {
134		8	manager_->RemoveAttachDelegate(id_);
135		8	}
136			} // namespace inspector
137			} // namespace node