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_inspector.cc Lines: 63 63 100.0 %
Date: 2019-10-06 22:30:00 Branches: 10 14 71.4 %

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