From cc01e5ba2307bb9f9786420b3225cb9b78a525d2 Mon Sep 17 00:00:00 2001
From: luhan <luhan22@huawei.com>
Date: Mon, 9 Sep 2024 20:23:10 +0800
Subject: [PATCH 1/5] =?UTF-8?q?pixelMap=20ICSL=E5=AE=89=E5=85=A8=E6=95=B4?=
 =?UTF-8?q?=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: luhan <luhan22@huawei.com>
---
 .../innerkitsimpl/common/src/pixel_map.cpp    |   6 +-
 frameworks/kits/js/common/pixel_map_napi.cpp  | 210 ++++++++++--------
 .../common/pixelmap_ndk/pixelmap_native.cpp   |   2 +
 .../sendable/sendable_pixel_map_napi.cpp      | 201 +++++++++--------
 4 files changed, 233 insertions(+), 186 deletions(-)

diff --git a/frameworks/innerkitsimpl/common/src/pixel_map.cpp b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
index 2c230ea12..947eb9267 100644
--- a/frameworks/innerkitsimpl/common/src/pixel_map.cpp
+++ b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
@@ -1053,8 +1053,10 @@ uint32_t PixelMap::SetImageInfo(ImageInfo &info, bool isReused)
         return ERR_IMAGE_DATA_ABNORMAL;
     }
 
-    if (allocatorType_ == AllocatorType::HEAP_ALLOC &&
-        ((static_cast<uint64_t>(pixelBytes_) * info.size.width * info.size.height) > PIXEL_MAP_MAX_RAM_SIZE)) {
+    uint64_t totalSize = static_cast<uint64_t>(pixelBytes_) *
+        static_cast<uint64_t>(info.size.width) * static_cast<uint64_t>(info.size.height);
+    if ((allocatorType_ == AllocatorType::HEAP_ALLOC &&
+        totalSize > PIXEL_MAP_MAX_RAM_SIZE) || totalSize > INT_MAX) {
         ResetPixelMap();
         IMAGE_LOGE("image size is out of range.");
         return ERR_IMAGE_TOO_LARGE;
diff --git a/frameworks/kits/js/common/pixel_map_napi.cpp b/frameworks/kits/js/common/pixel_map_napi.cpp
index 2421d7426..05dfabd3b 100644
--- a/frameworks/kits/js/common/pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/pixel_map_napi.cpp
@@ -1047,8 +1047,11 @@ napi_value PixelMapNapi::CreatePremultipliedPixelMap(napi_env env, napi_callback
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePremultipliedPixelMap",
         CreatePremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1099,8 +1102,11 @@ napi_value PixelMapNapi::CreateUnpremultipliedPixelMap(napi_env env, napi_callba
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateUnpremultipliedPixelMap",
         CreateUnpremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1151,8 +1157,11 @@ napi_value PixelMapNapi::CreatePixelMap(napi_env env, napi_callback_info info)
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePixelMap",
         CreatePixelMapExec, CreatePixelMapComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1319,7 +1328,6 @@ napi_value PixelMapNapi::CreatePixelMapFromSurface(napi_env env, napi_callback_i
     napi_value funcArgv[1] = { imageInfo };
     napi_value returnValue;
     napi_call_function(env, globalValue, func, 1, funcArgv, &returnValue);
-
     napi_value result = nullptr;
     napi_get_undefined(env, &result);
     int32_t refCount = 1;
@@ -1345,12 +1353,14 @@ napi_value PixelMapNapi::CreatePixelMapFromSurface(napi_env env, napi_callback_i
     IMG_NAPI_CHECK_BUILD_ERROR(ret,
         BuildContextError(env, asyncContext->error, "image invalid parameter", ERR_IMAGE_GET_DATA_ABNORMAL),
         IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePixelMapFromSurfaceGeneralError",
-        [](napi_env env, void *data) {}, GeneralErrorComplete, asyncContext, asyncContext->work),
-        result);
+        [](napi_env env, void *data) {}, GeneralErrorComplete, asyncContext, asyncContext->work), result);
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePixelMapFromSurface",
         CreatePixelMapFromSurfaceExec, CreatePixelMapFromSurfaceComplete, asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 #endif
 }
@@ -1514,8 +1524,10 @@ napi_value PixelMapNapi::Unmarshalling(napi_env env, napi_callback_info info)
         napi_create_reference(env, argValue[argCount - 1], refCount, &asyncContext->callbackRef);
     }
 
-    napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
+    status = napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
 
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence),
+        result, IMAGE_LOGE("fail to unwrap context"));
     if (asyncContext->callbackRef == nullptr) {
         napi_create_promise(env, &(asyncContext->deferred), &result);
     } else {
@@ -1526,6 +1538,7 @@ napi_value PixelMapNapi::Unmarshalling(napi_env env, napi_callback_info info)
         UnmarshallingExec, UnmarshallingComplete, asyncContext, asyncContext->work);
 
     if (!IMG_IS_OK(status)) {
+        napi_delete_reference(env, asyncContext->callbackRef);
         return ImageNapiUtils::ThrowExceptionError(
             env, ERROR, "Fail to create async work");
     }
@@ -1573,7 +1586,9 @@ napi_value PixelMapNapi::CreatePixelMapFromParcel(napi_env env, napi_callback_in
             CREATE_PIXEL_MAP_FROM_PARCEL, ERR_IMAGE_INVALID_PARAMETER, "Fail to napi_get_cb_info");
     }
     std::unique_ptr<PixelMapAsyncContext> asyncContext = std::make_unique<PixelMapAsyncContext>();
