Skip to content

Commit

Permalink
src: clean up zlib write code
Browse files Browse the repository at this point in the history
Split the existing `Write()` method into one that takes care
of translating the arguments from JS to C++, and a non-static
method for the actual write operations, as well as some minor
stylistic drive-by fixes.

PR-URL: #23183
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
  • Loading branch information
addaleax authored and targos committed Oct 5, 2018
1 parent e93c94c commit 8f5fb6f
Showing 1 changed file with 42 additions and 38 deletions.
80 changes: 42 additions & 38 deletions src/node_zlib.cc
Original file line number Diff line number Diff line change
Expand Up @@ -138,24 +138,15 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
// write(flush, in, in_off, in_len, out, out_off, out_len)
template <bool async>
static void Write(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Local<Context> context = env->context();
CHECK_EQ(args.Length(), 7);

ZCtx* ctx;
ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
CHECK(ctx->init_done_ && "write before init");
CHECK(ctx->mode_ != NONE && "already finalized");

CHECK_EQ(false, ctx->write_in_progress_ && "write already in progress");
CHECK_EQ(false, ctx->pending_close_ && "close is pending");
ctx->write_in_progress_ = true;
ctx->Ref();
uint32_t in_off, in_len, out_off, out_len, flush;
char* in;
char* out;

CHECK_EQ(false, args[0]->IsUndefined() && "must provide flush value");

Environment* env = ctx->env();
Local<Context> context = env->context();

unsigned int flush;
if (!args[0]->Uint32Value(context).To(&flush)) return;

if (flush != Z_NO_FLUSH &&
Expand All @@ -167,56 +158,69 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
CHECK(0 && "Invalid flush value");
}

AllocScope alloc_scope(ctx);

Bytef* in;
Bytef* out;
uint32_t in_off, in_len, out_off, out_len;

if (args[1]->IsNull()) {
// just a flush
in = nullptr;
in_len = 0;
in_off = 0;
} else {
CHECK(Buffer::HasInstance(args[1]));
Local<Object> in_buf;
in_buf = args[1]->ToObject(context).ToLocalChecked();
Local<Object> in_buf = args[1].As<Object>();
if (!args[2]->Uint32Value(context).To(&in_off)) return;
if (!args[3]->Uint32Value(context).To(&in_len)) return;

CHECK(Buffer::IsWithinBounds(in_off, in_len, Buffer::Length(in_buf)));
in = reinterpret_cast<Bytef *>(Buffer::Data(in_buf) + in_off);
in = Buffer::Data(in_buf) + in_off;
}

CHECK(Buffer::HasInstance(args[4]));
Local<Object> out_buf = args[4]->ToObject(context).ToLocalChecked();
Local<Object> out_buf = args[4].As<Object>();
if (!args[5]->Uint32Value(context).To(&out_off)) return;
if (!args[6]->Uint32Value(context).To(&out_len)) return;
CHECK(Buffer::IsWithinBounds(out_off, out_len, Buffer::Length(out_buf)));
out = reinterpret_cast<Bytef *>(Buffer::Data(out_buf) + out_off);
out = Buffer::Data(out_buf) + out_off;

ZCtx* ctx;
ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());

ctx->Write<async>(flush, in, in_len, out, out_len);
}

template <bool async>
void Write(uint32_t flush,
char* in, uint32_t in_len,
char* out, uint32_t out_len) {
AllocScope alloc_scope(this);

CHECK(init_done_ && "write before init");
CHECK(mode_ != NONE && "already finalized");

CHECK_EQ(false, write_in_progress_);
CHECK_EQ(false, pending_close_);
write_in_progress_ = true;
Ref();

ctx->strm_.avail_in = in_len;
ctx->strm_.next_in = in;
ctx->strm_.avail_out = out_len;
ctx->strm_.next_out = out;
ctx->flush_ = flush;
strm_.avail_in = in_len;
strm_.next_in = reinterpret_cast<Bytef*>(in);
strm_.avail_out = out_len;
strm_.next_out = reinterpret_cast<Bytef*>(out);
flush_ = flush;

if (!async) {
// sync version
env->PrintSyncTrace();
ctx->DoThreadPoolWork();
if (ctx->CheckError()) {
ctx->write_result_[0] = ctx->strm_.avail_out;
ctx->write_result_[1] = ctx->strm_.avail_in;
ctx->write_in_progress_ = false;
env()->PrintSyncTrace();
DoThreadPoolWork();
if (CheckError()) {
write_result_[0] = strm_.avail_out;
write_result_[1] = strm_.avail_in;
write_in_progress_ = false;
}
ctx->Unref();
Unref();
return;
}

// async version
ctx->ScheduleWork();
ScheduleWork();
}

// thread pool!
Expand Down

0 comments on commit 8f5fb6f

Please sign in to comment.