src: use NULL check macros to check nullptr

PR-URL: #25916 Refs: #20914 Reviewed-By: Masashi Hirano <shisama07@gmail.com> Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Richard Lau <riclau@uk.ibm.com>

Author: ZYSzys

src/async_wrap.cc

@@ -206,7 +206,7 @@ PromiseWrap* PromiseWrap::New(Environment* env,
  obj->SetInternalField(PromiseWrap::kIsChainedPromiseField,
  parent_wrap != nullptr ? v8::True(env->isolate())
  : v8::False(env->isolate()));
- CHECK_EQ(promise->GetAlignedPointerFromInternalField(0), nullptr);
+ CHECK_NULL(promise->GetAlignedPointerFromInternalField(0));
  promise->SetInternalField(0, obj);
  return new PromiseWrap(env, obj, silent);
 }

src/env-inl.h

@@ -667,7 +667,7 @@ inline worker::Worker* Environment::worker_context() const {
 }
 
 inline void Environment::set_worker_context(worker::Worker* context) {
- CHECK_EQ(worker_context_, nullptr); // Should be set only once.
+ CHECK_NULL(worker_context_); // Should be set only once.
  worker_context_ = context;
 }
 

src/inspector/main_thread_interface.cc

@@ -307,7 +307,7 @@ std::shared_ptr<MainThreadHandle> MainThreadInterface::GetHandle() {
 
 void MainThreadInterface::AddObject(int id,
  std::unique_ptr<Deletable> object) {
- CHECK_NE(nullptr, object);
+ CHECK_NOT_NULL(object);
  managed_objects_[id] = std::move(object);
 }
 
@@ -319,7 +319,7 @@ Deletable* MainThreadInterface::GetObject(int id) {
  Deletable* pointer = GetObjectIfExists(id);
  // This would mean the object is requested after it was disposed, which is
  // a coding error.
- CHECK_NE(nullptr, pointer);
+ CHECK_NOT_NULL(pointer);
  return pointer;
 }
 

src/inspector_agent.cc

@@ -682,7 +682,7 @@ bool Agent::Start(const std::string& path,
  bool is_main) {
  path_ = path;
  debug_options_ = options;
- CHECK_NE(host_port, nullptr);
+ CHECK_NOT_NULL(host_port);
  host_port_ = host_port;
 
  client_ = std::make_shared<NodeInspectorClient>(parent_env_, is_main);

src/inspector_socket_server.cc

@@ -352,7 +352,7 @@ std::string InspectorSocketServer::GetFrontendURL(bool is_compat,
 }
 
 bool InspectorSocketServer::Start() {
- CHECK_NE(delegate_, nullptr);
+ CHECK_NOT_NULL(delegate_);
  CHECK_EQ(state_, ServerState::kNew);
  std::unique_ptr<SocketServerDelegate> delegate_holder;
  // We will return it if startup is successful

src/node.cc

@@ -336,7 +336,7 @@ void MarkBootstrapComplete(const FunctionCallbackInfo<Value>& args) {
 
 MaybeLocal<Value> StartExecution(Environment* env, const char* main_script_id) {
  EscapableHandleScope scope(env->isolate());
- CHECK_NE(main_script_id, nullptr);
+ CHECK_NOT_NULL(main_script_id);
 
  std::vector<Local<String>> parameters = {
  env->process_string(),

src/node_api.cc

@@ -1043,8 +1043,8 @@ napi_create_threadsafe_function(napi_env env,
 napi_status
 napi_get_threadsafe_function_context(napi_threadsafe_function func,
  void** result) {
- CHECK(func != nullptr);
- CHECK(result != nullptr);
+ CHECK_NOT_NULL(func);
+ CHECK_NOT_NULL(result);
 
  *result = reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Context();
  return napi_ok;
@@ -1054,32 +1054,32 @@ napi_status
 napi_call_threadsafe_function(napi_threadsafe_function func,
  void* data,
  napi_threadsafe_function_call_mode is_blocking) {
- CHECK(func != nullptr);
+ CHECK_NOT_NULL(func);
  return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Push(data,
  is_blocking);
 }
 
 napi_status
 napi_acquire_threadsafe_function(napi_threadsafe_function func) {
- CHECK(func != nullptr);
+ CHECK_NOT_NULL(func);
  return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Acquire();
 }
 
 napi_status
 napi_release_threadsafe_function(napi_threadsafe_function func,
  napi_threadsafe_function_release_mode mode) {
- CHECK(func != nullptr);
+ CHECK_NOT_NULL(func);
  return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Release(mode);
 }
 
 napi_status
 napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func) {
- CHECK(func != nullptr);
+ CHECK_NOT_NULL(func);
  return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Unref();
 }
 
 napi_status
 napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func) {
- CHECK(func != nullptr);
+ CHECK_NOT_NULL(func);
  return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Ref();
 }

src/node_crypto.cc

@@ -5408,7 +5408,7 @@ void CryptoJob::AfterThreadPoolWork(int status) {
 
 void CryptoJob::Run(std::unique_ptr<CryptoJob> job, Local<Value> wrap) {
  CHECK(wrap->IsObject());
- CHECK_EQ(nullptr, job->async_wrap);
+ CHECK_NULL(job->async_wrap);
  job->async_wrap.reset(Unwrap<AsyncWrap>(wrap.As<Object>()));
  CHECK_EQ(false, job->async_wrap->persistent().IsWeak());
  job->ScheduleWork();

src/node_http2.cc

@@ -530,7 +530,7 @@ class Http2Session::MemoryAllocatorInfo {
  static void H2Free(void* ptr, void* user_data) {
  if (ptr == nullptr) return; // free(null); happens quite often.
  void* result = H2Realloc(ptr, 0, user_data);
- CHECK_EQ(result, nullptr);
+ CHECK_NULL(result);
  }
 
  static void* H2Realloc(void* ptr, size_t size, void* user_data) {

src/node_http_parser_impl.h

@@ -744,7 +744,7 @@ class Parser : public AsyncWrap, public StreamListener {
  Local<String> reason;
  if (err == HPE_USER) {
  const char* colon = strchr(errno_reason, ':');
- CHECK_NE(colon, nullptr);
+ CHECK_NOT_NULL(colon);
  code = OneByteString(env()->isolate(), errno_reason,
  colon - errno_reason);
  reason = OneByteString(env()->isolate(), colon + 1);