-    napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
+    status = napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence),
+    result, IMAGE_LOGE("fail to unwrap context"));
     auto messageParcel = napi_messageSequence->GetMessageParcel();
     if (messageParcel == nullptr) {
         return PixelMapNapi::ThrowExceptionError(env,
@@ -1711,8 +1726,11 @@ napi_value PixelMapNapi::ReadPixelsToBuffer(napi_env env, napi_callback_info inf
                 context->colorsBufferSize, static_cast<uint8_t*>(context->colorsBuffer));
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1815,8 +1833,11 @@ napi_value PixelMapNapi::ReadPixels(napi_env env, napi_callback_info info)
                 area.size, area.offset, area.stride, area.region, static_cast<uint8_t*>(area.pixels));
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1911,8 +1932,11 @@ napi_value PixelMapNapi::WritePixels(napi_env env, napi_callback_info info)
                 static_cast<uint8_t*>(area.pixels), area.size, area.offset, area.stride, area.region);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2008,8 +2032,11 @@ napi_value PixelMapNapi::WriteBufferToPixels(napi_env env, napi_callback_info in
                 context->colorsBufferSize);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2159,8 +2186,11 @@ napi_value PixelMapNapi::GetImageInfo(napi_env env, napi_callback_info info)
             context->rPixelMap->GetImageInfo(context->imageInfo);
             context->status = SUCCESS;
         }, GetImageInfoComplete, asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2404,8 +2434,11 @@ napi_value PixelMapNapi::CreateAlphaPixelmap(napi_env env, napi_callback_info in
             context->alphaMap = std::move(tmpPixelMap);
             context->status = SUCCESS;
         }, CreateAlphaPixelmapComplete, asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2566,8 +2599,11 @@ napi_value PixelMapNapi::Release(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2663,19 +2699,18 @@ napi_value PixelMapNapi::SetAlpha(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "SetAlphaGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "SetAlpha", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "SetAlpha",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             SetAlphaExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        },
+        EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (!IMG_IS_OK(nVal.status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+        return nullptr;
     }
     return nVal.result;
 }
@@ -2863,6 +2898,7 @@ napi_value PixelMapNapi::ScaleSync(napi_env env, napi_callback_info info)
     } else {
         IMAGE_LOGE("Null native ref");
     }
+
     return result;
 }
 
@@ -2885,6 +2921,16 @@ static void TranslateExec(napi_env env, PixelMapAsyncContext* context)
     }
 }
 
+static void CheckNapiValues(NapiValues& nVals, napi_env& env)
+{
+    if (nVals.status == napi_ok) {
+        nVals.context.release();
+    } else {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVals.context->callbackRef);
+    }
+}
+
 napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
 {
     NapiValues nVal;
@@ -2896,7 +2942,6 @@ napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
         return nVal.result;
     }
     nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
-
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count");
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -2913,7 +2958,6 @@ napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
-
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -2922,20 +2966,15 @@ napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "TranslateGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Translate", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Translate",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             TranslateExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
+
+    CheckNapiValues(nVal, env);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
-    }
     return nVal.result;
 }
 
@@ -3029,25 +3068,20 @@ napi_value PixelMapNapi::Rotate(napi_env env, napi_callback_info info)
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
+
     IMG_NAPI_CHECK_BUILD_ERROR(nVal.context->nConstructor->GetPixelNapiEditable(),
         BuildContextError(env, nVal.context->error, "pixelmap has crossed threads . Rotate failed",
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "RotateGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Rotate", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Rotate",
         [](napi_env env, void *data) {
-            auto context = static_cast<PixelMapAsyncContext*>(data);
-            RotateExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        auto context = static_cast<PixelMapAsyncContext*>(data);
+        RotateExec(env, context);
+    }, EmptyResultComplete, nVal.context, nVal.context->work);
+    CheckNapiValues(nVal, env);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
-    }
     return nVal.result;
 }
 
@@ -3117,8 +3151,8 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
     if (!prepareNapiEnv(env, info, &nVal)) {
         return nVal.result;
     }
-    nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
 
+    nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count");
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -3132,10 +3166,10 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
     }
+    
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
-
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -3144,20 +3178,14 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "FlipGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Flip", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Flip",
         [](napi_env env, void *data) {
-            auto context = static_cast<PixelMapAsyncContext*>(data);
-            FlipExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        auto context = static_cast<PixelMapAsyncContext*>(data);
+        FlipExec(env, context);
+    }, EmptyResultComplete, nVal.context, nVal.context->work);
+    CheckNapiValues(nVal, env);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
-    }
     return nVal.result;
 }
 
@@ -3260,20 +3288,15 @@ napi_value PixelMapNapi::Crop(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "CropGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "CropExec", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "CropExec",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             CropExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+            }, EmptyResultComplete, nVal.context, nVal.context->work);
+
+    CheckNapiValues(nVal, env);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
-    }
     return nVal.result;
 }
 
@@ -3515,7 +3538,9 @@ napi_value PixelMapNapi::Marshalling(napi_env env, napi_callback_info info)
     }
     NAPI_MessageSequence *napiSequence = nullptr;
     napi_get_cb_info(env, info, &nVal.argc, nVal.argv, nullptr, nullptr);
