diff options
Diffstat (limited to 'src/node/ext/node_grpc.cc')
-rw-r--r-- | src/node/ext/node_grpc.cc | 319 |
1 files changed, 171 insertions, 148 deletions
diff --git a/src/node/ext/node_grpc.cc b/src/node/ext/node_grpc.cc index 0cf30da922..caca0fc452 100644 --- a/src/node/ext/node_grpc.cc +++ b/src/node/ext/node_grpc.cc @@ -43,171 +43,194 @@ #include "credentials.h" #include "server_credentials.h" -using v8::Handle; +using v8::Local; using v8::Value; using v8::Object; using v8::Uint32; using v8::String; -void InitStatusConstants(Handle<Object> exports) { - NanScope(); - Handle<Object> status = NanNew<Object>(); - exports->Set(NanNew("status"), status); - Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_STATUS_OK)); - status->Set(NanNew("OK"), OK); - Handle<Value> CANCELLED(NanNew<Uint32, uint32_t>(GRPC_STATUS_CANCELLED)); - status->Set(NanNew("CANCELLED"), CANCELLED); - Handle<Value> UNKNOWN(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN)); - status->Set(NanNew("UNKNOWN"), UNKNOWN); - Handle<Value> INVALID_ARGUMENT( - NanNew<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT)); - status->Set(NanNew("INVALID_ARGUMENT"), INVALID_ARGUMENT); - Handle<Value> DEADLINE_EXCEEDED( - NanNew<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED)); - status->Set(NanNew("DEADLINE_EXCEEDED"), DEADLINE_EXCEEDED); - Handle<Value> NOT_FOUND(NanNew<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND)); - status->Set(NanNew("NOT_FOUND"), NOT_FOUND); - Handle<Value> ALREADY_EXISTS( - NanNew<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS)); - status->Set(NanNew("ALREADY_EXISTS"), ALREADY_EXISTS); - Handle<Value> PERMISSION_DENIED( - NanNew<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED)); - status->Set(NanNew("PERMISSION_DENIED"), PERMISSION_DENIED); - Handle<Value> UNAUTHENTICATED( - NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED)); - status->Set(NanNew("UNAUTHENTICATED"), UNAUTHENTICATED); - Handle<Value> RESOURCE_EXHAUSTED( - NanNew<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED)); - status->Set(NanNew("RESOURCE_EXHAUSTED"), RESOURCE_EXHAUSTED); - Handle<Value> FAILED_PRECONDITION( - NanNew<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION)); - status->Set(NanNew("FAILED_PRECONDITION"), FAILED_PRECONDITION); - Handle<Value> ABORTED(NanNew<Uint32, uint32_t>(GRPC_STATUS_ABORTED)); - status->Set(NanNew("ABORTED"), ABORTED); - Handle<Value> OUT_OF_RANGE( - NanNew<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE)); - status->Set(NanNew("OUT_OF_RANGE"), OUT_OF_RANGE); - Handle<Value> UNIMPLEMENTED( - NanNew<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED)); - status->Set(NanNew("UNIMPLEMENTED"), UNIMPLEMENTED); - Handle<Value> INTERNAL(NanNew<Uint32, uint32_t>(GRPC_STATUS_INTERNAL)); - status->Set(NanNew("INTERNAL"), INTERNAL); - Handle<Value> UNAVAILABLE(NanNew<Uint32, uint32_t>(GRPC_STATUS_UNAVAILABLE)); - status->Set(NanNew("UNAVAILABLE"), UNAVAILABLE); - Handle<Value> DATA_LOSS(NanNew<Uint32, uint32_t>(GRPC_STATUS_DATA_LOSS)); - status->Set(NanNew("DATA_LOSS"), DATA_LOSS); +void InitStatusConstants(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> status = Nan::New<Object>(); + Nan::Set(exports, Nan::New("status").ToLocalChecked(), status); + Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_STATUS_OK)); + Nan::Set(status, Nan::New("OK").ToLocalChecked(), OK); + Local<Value> CANCELLED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_CANCELLED)); + Nan::Set(status, Nan::New("CANCELLED").ToLocalChecked(), CANCELLED); + Local<Value> UNKNOWN(Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNKNOWN)); + Nan::Set(status, Nan::New("UNKNOWN").ToLocalChecked(), UNKNOWN); + Local<Value> INVALID_ARGUMENT( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_INVALID_ARGUMENT)); + Nan::Set(status, Nan::New("INVALID_ARGUMENT").ToLocalChecked(), + INVALID_ARGUMENT); + Local<Value> DEADLINE_EXCEEDED( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_DEADLINE_EXCEEDED)); + Nan::Set(status, Nan::New("DEADLINE_EXCEEDED").ToLocalChecked(), + DEADLINE_EXCEEDED); + Local<Value> NOT_FOUND(Nan::New<Uint32, uint32_t>(GRPC_STATUS_NOT_FOUND)); + Nan::Set(status, Nan::New("NOT_FOUND").ToLocalChecked(), NOT_FOUND); + Local<Value> ALREADY_EXISTS( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_ALREADY_EXISTS)); + Nan::Set(status, Nan::New("ALREADY_EXISTS").ToLocalChecked(), ALREADY_EXISTS); + Local<Value> PERMISSION_DENIED( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_PERMISSION_DENIED)); + Nan::Set(status, Nan::New("PERMISSION_DENIED").ToLocalChecked(), + PERMISSION_DENIED); + Local<Value> UNAUTHENTICATED( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNAUTHENTICATED)); + Nan::Set(status, Nan::New("UNAUTHENTICATED").ToLocalChecked(), + UNAUTHENTICATED); + Local<Value> RESOURCE_EXHAUSTED( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_RESOURCE_EXHAUSTED)); + Nan::Set(status, Nan::New("RESOURCE_EXHAUSTED").ToLocalChecked(), + RESOURCE_EXHAUSTED); + Local<Value> FAILED_PRECONDITION( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_FAILED_PRECONDITION)); + Nan::Set(status, Nan::New("FAILED_PRECONDITION").ToLocalChecked(), + FAILED_PRECONDITION); + Local<Value> ABORTED(Nan::New<Uint32, uint32_t>(GRPC_STATUS_ABORTED)); + Nan::Set(status, Nan::New("ABORTED").ToLocalChecked(), ABORTED); + Local<Value> OUT_OF_RANGE( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_OUT_OF_RANGE)); + Nan::Set(status, Nan::New("OUT_OF_RANGE").ToLocalChecked(), OUT_OF_RANGE); + Local<Value> UNIMPLEMENTED( + Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNIMPLEMENTED)); + Nan::Set(status, Nan::New("UNIMPLEMENTED").ToLocalChecked(), UNIMPLEMENTED); + Local<Value> INTERNAL(Nan::New<Uint32, uint32_t>(GRPC_STATUS_INTERNAL)); + Nan::Set(status, Nan::New("INTERNAL").ToLocalChecked(), INTERNAL); + Local<Value> UNAVAILABLE(Nan::New<Uint32, uint32_t>(GRPC_STATUS_UNAVAILABLE)); + Nan::Set(status, Nan::New("UNAVAILABLE").ToLocalChecked(), UNAVAILABLE); + Local<Value> DATA_LOSS(Nan::New<Uint32, uint32_t>(GRPC_STATUS_DATA_LOSS)); + Nan::Set(status, Nan::New("DATA_LOSS").ToLocalChecked(), DATA_LOSS); } -void InitCallErrorConstants(Handle<Object> exports) { - NanScope(); - Handle<Object> call_error = NanNew<Object>(); - exports->Set(NanNew("callError"), call_error); - Handle<Value> OK(NanNew<Uint32, uint32_t>(GRPC_CALL_OK)); - call_error->Set(NanNew("OK"), OK); - Handle<Value> ERROR(NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR)); - call_error->Set(NanNew("ERROR"), ERROR); - Handle<Value> NOT_ON_SERVER( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER)); - call_error->Set(NanNew("NOT_ON_SERVER"), NOT_ON_SERVER); - Handle<Value> NOT_ON_CLIENT( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT)); - call_error->Set(NanNew("NOT_ON_CLIENT"), NOT_ON_CLIENT); - Handle<Value> ALREADY_INVOKED( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED)); - call_error->Set(NanNew("ALREADY_INVOKED"), ALREADY_INVOKED); - Handle<Value> NOT_INVOKED( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED)); - call_error->Set(NanNew("NOT_INVOKED"), NOT_INVOKED); - Handle<Value> ALREADY_FINISHED( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED)); - call_error->Set(NanNew("ALREADY_FINISHED"), ALREADY_FINISHED); - Handle<Value> TOO_MANY_OPERATIONS( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS)); - call_error->Set(NanNew("TOO_MANY_OPERATIONS"), TOO_MANY_OPERATIONS); - Handle<Value> INVALID_FLAGS( - NanNew<Uint32, uint32_t>(GRPC_CALL_ERROR_INVALID_FLAGS)); - call_error->Set(NanNew("INVALID_FLAGS"), INVALID_FLAGS); +void InitCallErrorConstants(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> call_error = Nan::New<Object>(); + Nan::Set(exports, Nan::New("callError").ToLocalChecked(), call_error); + Local<Value> OK(Nan::New<Uint32, uint32_t>(GRPC_CALL_OK)); + Nan::Set(call_error, Nan::New("OK").ToLocalChecked(), OK); + Local<Value> ERROR(Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR)); + Nan::Set(call_error, Nan::New("ERROR").ToLocalChecked(), ERROR); + Local<Value> NOT_ON_SERVER( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_SERVER)); + Nan::Set(call_error, Nan::New("NOT_ON_SERVER").ToLocalChecked(), + NOT_ON_SERVER); + Local<Value> NOT_ON_CLIENT( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_ON_CLIENT)); + Nan::Set(call_error, Nan::New("NOT_ON_CLIENT").ToLocalChecked(), + NOT_ON_CLIENT); + Local<Value> ALREADY_INVOKED( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_INVOKED)); + Nan::Set(call_error, Nan::New("ALREADY_INVOKED").ToLocalChecked(), + ALREADY_INVOKED); + Local<Value> NOT_INVOKED( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_NOT_INVOKED)); + Nan::Set(call_error, Nan::New("NOT_INVOKED").ToLocalChecked(), NOT_INVOKED); + Local<Value> ALREADY_FINISHED( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_ALREADY_FINISHED)); + Nan::Set(call_error, Nan::New("ALREADY_FINISHED").ToLocalChecked(), + ALREADY_FINISHED); + Local<Value> TOO_MANY_OPERATIONS( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS)); + Nan::Set(call_error, Nan::New("TOO_MANY_OPERATIONS").ToLocalChecked(), + TOO_MANY_OPERATIONS); + Local<Value> INVALID_FLAGS( + Nan::New<Uint32, uint32_t>(GRPC_CALL_ERROR_INVALID_FLAGS)); + Nan::Set(call_error, Nan::New("INVALID_FLAGS").ToLocalChecked(), + INVALID_FLAGS); } -void InitOpTypeConstants(Handle<Object> exports) { - NanScope(); - Handle<Object> op_type = NanNew<Object>(); - exports->Set(NanNew("opType"), op_type); - Handle<Value> SEND_INITIAL_METADATA( - NanNew<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA)); - op_type->Set(NanNew("SEND_INITIAL_METADATA"), SEND_INITIAL_METADATA); - Handle<Value> SEND_MESSAGE( - NanNew<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE)); - op_type->Set(NanNew("SEND_MESSAGE"), SEND_MESSAGE); - Handle<Value> SEND_CLOSE_FROM_CLIENT( - NanNew<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT)); - op_type->Set(NanNew("SEND_CLOSE_FROM_CLIENT"), SEND_CLOSE_FROM_CLIENT); - Handle<Value> SEND_STATUS_FROM_SERVER( - NanNew<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER)); - op_type->Set(NanNew("SEND_STATUS_FROM_SERVER"), SEND_STATUS_FROM_SERVER); - Handle<Value> RECV_INITIAL_METADATA( - NanNew<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA)); - op_type->Set(NanNew("RECV_INITIAL_METADATA"), RECV_INITIAL_METADATA); - Handle<Value> RECV_MESSAGE( - NanNew<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE)); - op_type->Set(NanNew("RECV_MESSAGE"), RECV_MESSAGE); - Handle<Value> RECV_STATUS_ON_CLIENT( - NanNew<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT)); - op_type->Set(NanNew("RECV_STATUS_ON_CLIENT"), RECV_STATUS_ON_CLIENT); - Handle<Value> RECV_CLOSE_ON_SERVER( - NanNew<Uint32, uint32_t>(GRPC_OP_RECV_CLOSE_ON_SERVER)); - op_type->Set(NanNew("RECV_CLOSE_ON_SERVER"), RECV_CLOSE_ON_SERVER); +void InitOpTypeConstants(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> op_type = Nan::New<Object>(); + Nan::Set(exports, Nan::New("opType").ToLocalChecked(), op_type); + Local<Value> SEND_INITIAL_METADATA( + Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_INITIAL_METADATA)); + Nan::Set(op_type, Nan::New("SEND_INITIAL_METADATA").ToLocalChecked(), + SEND_INITIAL_METADATA); + Local<Value> SEND_MESSAGE( + Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_MESSAGE)); + Nan::Set(op_type, Nan::New("SEND_MESSAGE").ToLocalChecked(), SEND_MESSAGE); + Local<Value> SEND_CLOSE_FROM_CLIENT( + Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_CLOSE_FROM_CLIENT)); + Nan::Set(op_type, Nan::New("SEND_CLOSE_FROM_CLIENT").ToLocalChecked(), + SEND_CLOSE_FROM_CLIENT); + Local<Value> SEND_STATUS_FROM_SERVER( + Nan::New<Uint32, uint32_t>(GRPC_OP_SEND_STATUS_FROM_SERVER)); + Nan::Set(op_type, Nan::New("SEND_STATUS_FROM_SERVER").ToLocalChecked(), + SEND_STATUS_FROM_SERVER); + Local<Value> RECV_INITIAL_METADATA( + Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_INITIAL_METADATA)); + Nan::Set(op_type, Nan::New("RECV_INITIAL_METADATA").ToLocalChecked(), + RECV_INITIAL_METADATA); + Local<Value> RECV_MESSAGE( + Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_MESSAGE)); + Nan::Set(op_type, Nan::New("RECV_MESSAGE").ToLocalChecked(), RECV_MESSAGE); + Local<Value> RECV_STATUS_ON_CLIENT( + Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_STATUS_ON_CLIENT)); + Nan::Set(op_type, Nan::New("RECV_STATUS_ON_CLIENT").ToLocalChecked(), + RECV_STATUS_ON_CLIENT); + Local<Value> RECV_CLOSE_ON_SERVER( + Nan::New<Uint32, uint32_t>(GRPC_OP_RECV_CLOSE_ON_SERVER)); + Nan::Set(op_type, Nan::New("RECV_CLOSE_ON_SERVER").ToLocalChecked(), + RECV_CLOSE_ON_SERVER); } -void InitPropagateConstants(Handle<Object> exports) { - NanScope(); - Handle<Object> propagate = NanNew<Object>(); - exports->Set(NanNew("propagate"), propagate); - Handle<Value> DEADLINE(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE)); - propagate->Set(NanNew("DEADLINE"), DEADLINE); - Handle<Value> CENSUS_STATS_CONTEXT( - NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT)); - propagate->Set(NanNew("CENSUS_STATS_CONTEXT"), CENSUS_STATS_CONTEXT); - Handle<Value> CENSUS_TRACING_CONTEXT( - NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT)); - propagate->Set(NanNew("CENSUS_TRACING_CONTEXT"), CENSUS_TRACING_CONTEXT); - Handle<Value> CANCELLATION( - NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION)); - propagate->Set(NanNew("CANCELLATION"), CANCELLATION); - Handle<Value> DEFAULTS(NanNew<Uint32, uint32_t>(GRPC_PROPAGATE_DEFAULTS)); - propagate->Set(NanNew("DEFAULTS"), DEFAULTS); +void InitPropagateConstants(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> propagate = Nan::New<Object>(); + Nan::Set(exports, Nan::New("propagate").ToLocalChecked(), propagate); + Local<Value> DEADLINE(Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_DEADLINE)); + Nan::Set(propagate, Nan::New("DEADLINE").ToLocalChecked(), DEADLINE); + Local<Value> CENSUS_STATS_CONTEXT( + Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_STATS_CONTEXT)); + Nan::Set(propagate, Nan::New("CENSUS_STATS_CONTEXT").ToLocalChecked(), + CENSUS_STATS_CONTEXT); + Local<Value> CENSUS_TRACING_CONTEXT( + Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT)); + Nan::Set(propagate, Nan::New("CENSUS_TRACING_CONTEXT").ToLocalChecked(), + CENSUS_TRACING_CONTEXT); + Local<Value> CANCELLATION( + Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_CANCELLATION)); + Nan::Set(propagate, Nan::New("CANCELLATION").ToLocalChecked(), CANCELLATION); + Local<Value> DEFAULTS(Nan::New<Uint32, uint32_t>(GRPC_PROPAGATE_DEFAULTS)); + Nan::Set(propagate, Nan::New("DEFAULTS").ToLocalChecked(), DEFAULTS); } -void InitConnectivityStateConstants(Handle<Object> exports) { - NanScope(); - Handle<Object> channel_state = NanNew<Object>(); - exports->Set(NanNew("connectivityState"), channel_state); - Handle<Value> IDLE(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_IDLE)); - channel_state->Set(NanNew("IDLE"), IDLE); - Handle<Value> CONNECTING(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING)); - channel_state->Set(NanNew("CONNECTING"), CONNECTING); - Handle<Value> READY(NanNew<Uint32, uint32_t>(GRPC_CHANNEL_READY)); - channel_state->Set(NanNew("READY"), READY); - Handle<Value> TRANSIENT_FAILURE( - NanNew<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE)); - channel_state->Set(NanNew("TRANSIENT_FAILURE"), TRANSIENT_FAILURE); - Handle<Value> FATAL_FAILURE( - NanNew<Uint32, uint32_t>(GRPC_CHANNEL_FATAL_FAILURE)); - channel_state->Set(NanNew("FATAL_FAILURE"), FATAL_FAILURE); +void InitConnectivityStateConstants(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> channel_state = Nan::New<Object>(); + Nan::Set(exports, Nan::New("connectivityState").ToLocalChecked(), + channel_state); + Local<Value> IDLE(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_IDLE)); + Nan::Set(channel_state, Nan::New("IDLE").ToLocalChecked(), IDLE); + Local<Value> CONNECTING(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_CONNECTING)); + Nan::Set(channel_state, Nan::New("CONNECTING").ToLocalChecked(), CONNECTING); + Local<Value> READY(Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_READY)); + Nan::Set(channel_state, Nan::New("READY").ToLocalChecked(), READY); + Local<Value> TRANSIENT_FAILURE( + Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_TRANSIENT_FAILURE)); + Nan::Set(channel_state, Nan::New("TRANSIENT_FAILURE").ToLocalChecked(), + TRANSIENT_FAILURE); + Local<Value> FATAL_FAILURE( + Nan::New<Uint32, uint32_t>(GRPC_CHANNEL_FATAL_FAILURE)); + Nan::Set(channel_state, Nan::New("FATAL_FAILURE").ToLocalChecked(), + FATAL_FAILURE); } -void InitWriteFlags(Handle<Object> exports) { - NanScope(); - Handle<Object> write_flags = NanNew<Object>(); - exports->Set(NanNew("writeFlags"), write_flags); - Handle<Value> BUFFER_HINT(NanNew<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT)); - write_flags->Set(NanNew("BUFFER_HINT"), BUFFER_HINT); - Handle<Value> NO_COMPRESS(NanNew<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS)); - write_flags->Set(NanNew("NO_COMPRESS"), NO_COMPRESS); +void InitWriteFlags(Local<Object> exports) { + Nan::HandleScope scope; + Local<Object> write_flags = Nan::New<Object>(); + Nan::Set(exports, Nan::New("writeFlags").ToLocalChecked(), write_flags); + Local<Value> BUFFER_HINT(Nan::New<Uint32, uint32_t>(GRPC_WRITE_BUFFER_HINT)); + Nan::Set(write_flags, Nan::New("BUFFER_HINT").ToLocalChecked(), BUFFER_HINT); + Local<Value> NO_COMPRESS(Nan::New<Uint32, uint32_t>(GRPC_WRITE_NO_COMPRESS)); + Nan::Set(write_flags, Nan::New("NO_COMPRESS").ToLocalChecked(), NO_COMPRESS); } -void init(Handle<Object> exports) { - NanScope(); +void init(Local<Object> exports) { + Nan::HandleScope scope; grpc_init(); InitStatusConstants(exports); InitCallErrorConstants(exports); |