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

@@ -210,7 +210,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

@@ -340,7 +340,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

@@ -5383,7 +5383,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

@@ -521,7 +521,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);