-    napi_unwrap(env, nVal.argv[0], reinterpret_cast<void**>(&napiSequence));
+    napi_status status = napi_unwrap(env, nVal.argv[0], reinterpret_cast<void**>(&napiSequence));
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napiSequence),
+        nullptr, IMAGE_LOGE("fail to unwrap context"));
     auto messageParcel = napiSequence->GetMessageParcel();
     if (messageParcel == nullptr) {
         return ImageNapiUtils::ThrowExceptionError(
@@ -3598,19 +3623,14 @@ napi_value PixelMapNapi::ApplyColorSpace(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "ApplyColorSpaceGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "ApplyColorSpace", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource, [](napi_env env, void *data) {
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "ApplyColorSpace",
+        [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             ApplyColorSpaceExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
+    CheckNapiValues(nVal, env);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
-    }
     return nVal.result;
 }
 
diff --git a/frameworks/kits/js/common/pixelmap_ndk/pixelmap_native.cpp b/frameworks/kits/js/common/pixelmap_ndk/pixelmap_native.cpp
index 8b07831e2..072446d2b 100644
--- a/frameworks/kits/js/common/pixelmap_ndk/pixelmap_native.cpp
+++ b/frameworks/kits/js/common/pixelmap_ndk/pixelmap_native.cpp
@@ -309,6 +309,7 @@ Image_ErrorCode OH_PixelmapInitializationOptions_Release(OH_Pixelmap_Initializat
         return IMAGE_BAD_PARAMETER;
     }
     delete ops;
+    ops = nullptr;
     return IMAGE_SUCCESS;
 }
 
@@ -392,6 +393,7 @@ Image_ErrorCode OH_PixelmapImageInfo_Release(OH_Pixelmap_ImageInfo *info)
         return IMAGE_BAD_PARAMETER;
     }
     delete  info;
+    info = nullptr;
     return IMAGE_SUCCESS;
 }
 
diff --git a/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp b/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
index 5f4702152..0f2f06e89 100644
--- a/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
@@ -694,8 +694,11 @@ napi_value SendablePixelMapNapi::CreatePremultipliedSendablePixelMap(napi_env en
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePremultipliedPixelMap",
         CreatePremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -746,8 +749,11 @@ napi_value SendablePixelMapNapi::CreateUnpremultipliedSendablePixelMap(napi_env
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateUnpremultipliedPixelMap",
         CreateUnpremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -798,8 +804,11 @@ napi_value SendablePixelMapNapi::CreateSendablePixelMap(napi_env env, napi_callb
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateSendablePixelMap",
         CreateSendablePixelMapExec, CreateSendablePixelMapComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1038,8 +1047,11 @@ napi_value SendablePixelMapNapi::CreateSendablePixelMapFromSurface(napi_env env,
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateSendablePixelMapFromSurface",
         CreateSendablePixelMapFromSurfaceExec, CreateSendablePixelMapFromSurfaceComplete,
         asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 #endif
@@ -1150,6 +1162,7 @@ napi_value SendablePixelMapNapi::Unmarshalling(napi_env env, napi_callback_info
         UnmarshallingExec, UnmarshallingComplete, asyncContext, asyncContext->work);
 
     if (!IMG_IS_OK(status)) {
+        napi_delete_reference(env, asyncContext->callbackRef);
         return ImageNapiUtils::ThrowExceptionError(
             env, ERROR, "Fail to create async work");
     }
@@ -1327,8 +1340,11 @@ napi_value SendablePixelMapNapi::ReadPixelsToBuffer(napi_env env, napi_callback_
                 context->colorsBufferSize, static_cast<uint8_t*>(context->colorsBuffer));
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1432,8 +1448,11 @@ napi_value SendablePixelMapNapi::ReadPixels(napi_env env, napi_callback_info inf
                 area.size, area.offset, area.stride, area.region, static_cast<uint8_t*>(area.pixels));
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1530,8 +1549,11 @@ napi_value SendablePixelMapNapi::WritePixels(napi_env env, napi_callback_info in
                 static_cast<uint8_t*>(area.pixels), area.size, area.offset, area.stride, area.region);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1630,8 +1652,11 @@ napi_value SendablePixelMapNapi::WriteBufferToPixels(napi_env env, napi_callback
                 context->colorsBufferSize);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -1772,14 +1797,19 @@ napi_value SendablePixelMapNapi::GetImageInfo(napi_env env, napi_callback_info i
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, status, "GetImageInfoGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, asyncContext, asyncContext->work),
         result);
+
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "GetImageInfo",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             context->rPixelMap->GetImageInfo(context->imageInfo);
             context->status = SUCCESS;
         }, GetImageInfoComplete, asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2015,6 +2045,7 @@ napi_value SendablePixelMapNapi::CreateAlphaPixelmap(napi_env env, napi_callback
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateAlphaPixelmapGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, asyncContext, asyncContext->work),
         result);
+
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateAlphaPixelmap",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
@@ -2024,8 +2055,12 @@ napi_value SendablePixelMapNapi::CreateAlphaPixelmap(napi_env env, napi_callback
             context->alphaMap = std::move(tmpPixelMap);
             context->status = SUCCESS;
         }, CreateAlphaPixelmapComplete, asyncContext, asyncContext->work);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2188,8 +2223,11 @@ napi_value SendablePixelMapNapi::Release(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status),
-        nullptr, IMAGE_LOGE("fail to create async work"));
+    if (!IMG_IS_OK(status)) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, asyncContext->callbackRef);
+        return nullptr;
+    }
     return result;
 }
 
