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: 75 76 98.7 %
Date: 2019-09-24 22:36:24 Branches: 14 22 63.6 %

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