1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "napi_web_storage.h"
17 
18 #include <cstddef>
19 #include <new>
20 
21 #include "business_error.h"
22 #include "napi/native_common.h"
23 #include "nweb_helper.h"
24 #include "nweb_web_storage.h"
25 #include "web_errors.h"
26 
27 namespace {
28 constexpr int32_t MAX_WEB_STRING_LENGTH = 40960;
29 constexpr int32_t INTERFACE_OK = 0;
30 constexpr int32_t INTERFACE_ERROR = -1;
31 constexpr int32_t RESULT_COUNT = 2;
32 constexpr int32_t PARAMZERO = 0;
33 constexpr int32_t PARAMONE = 1;
34 }
35 
36 namespace OHOS {
37 namespace NWeb {
Init(napi_env env,napi_value exports)38 napi_value NapiWebStorage::Init(napi_env env, napi_value exports)
39 {
40     const std::string WEB_STORAGE_CLASS_NAME = "WebStorage";
41     napi_property_descriptor properties[] = {
42         DECLARE_NAPI_STATIC_FUNCTION("deleteAllData", NapiWebStorage::JsDeleteAllData),
43         DECLARE_NAPI_STATIC_FUNCTION("deleteOrigin", NapiWebStorage::JsDeleteOrigin),
44         DECLARE_NAPI_STATIC_FUNCTION("getOrigins", NapiWebStorage::JsGetOrigins),
45         DECLARE_NAPI_STATIC_FUNCTION("getOriginQuota", NapiWebStorage::JsGetOriginQuota),
46         DECLARE_NAPI_STATIC_FUNCTION("getOriginUsage", NapiWebStorage::JsGetOriginUsage),
47     };
48     napi_value constructor = nullptr;
49     napi_define_class(env, WEB_STORAGE_CLASS_NAME.c_str(), WEB_STORAGE_CLASS_NAME.length(), JsConstructor, nullptr,
50         sizeof(properties) / sizeof(properties[0]), properties, &constructor);
51     NAPI_ASSERT(env, constructor != nullptr, "define js class TestAsync failed");
52     napi_status status = napi_set_named_property(env, exports, "WebStorage", constructor);
53     NAPI_ASSERT(env, status == napi_ok, "set property WebStorage failed");
54     return exports;
55 }
JsDeleteAllData(napi_env env,napi_callback_info info)56 napi_value NapiWebStorage::JsDeleteAllData(napi_env env, napi_callback_info info)
57 {
58     napi_value result = nullptr;
59     napi_value retValue = nullptr;
60     size_t argc = 1;
61     size_t argcForOld = 0;
62     napi_value argv[1] = { 0 };
63     napi_get_cb_info(env, info, &argc, argv, &retValue, nullptr);
64     if (argc != 1 && argc != argcForOld) {
65         return nullptr;
66     }
67 
68     bool incognitoMode = false;
69     if (argc == 1) {
70         napi_get_value_bool(env, argv[0], &incognitoMode);
71     }
72 
73     std::shared_ptr<OHOS::NWeb::NWebWebStorage> web_storage = OHOS::NWeb::NWebHelper::Instance().GetWebStorage();
74     if (web_storage) {
75         web_storage->DeleteAllData(incognitoMode);
76     }
77     napi_get_undefined(env, &result);
78     return result;
79 }
80 
JsDeleteOrigin(napi_env env,napi_callback_info info)81 napi_value NapiWebStorage::JsDeleteOrigin(napi_env env, napi_callback_info info)
82 {
83     napi_value retValue = nullptr;
84     size_t argc = 1;
85     napi_value argv = nullptr;
86     napi_value result = nullptr;
87     napi_get_cb_info(env, info, &argc, &argv, &retValue, nullptr);
88     if (argc != 1) {
89         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
90             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_ONE, "one"));
91         return nullptr;
92     }
93     size_t bufferSize = 0;
94     napi_valuetype valueType = napi_null;
95     napi_typeof(env, argv, &valueType);
96     if (valueType != napi_string) {
97         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
98             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "origin", "string"));
99         return nullptr;
100     }
101     napi_get_value_string_utf8(env, argv, nullptr, 0, &bufferSize);
102     if (bufferSize >= MAX_WEB_STRING_LENGTH) {
103         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
104             "BusinessError 401: Parameter error. The length of 'origin' must less than 40960.");
105         return nullptr;
106     }
107     char stringValue[bufferSize + 1];
108     size_t jsStringLength = 0;
109     napi_get_value_string_utf8(env, argv, stringValue, bufferSize + 1, &jsStringLength);
110     if (jsStringLength != bufferSize) {
111         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
112             "BusinessError 401: Parameter error. The length of 'origin' obtained twice are different");
113         return nullptr;
114     }
115     std::string origin(stringValue);
116     std::shared_ptr<OHOS::NWeb::NWebWebStorage> web_storage = OHOS::NWeb::NWebHelper::Instance().GetWebStorage();
117     if (web_storage) {
118         if (web_storage->DeleteOrigin(origin) == NWebError::INVALID_ORIGIN) {
119             NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::INVALID_ORIGIN);
120             return nullptr;
121         }
122     }
123     napi_get_undefined(env, &result);
124     return result;
125 }
126 
GetErrorCodeValue(napi_env env,int errCode)127 napi_value NapiWebStorage::GetErrorCodeValue(napi_env env, int errCode)
128 {
129     napi_value jsObject = nullptr;
130     napi_value jsValue = nullptr;
131     NAPI_CALL(env, napi_create_int32(env, errCode, &jsValue));
132     NAPI_CALL(env, napi_create_object(env, &jsObject));
133     NAPI_CALL(env, napi_set_named_property(env, jsObject, "code", jsValue));
134     return jsObject;
135 }
136 
ExecuteGetOrigins(napi_env env,void * data)137 void NapiWebStorage::ExecuteGetOrigins(napi_env env, void *data)
138 {
139     GetOriginsParam *param = reinterpret_cast<GetOriginsParam *>(data);
140     std::shared_ptr<OHOS::NWeb::NWebWebStorage> web_storage = OHOS::NWeb::NWebHelper::Instance().GetWebStorage();
141     if (!web_storage) {
142         param->errCode = INTERFACE_ERROR;
143         param->status = napi_generic_failure;
144         return;
145     }
146     std::vector<std::shared_ptr<NWebWebStorageOrigin>> origins = web_storage->GetOrigins();
147     for (auto origin : origins) {
148         NapiWebStorageOrigin napiOrigin;
149         napiOrigin.origin = origin->GetOrigin();
150         napiOrigin.quota = origin->GetQuota();
151         napiOrigin.usage = origin->GetUsage();
152         param->origins.push_back(napiOrigin);
153     }
154     param->errCode = param->origins.empty() ? NWebError::NO_WEBSTORAGE_ORIGIN : INTERFACE_OK;
155     param->status = param->errCode == INTERFACE_OK ? napi_ok : napi_generic_failure;
156 }
157 
GetNapiWebStorageOriginForResult(napi_env env,const std::vector<NapiWebStorageOrigin> & info,napi_value result)158 void NapiWebStorage::GetNapiWebStorageOriginForResult(napi_env env,
159     const std::vector<NapiWebStorageOrigin> &info, napi_value result)
160 {
161     int32_t index = 0;
162     for (auto item : info) {
163         napi_value napiWebStorageOrigin = nullptr;
164         napi_create_object(env, &napiWebStorageOrigin);
165 
166         napi_value origin = nullptr;
167         napi_create_string_utf8(env, item.origin.c_str(), NAPI_AUTO_LENGTH, &origin);
168         napi_set_named_property(env, napiWebStorageOrigin, "origin", origin);
169 
170         napi_value quota = nullptr;
171         napi_create_uint32(env, static_cast<uint32_t>(item.quota), &quota);
172         napi_set_named_property(env, napiWebStorageOrigin, "quota", quota);
173 
174         napi_value usage = nullptr;
175         napi_create_uint32(env, static_cast<uint32_t>(item.usage), &usage);
176         napi_set_named_property(env, napiWebStorageOrigin, "usage", usage);
177 
178         napi_set_element(env, result, index, napiWebStorageOrigin);
179         index++;
180     }
181 }
182 
GetOriginComplete(napi_env env,napi_status status,void * data)183 void NapiWebStorage::GetOriginComplete(napi_env env, napi_status status, void *data)
184 {
185     GetOriginsParam* param = static_cast<GetOriginsParam*>(data);
186     napi_handle_scope scope = nullptr;
187     napi_open_handle_scope(env, &scope);
188     if (scope == nullptr) {
189         return;
190     }
191     napi_value setResult[RESULT_COUNT] = {0};
192     if (param->status) {
193         setResult[PARAMZERO] = NWebError::BusinessError::CreateError(env, NWebError::NO_WEBSTORAGE_ORIGIN);
194         napi_get_undefined(env, &setResult[PARAMONE]);
195     } else {
196         napi_get_undefined(env, &setResult[PARAMZERO]);
197         napi_create_array(env, &setResult[PARAMONE]);
198         GetNapiWebStorageOriginForResult(env, param->origins, setResult[PARAMONE]);
199     }
200     napi_value args[RESULT_COUNT] = {setResult[PARAMZERO], setResult[PARAMONE]};
201     napi_value callback = nullptr;
202     napi_get_reference_value(env, param->callbackRef, &callback);
203     napi_value returnVal = nullptr;
204     napi_call_function(env, nullptr, callback, RESULT_COUNT, args, &returnVal);
205     napi_delete_reference(env, param->callbackRef);
206     napi_delete_async_work(env, param->asyncWork);
207     napi_close_handle_scope(env, scope);
208     delete param;
209 }
210 
GetOriginsPromiseComplete(napi_env env,napi_status status,void * data)211 void NapiWebStorage::GetOriginsPromiseComplete(napi_env env, napi_status status, void *data)
212 {
213     GetOriginsParam* param = static_cast<GetOriginsParam*>(data);
214     napi_handle_scope scope = nullptr;
215     napi_open_handle_scope(env, &scope);
216     if (scope == nullptr) {
217         delete param;
218         return;
219     }
220     napi_value setResult[RESULT_COUNT] = {0};
221     setResult[PARAMZERO] = NWebError::BusinessError::CreateError(env, NWebError::NO_WEBSTORAGE_ORIGIN);
222     napi_create_array(env, &setResult[PARAMONE]);
223     GetNapiWebStorageOriginForResult(env, param->origins, setResult[PARAMONE]);
224     napi_value args[RESULT_COUNT] = {setResult[PARAMZERO], setResult[PARAMONE]};
225     if (param->status == napi_ok) {
226         napi_resolve_deferred(env, param->deferred, args[1]);
227     } else {
228         napi_reject_deferred(env, param->deferred, args[0]);
229     }
230     napi_delete_async_work(env, param->asyncWork);
231     napi_close_handle_scope(env, scope);
232     delete param;
233 }
234 
GetOriginsAsync(napi_env env,napi_value * argv)235 napi_value NapiWebStorage::GetOriginsAsync(napi_env env, napi_value *argv)
236 {
237     napi_value result = nullptr;
238     napi_value resourceName = nullptr;
239 
240     GetOriginsParam *param = new (std::nothrow) GetOriginsParam {
241         .env = env,
242         .asyncWork = nullptr,
243         .deferred = nullptr,
244         .callbackRef = nullptr,
245     };
246     if (param == nullptr) {
247         return nullptr;
248     }
249     napi_create_reference(env, *argv, 1, &param->callbackRef);
250     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
251     NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, ExecuteGetOrigins,
252         GetOriginComplete, static_cast<void *>(param), &param->asyncWork));
253     NAPI_CALL(env, napi_queue_async_work_with_qos(env, param->asyncWork, napi_qos_user_initiated));
254     napi_get_undefined(env, &result);
255     return result;
256 }
257 
GetOriginsPromise(napi_env env)258 napi_value NapiWebStorage::GetOriginsPromise(napi_env env)
259 {
260     napi_deferred deferred = nullptr;
261     napi_value promise = nullptr;
262     napi_create_promise(env, &deferred, &promise);
263 
264     GetOriginsParam *param = new (std::nothrow) GetOriginsParam {
265         .env = env,
266         .asyncWork = nullptr,
267         .deferred = deferred,
268         .callbackRef = nullptr,
269     };
270     if (param == nullptr) {
271         return nullptr;
272     }
273     napi_value resourceName = nullptr;
274     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
275     NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, ExecuteGetOrigins,
276         GetOriginsPromiseComplete, static_cast<void *>(param), &param->asyncWork));
277     NAPI_CALL(env, napi_queue_async_work_with_qos(env, param->asyncWork, napi_qos_user_initiated));
278     return promise;
279 }
280 
JsGetOrigins(napi_env env,napi_callback_info info)281 napi_value NapiWebStorage::JsGetOrigins(napi_env env, napi_callback_info info)
282 {
283     napi_value retValue = nullptr;
284     size_t argc = 0;
285     size_t argcPromise = 0;
286     size_t argcCallback = 1;
287     napi_value argv = nullptr;
288     napi_value result = nullptr;
289     napi_get_undefined(env, &result);
290     napi_get_cb_info(env, info, &argc, &argv, &retValue, nullptr);
291     if (argc != argcPromise && argc != argcCallback) {
292         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
293             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "zero", "one"));
294         return nullptr;
295     }
296     if (argc == argcCallback) {
297         napi_valuetype valueType = napi_undefined;
298         napi_get_cb_info(env, info, &argc, &argv, &retValue, nullptr);
299         napi_typeof(env, argv, &valueType);
300         if (valueType != napi_function) {
301             NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
302                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
303             return nullptr;
304         }
305         return GetOriginsAsync(env, &argv);
306     }
307     return GetOriginsPromise(env);
308 }
309 
ExecuteGetOriginUsageOrQuota(napi_env env,void * data)310 void NapiWebStorage::ExecuteGetOriginUsageOrQuota(napi_env env, void *data)
311 {
312     GetOriginUsageOrQuotaParam *param = reinterpret_cast<GetOriginUsageOrQuotaParam *>(data);
313     std::shared_ptr<OHOS::NWeb::NWebWebStorage> web_storage = OHOS::NWeb::NWebHelper::Instance().GetWebStorage();
314     if (!web_storage) {
315         param->errCode = INTERFACE_ERROR;
316         param->status = napi_generic_failure;
317         return;
318     }
319     if (param->isQuato) {
320         param->retValue = web_storage->GetOriginQuota(param->origin);
321         if (param->retValue != INTERFACE_ERROR && param->retValue != NWebError::INVALID_ORIGIN) {
322             param->errCode = INTERFACE_OK;
323         } else {
324             param->errCode = param->retValue;
325         }
326         param->status = param->errCode == INTERFACE_OK ? napi_ok : napi_generic_failure;
327         return;
328     }
329     param->retValue = web_storage->GetOriginUsage(param->origin);
330     if (param->retValue != INTERFACE_ERROR && param->retValue != NWebError::INVALID_ORIGIN) {
331         param->errCode = INTERFACE_OK;
332     } else {
333         param->errCode = param->retValue;
334     }
335     param->status = param->errCode == INTERFACE_OK ? napi_ok : napi_generic_failure;
336 }
337 
GetOriginUsageOrQuotaComplete(napi_env env,napi_status status,void * data)338 void NapiWebStorage::GetOriginUsageOrQuotaComplete(napi_env env, napi_status status, void *data)
339 {
340     GetOriginUsageOrQuotaParam* param = static_cast<GetOriginUsageOrQuotaParam*>(data);
341     napi_handle_scope scope = nullptr;
342     napi_open_handle_scope(env, &scope);
343     if (scope == nullptr) {
344         return;
345     }
346     napi_value setResult[RESULT_COUNT] = {0};
347     if (param->status) {
348         if (param->errCode == NWebError::INVALID_ORIGIN) {
349             setResult[PARAMZERO] = NWebError::BusinessError::CreateError(env, NWebError::INVALID_ORIGIN);
350         } else {
351             napi_get_undefined(env, &setResult[PARAMZERO]);
352         }
353         napi_get_undefined(env, &setResult[PARAMONE]);
354     } else {
355         napi_get_undefined(env, &setResult[PARAMZERO]);
356         napi_create_array(env, &setResult[PARAMONE]);
357         napi_create_uint32(env, static_cast<uint32_t>(param->retValue), &setResult[PARAMONE]);
358     }
359     napi_value args[RESULT_COUNT] = {setResult[PARAMZERO], setResult[PARAMONE]};
360     napi_value callback = nullptr;
361     napi_get_reference_value(env, param->callbackRef, &callback);
362     napi_value returnVal = nullptr;
363     napi_call_function(env, nullptr, callback, RESULT_COUNT, &args[PARAMZERO], &returnVal);
364     napi_delete_reference(env, param->jsStringRef);
365     napi_delete_reference(env, param->callbackRef);
366     napi_delete_async_work(env, param->asyncWork);
367     napi_close_handle_scope(env, scope);
368     delete param;
369 }
370 
GetOriginUsageOrQuotaPromiseComplete(napi_env env,napi_status status,void * data)371 void NapiWebStorage::GetOriginUsageOrQuotaPromiseComplete(napi_env env, napi_status status, void *data)
372 {
373     GetOriginUsageOrQuotaParam* param = static_cast<GetOriginUsageOrQuotaParam*>(data);
374     napi_handle_scope scope = nullptr;
375     napi_open_handle_scope(env, &scope);
376     if (scope == nullptr) {
377         return;
378     }
379     napi_value setResult[RESULT_COUNT] = {0};
380     setResult[PARAMZERO] = NWebError::BusinessError::CreateError(env, NWebError::INVALID_ORIGIN);
381     napi_create_uint32(env, static_cast<uint32_t>(param->retValue), &setResult[PARAMONE]);
382     napi_value args[RESULT_COUNT] = {setResult[PARAMZERO], setResult[PARAMONE]};
383     if (param->status != napi_ok && param->errCode == NWebError::INVALID_ORIGIN) {
384         napi_reject_deferred(env, param->deferred, args[PARAMZERO]);
385     } else {
386         napi_resolve_deferred(env, param->deferred, args[PARAMONE]);
387     }
388     napi_delete_reference(env, param->jsStringRef);
389     napi_delete_async_work(env, param->asyncWork);
390     napi_close_handle_scope(env, scope);
391     delete param;
392 }
393 
GetOriginUsageOrQuotaAsync(napi_env env,napi_value * argv,const std::string & origin,bool isQuato)394 napi_value NapiWebStorage::GetOriginUsageOrQuotaAsync(napi_env env,
395     napi_value *argv, const std::string& origin, bool isQuato)
396 {
397     napi_value result = nullptr;
398     napi_value resourceName = nullptr;
399 
400     GetOriginUsageOrQuotaParam *param = new (std::nothrow) GetOriginUsageOrQuotaParam {
401         .retValue = -1,
402         .isQuato = isQuato,
403         .origin = origin,
404         .jsStringRef = nullptr,
405         .env = env,
406         .asyncWork = nullptr,
407         .deferred = nullptr,
408         .callbackRef = nullptr,
409     };
410     if (param == nullptr) {
411         return nullptr;
412     }
413     napi_create_reference(env, argv[PARAMZERO], 1, &param->jsStringRef);
414     napi_create_reference(env, argv[PARAMONE], 1, &param->callbackRef);
415     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
416     NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, ExecuteGetOriginUsageOrQuota,
417         GetOriginUsageOrQuotaComplete, static_cast<void *>(param), &param->asyncWork));
418     NAPI_CALL(env, napi_queue_async_work_with_qos(env, param->asyncWork, napi_qos_user_initiated));
419     napi_get_undefined(env, &result);
420     return result;
421 }
422 
GetOriginUsageOrQuotaPromise(napi_env env,napi_value * argv,const std::string & origin,bool isQuato)423 napi_value NapiWebStorage::GetOriginUsageOrQuotaPromise(napi_env env,
424     napi_value *argv, const std::string& origin, bool isQuato)
425 {
426     napi_deferred deferred = nullptr;
427     napi_value promise = nullptr;
428     napi_create_promise(env, &deferred, &promise);
429 
430     GetOriginUsageOrQuotaParam *param = new (std::nothrow) GetOriginUsageOrQuotaParam {
431         .retValue = -1,
432         .isQuato = isQuato,
433         .origin = origin,
434         .jsStringRef = nullptr,
435         .env = env,
436         .asyncWork = nullptr,
437         .deferred = deferred,
438         .callbackRef = nullptr,
439     };
440     if (param == nullptr) {
441         return nullptr;
442     }
443     napi_create_reference(env, argv[PARAMZERO], 1, &param->jsStringRef);
444     napi_value resourceName = nullptr;
445     NAPI_CALL(env, napi_create_string_utf8(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
446     NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, ExecuteGetOriginUsageOrQuota,
447         GetOriginUsageOrQuotaPromiseComplete, static_cast<void *>(param), &param->asyncWork));
448     NAPI_CALL(env, napi_queue_async_work_with_qos(env, param->asyncWork, napi_qos_user_initiated));
449     return promise;
450 }
451 
JsGetOriginUsageOrQuota(napi_env env,napi_callback_info info,bool isQuato)452 napi_value NapiWebStorage::JsGetOriginUsageOrQuota(napi_env env, napi_callback_info info, bool isQuato)
453 {
454     napi_value retValue = nullptr;
455     size_t argc = 1;
456     size_t argcPromise = 1;
457     size_t argcCallback = 2;
458     napi_value argv[RESULT_COUNT] = {0};
459     napi_get_cb_info(env, info, &argc, argv, &retValue, nullptr);
460     if (argc != argcPromise && argc != argcCallback) {
461         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
462             NWebError::FormatString(ParamCheckErrorMsgTemplate::PARAM_NUMBERS_ERROR_TWO, "one", "two"));
463         return nullptr;
464     }
465     napi_valuetype valueType = napi_null;
466     napi_typeof(env, argv[PARAMZERO], &valueType);
467     if (valueType != napi_string) {
468         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
469             NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "origin", "string"));
470         return nullptr;
471     }
472     size_t bufferSize = 0;
473     napi_get_value_string_utf8(env, argv[PARAMZERO], nullptr, 0, &bufferSize);
474     if (bufferSize >= MAX_WEB_STRING_LENGTH) {
475         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
476             "BusinessError 401: Parameter error. The length of 'origin' must less than 40960.");
477         return nullptr;
478     }
479     char stringValue[bufferSize + 1];
480     size_t jsStringLength = 0;
481     napi_get_value_string_utf8(env, argv[PARAMZERO], stringValue, bufferSize + 1, &jsStringLength);
482     if (jsStringLength != bufferSize) {
483         NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
484             "BusinessError 401: Parameter error. The length of 'origin' obtained twice are different");
485         return nullptr;
486     }
487     std::string origin(stringValue);
488     if (argc == argcCallback) {
489         valueType = napi_undefined;
490         napi_get_cb_info(env, info, &argc, argv, &retValue, nullptr);
491         napi_typeof(env, argv[argcCallback - 1], &valueType);
492         if (valueType != napi_function) {
493             NWebError::BusinessError::ThrowErrorByErrcode(env, NWebError::PARAM_CHECK_ERROR,
494                 NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "callback", "function"));
495             return nullptr;
496         }
497         return GetOriginUsageOrQuotaAsync(env, argv, origin, isQuato);
498     }
499     return GetOriginUsageOrQuotaPromise(env, argv, origin, isQuato);
500 }
501 
JsGetOriginQuota(napi_env env,napi_callback_info info)502 napi_value NapiWebStorage::JsGetOriginQuota(napi_env env, napi_callback_info info)
503 {
504     return JsGetOriginUsageOrQuota(env, info, true);
505 }
506 
JsGetOriginUsage(napi_env env,napi_callback_info info)507 napi_value NapiWebStorage::JsGetOriginUsage(napi_env env, napi_callback_info info)
508 {
509     return JsGetOriginUsageOrQuota(env, info, false);
510 }
511 
JsConstructor(napi_env env,napi_callback_info info)512 napi_value NapiWebStorage::JsConstructor(napi_env env, napi_callback_info info)
513 {
514     napi_value thisVar = nullptr;
515     size_t argc = 2;
516     napi_value argv[RESULT_COUNT] = {0};
517     napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
518     return thisVar;
519 }
520 } // namespace NWeb
521 } // namespace OHOS
522