@@ -2276,20 +2314,18 @@ napi_value SendablePixelMapNapi::SetAlpha(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "SetAlphaGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "SetAlpha", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "SetAlpha",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             SetAlphaExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -2368,7 +2404,6 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
         return nVal.result;
     }
     nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
-
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count %{public}zu", nVal.argc);
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -2377,15 +2412,16 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
             IMAGE_LOGE("Arg 0 type mismatch");
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
+
         if (napi_ok != napi_get_value_double(env, nVal.argv[NUM_1], &(nVal.context->yArg))) {
             IMAGE_LOGE("Arg 1 type mismatch");
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
     }
+
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
-
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -2394,20 +2430,18 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "ScaleGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Scale", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK_WITH_QOS(env, nVal.status, "Scale",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             ScaleExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work, napi_qos_user_initiated);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work_with_qos(env, nVal.context->work, napi_qos_user_initiated);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -2483,7 +2517,6 @@ napi_value SendablePixelMapNapi::Translate(napi_env env, napi_callback_info info
         return nVal.result;
     }
     nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
-
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count");
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -2500,7 +2533,6 @@ napi_value SendablePixelMapNapi::Translate(napi_env env, napi_callback_info info
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
-
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -2509,20 +2541,18 @@ napi_value SendablePixelMapNapi::Translate(napi_env env, napi_callback_info info
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "TranslateGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Translate", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Translate",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             TranslateExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -2622,20 +2652,18 @@ napi_value SendablePixelMapNapi::Rotate(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "RotateGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Rotate", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Rotate",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             RotateExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -2733,20 +2761,18 @@ napi_value SendablePixelMapNapi::Flip(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "FlipGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "Flip", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Flip",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             FlipExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -2851,20 +2877,18 @@ napi_value SendablePixelMapNapi::Crop(napi_env env, napi_callback_info info)
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "CropGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "CropExec", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource,
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "CropExec",
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             CropExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
@@ -3083,19 +3107,18 @@ napi_value SendablePixelMapNapi::ApplyColorSpace(napi_env env, napi_callback_inf
         ERR_RESOURCE_UNAVAILABLE), IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "ApplyColorSpaceGeneralError",
         [](napi_env env, void *data) {}, GeneralErrorComplete, nVal.context, nVal.context->work),
         nVal.result);
-    napi_value _resource = nullptr;
-    napi_create_string_utf8(env, "ApplyColorSpace", NAPI_AUTO_LENGTH, &_resource);
-    nVal.status = napi_create_async_work(env, nullptr, _resource, [](napi_env env, void *data) {
+
+    IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "ApplyColorSpace",
+        [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             ApplyColorSpaceExec(env, context);
-        }, EmptyResultComplete, static_cast<void*>(nVal.context.get()), &(nVal.context->work));
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status == napi_ok) {
-        nVal.status = napi_queue_async_work(env, nVal.context->work);
-        if (nVal.status == napi_ok) {
-            nVal.context.release();
-        }
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
     }
+
     return nVal.result;
 }
 
-- 
Gitee


From 2541ed08701318ce6cfbea80bad00cc6bad8e150 Mon Sep 17 00:00:00 2001
From: luhan <luhan22@huawei.com>
Date: Thu, 12 Sep 2024 10:27:44 +0800
Subject: [PATCH 2/5] =?UTF-8?q?PixelMap=20ICSL=20=E5=AE=89=E5=85=A8?=
 =?UTF-8?q?=E6=95=B4=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: luhan <luhan22@huawei.com>
---
 frameworks/kits/js/common/pixel_map_napi.cpp | 43 ++++++++++++--------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/frameworks/kits/js/common/pixel_map_napi.cpp b/frameworks/kits/js/common/pixel_map_napi.cpp
index 05dfabd3b..1ef36c11f 100644
--- a/frameworks/kits/js/common/pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/pixel_map_napi.cpp
@@ -1526,8 +1526,7 @@ napi_value PixelMapNapi::Unmarshalling(napi_env env, napi_callback_info info)
 
     status = napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
 
-    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence),
-        result, IMAGE_LOGE("fail to unwrap context"));
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence), result, IMAGE_LOGE("fail to unwrap context"));
     if (asyncContext->callbackRef == nullptr) {
         napi_create_promise(env, &(asyncContext->deferred), &result);
     } else {
@@ -1588,7 +1587,7 @@ napi_value PixelMapNapi::CreatePixelMapFromParcel(napi_env env, napi_callback_in
     std::unique_ptr<PixelMapAsyncContext> asyncContext = std::make_unique<PixelMapAsyncContext>();
     status = napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
     IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence),
-    result, IMAGE_LOGE("fail to unwrap context"));
+        result, IMAGE_LOGE("fail to unwrap context"));
     auto messageParcel = napi_messageSequence->GetMessageParcel();
     if (messageParcel == nullptr) {
         return PixelMapNapi::ThrowExceptionError(env,
@@ -2921,16 +2920,6 @@ static void TranslateExec(napi_env env, PixelMapAsyncContext* context)
     }
 }
 
-static void CheckNapiValues(NapiValues& nVals, napi_env& env)
-{
-    if (nVals.status == napi_ok) {
-        nVals.context.release();
-    } else {
-        IMAGE_LOGE("fail to create async work");
-        napi_delete_reference(env, nVals.context->callbackRef);
-    }
-}
-
 napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
 {
     NapiValues nVal;
@@ -2973,7 +2962,10 @@ napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
             TranslateExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    CheckNapiValues(nVal, env);
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+    }
 
     return nVal.result;
 }
