GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/inspector/worker_agent.cc Lines: 70 76 92.1 %
Date: 2021-02-19 04:08:54 Branches: 9 18 50.0 %

Line Branch Exec Source
1
#include "worker_agent.h"
2
3
#include "main_thread_interface.h"
4
#include "worker_inspector.h"
5
#include "util-inl.h"
6
7
namespace node {
8
namespace inspector {
9
namespace protocol {
10
11
140
class NodeWorkers
12
    : public std::enable_shared_from_this<NodeWorkers> {
13
 public:
14
143
  explicit NodeWorkers(std::weak_ptr<NodeWorker::Frontend> frontend,
15
                      std::shared_ptr<MainThreadHandle> thread)
16
143
                      : frontend_(frontend), thread_(thread) {}
17
  void WorkerCreated(const std::string& title,
18
                     const std::string& url,
19
                     bool waiting,
20
                     std::shared_ptr<MainThreadHandle> target);
21
  void Receive(const std::string& id, const std::string& message);
22
  void Send(const std::string& id, const std::string& message);
23
  void Detached(const std::string& id);
24
25
 private:
26
  std::weak_ptr<NodeWorker::Frontend> frontend_;
27
  std::shared_ptr<MainThreadHandle> thread_;
28
  std::unordered_map<std::string, std::unique_ptr<InspectorSession>> sessions_;
29
  int next_target_id_ = 0;
30
};
31
32
namespace {
33
2
class AgentWorkerInspectorDelegate : public WorkerDelegate {
34
 public:
35
1
  explicit AgentWorkerInspectorDelegate(std::shared_ptr<NodeWorkers> workers)
36
1
                                        : workers_(workers) {}
37
38
1
  void WorkerCreated(const std::string& title,
39
                     const std::string& url,
40
                     bool waiting,
41
                     std::shared_ptr<MainThreadHandle> target) override {
42
1
    workers_->WorkerCreated(title, url, waiting, target);
43
1
  }
44
45
 private:
46
  std::shared_ptr<NodeWorkers> workers_;
47
};
48
49
class ParentInspectorSessionDelegate : public InspectorSessionDelegate {
50
 public:
51
1
  ParentInspectorSessionDelegate(const std::string& id,
52
                                 std::shared_ptr<NodeWorkers> workers)
53
1
                                 : id_(id), workers_(workers) {}
54
55
3
  ~ParentInspectorSessionDelegate() override {
56
1
    workers_->Detached(id_);
57
2
  }
58
59
1
  void SendMessageToFrontend(const v8_inspector::StringView& msg) override {
60
2
    std::string message = protocol::StringUtil::StringViewToUtf8(msg);
61
1
    workers_->Send(id_, message);
62
1
  }
63
64
 private:
65
  std::string id_;
66
  std::shared_ptr<NodeWorkers> workers_;
67
};
68
69
1
std::unique_ptr<NodeWorker::WorkerInfo> WorkerInfo(const std::string& id,
70
                                                   const std::string& title,
71
                                                   const std::string& url) {
72
2
  return NodeWorker::WorkerInfo::create()
73
1
      .setWorkerId(id)
74
1
      .setTitle(title)
75
1
      .setUrl(url)
76
3
      .setType("worker").build();
77
}
78
}  // namespace
79
80
143
WorkerAgent::WorkerAgent(std::weak_ptr<WorkerManager> manager)
81
143
                         : manager_(manager) {}
82
83
84
143
void WorkerAgent::Wire(UberDispatcher* dispatcher) {
85
143
  frontend_.reset(new NodeWorker::Frontend(dispatcher->channel()));
86
143
  NodeWorker::Dispatcher::wire(dispatcher, this);
87
286
  auto manager = manager_.lock();
88
143
  CHECK_NOT_NULL(manager);
89
  workers_ =
90
143
      std::make_shared<NodeWorkers>(frontend_, manager->MainThread());
91
143
}
92
93
1
DispatchResponse WorkerAgent::sendMessageToWorker(const String& message,
94
                                                  const String& sessionId) {
95
1
  workers_->Receive(sessionId, message);
96
1
  return DispatchResponse::OK();
97
}
98
99
1
DispatchResponse WorkerAgent::enable(bool waitForDebuggerOnStart) {
100
2
  auto manager = manager_.lock();
101
1
  if (!manager) {
102
    return DispatchResponse::OK();
103
  }
104
1
  if (!event_handle_) {
105
    std::unique_ptr<AgentWorkerInspectorDelegate> delegate(
106
2
            new AgentWorkerInspectorDelegate(workers_));
107
1
    event_handle_ = manager->SetAutoAttach(std::move(delegate));
108
  }
109
1
  event_handle_->SetWaitOnStart(waitForDebuggerOnStart);
110
1
  return DispatchResponse::OK();
111
}
112
113
140
DispatchResponse WorkerAgent::disable() {
114
140
  event_handle_.reset();
115
140
  return DispatchResponse::OK();
116
}
117
118
DispatchResponse WorkerAgent::detach(const String& sessionId) {
119
  workers_->Detached(sessionId);
120
  return DispatchResponse::OK();
121
}
122
123
1
void NodeWorkers::WorkerCreated(const std::string& title,
124
                                const std::string& url,
125
                                bool waiting,
126
                                std::shared_ptr<MainThreadHandle> target) {
127
2
  auto frontend = frontend_.lock();
128
1
  if (!frontend)
129
    return;
130
2
  std::string id = std::to_string(++next_target_id_);
131
  auto delegate = thread_->MakeDelegateThreadSafe(
132
3
      std::unique_ptr<InspectorSessionDelegate>(
133
5
          new ParentInspectorSessionDelegate(id, shared_from_this())));
134
1
  sessions_[id] = target->Connect(std::move(delegate), true);
135
1
  frontend->attachedToWorker(id, WorkerInfo(id, title, url), waiting);
136
}
137
138
1
void NodeWorkers::Send(const std::string& id, const std::string& message) {
139
2
  auto frontend = frontend_.lock();
140
1
  if (frontend)
141
1
    frontend->receivedMessageFromWorker(id, message);
142
1
}
143
144
1
void NodeWorkers::Receive(const std::string& id, const std::string& message) {
145
1
  auto it = sessions_.find(id);
146
1
  if (it != sessions_.end())
147
1
    it->second->Dispatch(Utf8ToStringView(message)->string());
148
1
}
149
150
1
void NodeWorkers::Detached(const std::string& id) {
151
1
  if (sessions_.erase(id) == 0)
152
    return;
153
2
  auto frontend = frontend_.lock();
154
1
  if (frontend) {
155
1
    frontend->detachedFromWorker(id);
156
  }
157
}
158
}  // namespace protocol
159
}  // namespace inspector
160
}  // namespace node