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