@@ -3080,7 +3072,11 @@ napi_value PixelMapNapi::Rotate(napi_env env, napi_callback_info info)
         auto context = static_cast<PixelMapAsyncContext*>(data);
         RotateExec(env, context);
     }, EmptyResultComplete, nVal.context, nVal.context->work);
-    CheckNapiValues(nVal, env);
+
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+    }
 
     return nVal.result;
 }
@@ -3184,7 +3180,11 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
         auto context = static_cast<PixelMapAsyncContext*>(data);
         FlipExec(env, context);
     }, EmptyResultComplete, nVal.context, nVal.context->work);
-    CheckNapiValues(nVal, env);
+
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+    }
 
     return nVal.result;
 }
@@ -3295,7 +3295,10 @@ napi_value PixelMapNapi::Crop(napi_env env, napi_callback_info info)
             CropExec(env, context);
             }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    CheckNapiValues(nVal, env);
+    if (nVal.status != napi_ok) {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+    }
 
     return nVal.result;
 }
@@ -3629,7 +3632,11 @@ napi_value PixelMapNapi::ApplyColorSpace(napi_env env, napi_callback_info info)
             auto context = static_cast<PixelMapAsyncContext*>(data);
             ApplyColorSpaceExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
-    CheckNapiValues(nVal, env);
+
+        if (nVal.status != napi_ok) {
+            IMAGE_LOGE("fail to create async work");
+            napi_delete_reference(env, nVal.context->callbackRef);
+        }
 
     return nVal.result;
 }
-- 
Gitee


From 642c5f877858e313e126eadc75ed701408bcf1fa Mon Sep 17 00:00:00 2001
From: luhan <luhan22@huawei.com>
Date: Thu, 12 Sep 2024 11:06:14 +0800
Subject: [PATCH 3/5] =?UTF-8?q?PixelMap=20ICSL=20=E5=AE=89=E5=85=A8?=
 =?UTF-8?q?=E6=95=B4=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: luhan <luhan22@huawei.com>
---
 .../innerkitsimpl/common/src/pixel_map.cpp    |  7 +++----
 frameworks/kits/js/common/pixel_map_napi.cpp  | 19 ++++++++-----------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/frameworks/innerkitsimpl/common/src/pixel_map.cpp b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
index 947eb9267..0d2cafb6f 100644
--- a/frameworks/innerkitsimpl/common/src/pixel_map.cpp
+++ b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
@@ -1053,10 +1053,9 @@ uint32_t PixelMap::SetImageInfo(ImageInfo &info, bool isReused)
         return ERR_IMAGE_DATA_ABNORMAL;
     }
 
