Skip to content

src: introduce TimerWrap/TimerWrapHandle utility #34186

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
jasnell wants to merge 3 commits into from
Closed

src: introduce TimerWrap/TimerWrapHandle utility #34186

Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
9707be1
src: add TimerWrap utility
jasnell Jul 3, 2020
b4e7e57
src: replace InspectorTimer with TimerWrap utility
jasnell Jul 3, 2020
f7ad0bf
quic: use TimerWrap for idle and retransmit timers
jasnell Jul 3, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
src: replace InspectorTimer with TimerWrap utility 
Signed-off-by: James M Snell <jasnell@gmail.com>
  • Loading branch information
@jasnell
jasnell committed Jul 5, 2020
commit b4e7e573962b487f03dbaeb9df84deb604b53015
92 changes: 8 additions & 84 deletions src/inspector_agent.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@
#include "node_process.h"
#include "node_url.h"
#include "util-inl.h"
#include "timer_wrap.h"
#include "v8-inspector.h"
#include "v8-platform.h"

Expand Down Expand Up @@ -326,86 +327,6 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
bool retaining_context_;
};

class InspectorTimer {
public:
InspectorTimer(Environment* env,
double interval_s,
V8InspectorClient::TimerCallback callback,
void* data) : env_(env),
callback_(callback),
data_(data) {
uv_timer_init(env->event_loop(), &timer_);
int64_t interval_ms = 1000 * interval_s;
uv_timer_start(&timer_, OnTimer, interval_ms, interval_ms);
timer_.data = this;
}

InspectorTimer(const InspectorTimer&) = delete;

void Stop() {
if (timer_.data == nullptr) return;

timer_.data = nullptr;
uv_timer_stop(&timer_);
env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&timer_), TimerClosedCb);
}

inline Environment* env() const { return env_; }

private:
static void OnTimer(uv_timer_t* uvtimer) {
InspectorTimer* timer = node::ContainerOf(&InspectorTimer::timer_, uvtimer);
timer->callback_(timer->data_);
}

static void TimerClosedCb(uv_handle_t* uvtimer) {
std::unique_ptr<InspectorTimer> timer(
node::ContainerOf(&InspectorTimer::timer_,
reinterpret_cast<uv_timer_t*>(uvtimer)));
// Unique_ptr goes out of scope here and pointer is deleted.
}

~InspectorTimer() = default;

Environment* env_;
uv_timer_t timer_;
V8InspectorClient::TimerCallback callback_;
void* data_;

friend std::unique_ptr<InspectorTimer>::deleter_type;
};

class InspectorTimerHandle {
public:
InspectorTimerHandle(Environment* env, double interval_s,
V8InspectorClient::TimerCallback callback, void* data) {
timer_ = new InspectorTimer(env, interval_s, callback, data);

env->AddCleanupHook(CleanupHook, this);
}

InspectorTimerHandle(const InspectorTimerHandle&) = delete;

~InspectorTimerHandle() {
Stop();
}

private:
void Stop() {
if (timer_ != nullptr) {
timer_->env()->RemoveCleanupHook(CleanupHook, this);
timer_->Stop();
}
timer_ = nullptr;
}

static void CleanupHook(void* data) {
static_cast<InspectorTimerHandle*>(data)->Stop();
}

InspectorTimer* timer_;
};

class SameThreadInspectorSession : public InspectorSession {
public:
SameThreadInspectorSession(
Expand Down Expand Up @@ -602,9 +523,12 @@ class NodeInspectorClient : public V8InspectorClient {
void startRepeatingTimer(double interval_s,
TimerCallback callback,
void* data) override {
timers_.emplace(std::piecewise_construct, std::make_tuple(data),
std::make_tuple(env_, interval_s, callback,
data));
auto result =
timers_.emplace(std::piecewise_construct, std::make_tuple(data),
std::make_tuple(env_, callback, data));
CHECK(result.second);
uint64_t interval = 1000 * interval_s;
result.first->second.Update(interval, interval);
}

void cancelTimer(void* data) override {
Expand Down Expand Up @@ -724,7 +648,7 @@ class NodeInspectorClient : public V8InspectorClient {
bool running_nested_loop_ = false;
std::unique_ptr<V8Inspector> client_;
// Note: ~ChannelImpl may access timers_ so timers_ has to come first.
std::unordered_map<void*, InspectorTimerHandle> timers_;
std::unordered_map<void*, TimerWrapHandle> timers_;
std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_;
int next_session_id_ = 1;
bool waiting_for_resume_ = false;
Expand Down