-    uint64_t totalSize = static_cast<uint64_t>(pixelBytes_) *
-        static_cast<uint64_t>(info.size.width) * static_cast<uint64_t>(info.size.height);
-    if ((allocatorType_ == AllocatorType::HEAP_ALLOC &&
-        totalSize > PIXEL_MAP_MAX_RAM_SIZE) || totalSize > INT_MAX) {
+    uint64_t totalSize = static_cast<uint64_t>(pixelBytes_) * static_cast<uint64_t>(info.size.width) *
+        static_cast<uint64_t>(info.size.height);
+    if ((allocatorType_ == AllocatorType::HEAP_ALLOC && totalSize > PIXEL_MAP_MAX_RAM_SIZE) || totalSize > INT_MAX) {
         ResetPixelMap();
         IMAGE_LOGE("image size is out of range.");
         return ERR_IMAGE_TOO_LARGE;
diff --git a/frameworks/kits/js/common/pixel_map_napi.cpp b/frameworks/kits/js/common/pixel_map_napi.cpp
index 1ef36c11f..c198f0fcc 100644
--- a/frameworks/kits/js/common/pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/pixel_map_napi.cpp
@@ -1586,8 +1586,7 @@ napi_value PixelMapNapi::CreatePixelMapFromParcel(napi_env env, napi_callback_in
     }
     std::unique_ptr<PixelMapAsyncContext> asyncContext = std::make_unique<PixelMapAsyncContext>();
     status = napi_unwrap(env, argValue[NUM_0], (void **)&napi_messageSequence);
-    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence),
-        result, IMAGE_LOGE("fail to unwrap context"));
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napi_messageSequence), result, IMAGE_LOGE("fail to unwrap context"));
     auto messageParcel = napi_messageSequence->GetMessageParcel();
     if (messageParcel == nullptr) {
         return PixelMapNapi::ThrowExceptionError(env,
@@ -2709,7 +2708,6 @@ napi_value PixelMapNapi::SetAlpha(napi_env env, napi_callback_info info)
     if (!IMG_IS_OK(nVal.status)) {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-        return nullptr;
     }
     return nVal.result;
 }
@@ -3069,9 +3067,9 @@ napi_value PixelMapNapi::Rotate(napi_env env, napi_callback_info info)
 
     IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Rotate",
         [](napi_env env, void *data) {
-        auto context = static_cast<PixelMapAsyncContext*>(data);
-        RotateExec(env, context);
-    }, EmptyResultComplete, nVal.context, nVal.context->work);
+            auto context = static_cast<PixelMapAsyncContext*>(data);
+            RotateExec(env, context);
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
     if (nVal.status != napi_ok) {
         IMAGE_LOGE("fail to create async work");
@@ -3177,9 +3175,9 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
 
     IMG_CREATE_CREATE_ASYNC_WORK(env, nVal.status, "Flip",
         [](napi_env env, void *data) {
-        auto context = static_cast<PixelMapAsyncContext*>(data);
-        FlipExec(env, context);
-    }, EmptyResultComplete, nVal.context, nVal.context->work);
+            auto context = static_cast<PixelMapAsyncContext*>(data);
+            FlipExec(env, context);
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
     if (nVal.status != napi_ok) {
         IMAGE_LOGE("fail to create async work");
@@ -3542,8 +3540,7 @@ napi_value PixelMapNapi::Marshalling(napi_env env, napi_callback_info info)
     NAPI_MessageSequence *napiSequence = nullptr;
     napi_get_cb_info(env, info, &nVal.argc, nVal.argv, nullptr, nullptr);
     napi_status status = napi_unwrap(env, nVal.argv[0], reinterpret_cast<void**>(&napiSequence));
-    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napiSequence),
-        nullptr, IMAGE_LOGE("fail to unwrap context"));
+    IMG_NAPI_CHECK_RET_D(IMG_IS_READY(status, napiSequence), nullptr, IMAGE_LOGE("fail to unwrap context"));
     auto messageParcel = napiSequence->GetMessageParcel();
     if (messageParcel == nullptr) {
         return ImageNapiUtils::ThrowExceptionError(
-- 
Gitee


From 829a3f418ce822f2eb25d6cca4fef62989d67554 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B1=91=E5=B1=91=E5=B1=91?= <jiangwenda5@h-partners.com>
Date: Thu, 12 Sep 2024 11:25:01 +0800
Subject: [PATCH 4/5] =?UTF-8?q?PixelMap=20ICSL=20=E5=AE=89=E5=85=A8?=
 =?UTF-8?q?=E6=95=B4=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: 屑屑屑 <jiangwenda5@h-partners.com>
---
 frameworks/kits/js/common/pixel_map_napi.cpp  | 94 ++++++++-----------
 .../sendable/sendable_pixel_map_napi.cpp      | 85 +++++++----------
 2 files changed, 77 insertions(+), 102 deletions(-)

diff --git a/frameworks/kits/js/common/pixel_map_napi.cpp b/frameworks/kits/js/common/pixel_map_napi.cpp
index c198f0fcc..c91058512 100644
--- a/frameworks/kits/js/common/pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/pixel_map_napi.cpp
@@ -1047,11 +1047,10 @@ napi_value PixelMapNapi::CreatePremultipliedPixelMap(napi_env env, napi_callback
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePremultipliedPixelMap",
         CreatePremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1102,11 +1101,10 @@ napi_value PixelMapNapi::CreateUnpremultipliedPixelMap(napi_env env, napi_callba
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateUnpremultipliedPixelMap",
         CreateUnpremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1157,11 +1155,10 @@ napi_value PixelMapNapi::CreatePixelMap(napi_env env, napi_callback_info info)
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePixelMap",
         CreatePixelMapExec, CreatePixelMapComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1328,6 +1325,7 @@ napi_value PixelMapNapi::CreatePixelMapFromSurface(napi_env env, napi_callback_i
     napi_value funcArgv[1] = { imageInfo };
     napi_value returnValue;
     napi_call_function(env, globalValue, func, 1, funcArgv, &returnValue);
+
     napi_value result = nullptr;
     napi_get_undefined(env, &result);
     int32_t refCount = 1;
@@ -1356,11 +1354,10 @@ napi_value PixelMapNapi::CreatePixelMapFromSurface(napi_env env, napi_callback_i
         [](napi_env env, void *data) {}, GeneralErrorComplete, asyncContext, asyncContext->work), result);
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePixelMapFromSurface",
         CreatePixelMapFromSurfaceExec, CreatePixelMapFromSurfaceComplete, asyncContext, asyncContext->work);
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 #endif
 }
@@ -1724,11 +1721,10 @@ napi_value PixelMapNapi::ReadPixelsToBuffer(napi_env env, napi_callback_info inf
                 context->colorsBufferSize, static_cast<uint8_t*>(context->colorsBuffer));
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1831,11 +1827,10 @@ napi_value PixelMapNapi::ReadPixels(napi_env env, napi_callback_info info)
                 area.size, area.offset, area.stride, area.region, static_cast<uint8_t*>(area.pixels));
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1930,11 +1925,10 @@ napi_value PixelMapNapi::WritePixels(napi_env env, napi_callback_info info)
                 static_cast<uint8_t*>(area.pixels), area.size, area.offset, area.stride, area.region);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2030,11 +2024,10 @@ napi_value PixelMapNapi::WriteBufferToPixels(napi_env env, napi_callback_info in
                 context->colorsBufferSize);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2184,11 +2177,10 @@ napi_value PixelMapNapi::GetImageInfo(napi_env env, napi_callback_info info)
             context->rPixelMap->GetImageInfo(context->imageInfo);
             context->status = SUCCESS;
         }, GetImageInfoComplete, asyncContext, asyncContext->work);
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2432,11 +2424,10 @@ napi_value PixelMapNapi::CreateAlphaPixelmap(napi_env env, napi_callback_info in
             context->alphaMap = std::move(tmpPixelMap);
             context->status = SUCCESS;
         }, CreateAlphaPixelmapComplete, asyncContext, asyncContext->work);
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2597,11 +2588,10 @@ napi_value PixelMapNapi::Release(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2702,13 +2692,12 @@ napi_value PixelMapNapi::SetAlpha(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             SetAlphaExec(env, context);
-        },
-        EmptyResultComplete, nVal.context, nVal.context->work);
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (!IMG_IS_OK(nVal.status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
     return nVal.result;
 }
 
@@ -2895,7 +2884,6 @@ napi_value PixelMapNapi::ScaleSync(napi_env env, napi_callback_info info)
     } else {
         IMAGE_LOGE("Null native ref");
     }
-
     return result;
 }
 
@@ -2960,10 +2948,10 @@ napi_value PixelMapNapi::Translate(napi_env env, napi_callback_info info)
             TranslateExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -3071,10 +3059,10 @@ napi_value PixelMapNapi::Rotate(napi_env env, napi_callback_info info)
             RotateExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -3145,8 +3133,8 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
     if (!prepareNapiEnv(env, info, &nVal)) {
         return nVal.result;
     }
-
     nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
+
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count");
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -3160,10 +3148,10 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
     }
-    
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
+
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -3179,10 +3167,10 @@ napi_value PixelMapNapi::Flip(napi_env env, napi_callback_info info)
             FlipExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -3291,12 +3279,12 @@ napi_value PixelMapNapi::Crop(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             auto context = static_cast<PixelMapAsyncContext*>(data);
             CropExec(env, context);
-            }, EmptyResultComplete, nVal.context, nVal.context->work);
+        }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -3630,10 +3618,10 @@ napi_value PixelMapNapi::ApplyColorSpace(napi_env env, napi_callback_info info)
             ApplyColorSpaceExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-        if (nVal.status != napi_ok) {
-            IMAGE_LOGE("fail to create async work");
-            napi_delete_reference(env, nVal.context->callbackRef);
-        }
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
+        IMAGE_LOGE("fail to create async work");
+        napi_delete_reference(env, nVal.context->callbackRef);
+    });
 
     return nVal.result;
 }
diff --git a/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp b/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
index 0f2f06e89..41ebcea2e 100644
--- a/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
+++ b/frameworks/kits/js/common/sendable/sendable_pixel_map_napi.cpp
@@ -694,11 +694,10 @@ napi_value SendablePixelMapNapi::CreatePremultipliedSendablePixelMap(napi_env en
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreatePremultipliedPixelMap",
         CreatePremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -749,11 +748,10 @@ napi_value SendablePixelMapNapi::CreateUnpremultipliedSendablePixelMap(napi_env
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateUnpremultipliedPixelMap",
         CreateUnpremultipliedPixelMapExec, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -804,11 +802,10 @@ napi_value SendablePixelMapNapi::CreateSendablePixelMap(napi_env env, napi_callb
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateSendablePixelMap",
         CreateSendablePixelMapExec, CreateSendablePixelMapComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1047,11 +1044,10 @@ napi_value SendablePixelMapNapi::CreateSendablePixelMapFromSurface(napi_env env,
     IMG_CREATE_CREATE_ASYNC_WORK(env, status, "CreateSendablePixelMapFromSurface",
         CreateSendablePixelMapFromSurfaceExec, CreateSendablePixelMapFromSurfaceComplete,
         asyncContext, asyncContext->work);
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 #endif
@@ -1340,11 +1336,10 @@ napi_value SendablePixelMapNapi::ReadPixelsToBuffer(napi_env env, napi_callback_
                 context->colorsBufferSize, static_cast<uint8_t*>(context->colorsBuffer));
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1448,11 +1443,10 @@ napi_value SendablePixelMapNapi::ReadPixels(napi_env env, napi_callback_info inf
                 area.size, area.offset, area.stride, area.region, static_cast<uint8_t*>(area.pixels));
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1549,11 +1543,10 @@ napi_value SendablePixelMapNapi::WritePixels(napi_env env, napi_callback_info in
                 static_cast<uint8_t*>(area.pixels), area.size, area.offset, area.stride, area.region);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1652,11 +1645,10 @@ napi_value SendablePixelMapNapi::WriteBufferToPixels(napi_env env, napi_callback
                 context->colorsBufferSize);
         }, EmptyResultComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -1805,11 +1797,10 @@ napi_value SendablePixelMapNapi::GetImageInfo(napi_env env, napi_callback_info i
             context->status = SUCCESS;
         }, GetImageInfoComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2056,11 +2047,10 @@ napi_value SendablePixelMapNapi::CreateAlphaPixelmap(napi_env env, napi_callback
             context->status = SUCCESS;
         }, CreateAlphaPixelmapComplete, asyncContext, asyncContext->work);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2223,11 +2213,10 @@ napi_value SendablePixelMapNapi::Release(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
         }, EmptyResultComplete, asyncContext, asyncContext->work, napi_qos_user_initiated);
 
-    if (!IMG_IS_OK(status)) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, asyncContext->callbackRef);
-        return nullptr;
-    }
+    });
     return result;
 }
 
@@ -2321,11 +2310,10 @@ napi_value SendablePixelMapNapi::SetAlpha(napi_env env, napi_callback_info info)
             SetAlphaExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
-
+    });
     return nVal.result;
 }
 
@@ -2404,6 +2392,7 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
         return nVal.result;
     }
     nVal.context->rPixelMap = nVal.context->nConstructor->nativePixelMap_;
+
     if (nVal.argc != NUM_2 && nVal.argc != NUM_3) {
         IMAGE_LOGE("Invalid args count %{public}zu", nVal.argc);
         nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
@@ -2412,16 +2401,15 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
             IMAGE_LOGE("Arg 0 type mismatch");
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
-
         if (napi_ok != napi_get_value_double(env, nVal.argv[NUM_1], &(nVal.context->yArg))) {
             IMAGE_LOGE("Arg 1 type mismatch");
             nVal.context->status = ERR_IMAGE_INVALID_PARAMETER;
         }
     }
-
     if (nVal.argc >= 1 && ImageNapiUtils::getType(env, nVal.argv[nVal.argc - 1]) == napi_function) {
         napi_create_reference(env, nVal.argv[nVal.argc - 1], nVal.refCount, &(nVal.context->callbackRef));
     }
+
     if (nVal.context->callbackRef == nullptr) {
         napi_create_promise(env, &(nVal.context->deferred), &(nVal.result));
     }
@@ -2437,10 +2425,10 @@ napi_value SendablePixelMapNapi::Scale(napi_env env, napi_callback_info info)
             ScaleExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work, napi_qos_user_initiated);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -2659,10 +2647,10 @@ napi_value SendablePixelMapNapi::Rotate(napi_env env, napi_callback_info info)
             RotateExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -2768,10 +2756,10 @@ napi_value SendablePixelMapNapi::Flip(napi_env env, napi_callback_info info)
             FlipExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -2884,10 +2872,10 @@ napi_value SendablePixelMapNapi::Crop(napi_env env, napi_callback_info info)
             CropExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
+    });
 
     return nVal.result;
 }
@@ -3114,11 +3102,10 @@ napi_value SendablePixelMapNapi::ApplyColorSpace(napi_env env, napi_callback_inf
             ApplyColorSpaceExec(env, context);
         }, EmptyResultComplete, nVal.context, nVal.context->work);
 
-    if (nVal.status != napi_ok) {
+    IMG_NAPI_CHECK_RET_D(IMG_IS_OK(nVal.status), nullptr, {
         IMAGE_LOGE("fail to create async work");
         napi_delete_reference(env, nVal.context->callbackRef);
-    }
-
+    });
     return nVal.result;
 }
 
-- 
Gitee


From 2dab8faf9c7042f8db1ccb2528adde387d43fece Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B1=91=E5=B1=91=E5=B1=91?= <jiangwenda5@h-partners.com>
Date: Wed, 18 Sep 2024 21:13:49 +0800
Subject: [PATCH 5/5] =?UTF-8?q?PixelMap=20ICSL=20=E5=AE=89=E5=85=A8?=
 =?UTF-8?q?=E6=95=B4=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: 屑屑屑 <jiangwenda5@h-partners.com>
---
 frameworks/kits/js/common/image_pixel_map_napi_kits.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/frameworks/kits/js/common/image_pixel_map_napi_kits.cpp b/frameworks/kits/js/common/image_pixel_map_napi_kits.cpp
index 94a661efa..1f876ed86 100644
--- a/frameworks/kits/js/common/image_pixel_map_napi_kits.cpp
+++ b/frameworks/kits/js/common/image_pixel_map_napi_kits.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "image_log.h"
 #include "image_pixel_map_napi_kits.h"
 
 #include <map>
@@ -96,11 +97,13 @@ static AntiAliasingOption ParseAntiAliasingOption(int32_t val)
 static int32_t PixelMapNapiCreate(napi_env env, PixelMapNapiArgs* args)
 {
     if (args == nullptr || args->outValue == nullptr) {
+        IMAGE_LOGE("Null Parameter for PixelMapNapiCreate");
         return IMAGE_RESULT_INVALID_PARAMETER;
     }
     napi_value undefinedValue = nullptr;
     if ((!makeUndefined(env, &undefinedValue)) || args->inBuffer == nullptr || args->bufferLen <= NUM_0) {
         *(args->outValue) = undefinedValue;
+        IMAGE_LOGE("PixelMapNapiCreate undefine value");
         return IMAGE_RESULT_GET_DATA_ABNORMAL;
     }
 
@@ -124,10 +127,12 @@ static int32_t PixelMapNapiCreate(napi_env env, PixelMapNapiArgs* args)
         info.pixelFormat == PixelFormat::YCBCR_P010 ||
         info.pixelFormat == PixelFormat::YCRCB_P010) {
         error = IMAGE_RESULT_BAD_PARAMETER;
+        IMAGE_LOGE("Invalid Parameter for PixelMapNapiCreate");
         return error;
     }
     auto pixelmap = PixelMap::Create(static_cast<uint32_t*>(args->inBuffer), args->bufferLen, pam, info, error);
     if (pixelmap == nullptr) {
+        IMAGE_LOGE("PixelMap Create failed");
         return error;
     }
 
@@ -405,6 +410,7 @@ int32_t PixelMapNapiNativeEnvCall(int32_t mode, napi_env env, PixelMapNapiArgs*
 {
     auto funcSearch = g_EnvFunctions.find(mode);
     if (funcSearch == g_EnvFunctions.end()) {
+        IMAGE_LOGE("Abnormal JNI enviroment");
         return IMAGE_RESULT_JNI_ENV_ABNORMAL;
     }
     return funcSearch->second(env, args);
-- 
Gitee