1 // Copyright (c) 2022 The Chromium Embedded Framework Authors. All rights
2 // reserved. Use of this source code is governed by a BSD-style license that
3 // can be found in the LICENSE file.
4 //
5 // ---------------------------------------------------------------------------
6 //
7 // This file was generated by the CEF translator tool. If making changes by
8 // hand only do so within the body of existing method and function
9 // implementations. See the translator.README.txt file in the tools directory
10 // for more information.
11 //
12 // $hash=a28e85dbec92b031978a0d4c998c9cb1a853c9f8$
13 //
14
15 #include "libcef_dll/ctocpp/test/translator_test_ctocpp.h"
16 #include <algorithm>
17 #include "libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.h"
18 #include "libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.h"
19 #include "libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.h"
20 #include "libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.h"
21 #include "libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.h"
22 #include "libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.h"
23 #include "libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.h"
24 #include "libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.h"
25 #include "libcef_dll/shutdown_checker.h"
26 #include "libcef_dll/transfer_util.h"
27
28 // STATIC METHODS - Body may be edited by hand.
29
30 NO_SANITIZE("cfi-icall")
Create()31 CefRefPtr<CefTranslatorTest> CefTranslatorTest::Create() {
32 shutdown_checker::AssertNotShutdown();
33
34 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
35
36 // Execute
37 cef_translator_test_t* _retval = cef_translator_test_create();
38
39 // Return type: refptr_same
40 return CefTranslatorTestCToCpp::Wrap(_retval);
41 }
42
43 // VIRTUAL METHODS - Body may be edited by hand.
44
GetVoid()45 NO_SANITIZE("cfi-icall") void CefTranslatorTestCToCpp::GetVoid() {
46 shutdown_checker::AssertNotShutdown();
47
48 cef_translator_test_t* _struct = GetStruct();
49 if (CEF_MEMBER_MISSING(_struct, get_void))
50 return;
51
52 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
53
54 // Execute
55 _struct->get_void(_struct);
56 }
57
GetBool()58 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::GetBool() {
59 shutdown_checker::AssertNotShutdown();
60
61 cef_translator_test_t* _struct = GetStruct();
62 if (CEF_MEMBER_MISSING(_struct, get_bool))
63 return false;
64
65 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
66
67 // Execute
68 int _retval = _struct->get_bool(_struct);
69
70 // Return type: bool
71 return _retval ? true : false;
72 }
73
GetInt()74 NO_SANITIZE("cfi-icall") int CefTranslatorTestCToCpp::GetInt() {
75 shutdown_checker::AssertNotShutdown();
76
77 cef_translator_test_t* _struct = GetStruct();
78 if (CEF_MEMBER_MISSING(_struct, get_int))
79 return 0;
80
81 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
82
83 // Execute
84 int _retval = _struct->get_int(_struct);
85
86 // Return type: simple
87 return _retval;
88 }
89
GetDouble()90 NO_SANITIZE("cfi-icall") double CefTranslatorTestCToCpp::GetDouble() {
91 shutdown_checker::AssertNotShutdown();
92
93 cef_translator_test_t* _struct = GetStruct();
94 if (CEF_MEMBER_MISSING(_struct, get_double))
95 return 0;
96
97 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
98
99 // Execute
100 double _retval = _struct->get_double(_struct);
101
102 // Return type: simple
103 return _retval;
104 }
105
GetLong()106 NO_SANITIZE("cfi-icall") long CefTranslatorTestCToCpp::GetLong() {
107 shutdown_checker::AssertNotShutdown();
108
109 cef_translator_test_t* _struct = GetStruct();
110 if (CEF_MEMBER_MISSING(_struct, get_long))
111 return 0;
112
113 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
114
115 // Execute
116 long _retval = _struct->get_long(_struct);
117
118 // Return type: simple
119 return _retval;
120 }
121
GetSizet()122 NO_SANITIZE("cfi-icall") size_t CefTranslatorTestCToCpp::GetSizet() {
123 shutdown_checker::AssertNotShutdown();
124
125 cef_translator_test_t* _struct = GetStruct();
126 if (CEF_MEMBER_MISSING(_struct, get_sizet))
127 return 0;
128
129 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
130
131 // Execute
132 size_t _retval = _struct->get_sizet(_struct);
133
134 // Return type: simple
135 return _retval;
136 }
137
SetVoid()138 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetVoid() {
139 shutdown_checker::AssertNotShutdown();
140
141 cef_translator_test_t* _struct = GetStruct();
142 if (CEF_MEMBER_MISSING(_struct, set_void))
143 return false;
144
145 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
146
147 // Execute
148 int _retval = _struct->set_void(_struct);
149
150 // Return type: bool
151 return _retval ? true : false;
152 }
153
SetBool(bool val)154 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetBool(bool val) {
155 shutdown_checker::AssertNotShutdown();
156
157 cef_translator_test_t* _struct = GetStruct();
158 if (CEF_MEMBER_MISSING(_struct, set_bool))
159 return false;
160
161 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
162
163 // Execute
164 int _retval = _struct->set_bool(_struct, val);
165
166 // Return type: bool
167 return _retval ? true : false;
168 }
169
SetInt(int val)170 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetInt(int val) {
171 shutdown_checker::AssertNotShutdown();
172
173 cef_translator_test_t* _struct = GetStruct();
174 if (CEF_MEMBER_MISSING(_struct, set_int))
175 return false;
176
177 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
178
179 // Execute
180 int _retval = _struct->set_int(_struct, val);
181
182 // Return type: bool
183 return _retval ? true : false;
184 }
185
SetDouble(double val)186 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetDouble(double val) {
187 shutdown_checker::AssertNotShutdown();
188
189 cef_translator_test_t* _struct = GetStruct();
190 if (CEF_MEMBER_MISSING(_struct, set_double))
191 return false;
192
193 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
194
195 // Execute
196 int _retval = _struct->set_double(_struct, val);
197
198 // Return type: bool
199 return _retval ? true : false;
200 }
201
SetLong(long val)202 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetLong(long val) {
203 shutdown_checker::AssertNotShutdown();
204
205 cef_translator_test_t* _struct = GetStruct();
206 if (CEF_MEMBER_MISSING(_struct, set_long))
207 return false;
208
209 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
210
211 // Execute
212 int _retval = _struct->set_long(_struct, val);
213
214 // Return type: bool
215 return _retval ? true : false;
216 }
217
SetSizet(size_t val)218 NO_SANITIZE("cfi-icall") bool CefTranslatorTestCToCpp::SetSizet(size_t val) {
219 shutdown_checker::AssertNotShutdown();
220
221 cef_translator_test_t* _struct = GetStruct();
222 if (CEF_MEMBER_MISSING(_struct, set_sizet))
223 return false;
224
225 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
226
227 // Execute
228 int _retval = _struct->set_sizet(_struct, val);
229
230 // Return type: bool
231 return _retval ? true : false;
232 }
233
234 NO_SANITIZE("cfi-icall")
SetIntList(const std::vector<int> & val)235 bool CefTranslatorTestCToCpp::SetIntList(const std::vector<int>& val) {
236 shutdown_checker::AssertNotShutdown();
237
238 cef_translator_test_t* _struct = GetStruct();
239 if (CEF_MEMBER_MISSING(_struct, set_int_list))
240 return false;
241
242 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
243
244 // Translate param: val; type: simple_vec_byref_const
245 const size_t valCount = val.size();
246 int* valList = NULL;
247 if (valCount > 0) {
248 valList = new int[valCount];
249 DCHECK(valList);
250 if (valList) {
251 for (size_t i = 0; i < valCount; ++i) {
252 valList[i] = val[i];
253 }
254 }
255 }
256
257 // Execute
258 int _retval = _struct->set_int_list(_struct, valCount, valList);
259
260 // Restore param:val; type: simple_vec_byref_const
261 if (valList)
262 delete[] valList;
263
264 // Return type: bool
265 return _retval ? true : false;
266 }
267
268 NO_SANITIZE("cfi-icall")
GetIntListByRef(IntList & val)269 bool CefTranslatorTestCToCpp::GetIntListByRef(IntList& val) {
270 shutdown_checker::AssertNotShutdown();
271
272 cef_translator_test_t* _struct = GetStruct();
273 if (CEF_MEMBER_MISSING(_struct, get_int_list_by_ref))
274 return false;
275
276 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
277
278 // Translate param: val; type: simple_vec_byref
279 size_t valSize = val.size();
280 size_t valCount = std::max(GetIntListSize(), valSize);
281 int* valList = NULL;
282 if (valCount > 0) {
283 valList = new int[valCount];
284 DCHECK(valList);
285 if (valList) {
286 memset(valList, 0, sizeof(int) * valCount);
287 }
288 if (valList && valSize > 0) {
289 for (size_t i = 0; i < valSize; ++i) {
290 valList[i] = val[i];
291 }
292 }
293 }
294
295 // Execute
296 int _retval = _struct->get_int_list_by_ref(_struct, &valCount, valList);
297
298 // Restore param:val; type: simple_vec_byref
299 val.clear();
300 if (valCount > 0 && valList) {
301 for (size_t i = 0; i < valCount; ++i) {
302 val.push_back(valList[i]);
303 }
304 delete[] valList;
305 }
306
307 // Return type: bool
308 return _retval ? true : false;
309 }
310
GetIntListSize()311 NO_SANITIZE("cfi-icall") size_t CefTranslatorTestCToCpp::GetIntListSize() {
312 shutdown_checker::AssertNotShutdown();
313
314 cef_translator_test_t* _struct = GetStruct();
315 if (CEF_MEMBER_MISSING(_struct, get_int_list_size))
316 return 0;
317
318 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
319
320 // Execute
321 size_t _retval = _struct->get_int_list_size(_struct);
322
323 // Return type: simple
324 return _retval;
325 }
326
GetString()327 NO_SANITIZE("cfi-icall") CefString CefTranslatorTestCToCpp::GetString() {
328 shutdown_checker::AssertNotShutdown();
329
330 cef_translator_test_t* _struct = GetStruct();
331 if (CEF_MEMBER_MISSING(_struct, get_string))
332 return CefString();
333
334 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
335
336 // Execute
337 cef_string_userfree_t _retval = _struct->get_string(_struct);
338
339 // Return type: string
340 CefString _retvalStr;
341 _retvalStr.AttachToUserFree(_retval);
342 return _retvalStr;
343 }
344
345 NO_SANITIZE("cfi-icall")
SetString(const CefString & val)346 bool CefTranslatorTestCToCpp::SetString(const CefString& val) {
347 shutdown_checker::AssertNotShutdown();
348
349 cef_translator_test_t* _struct = GetStruct();
350 if (CEF_MEMBER_MISSING(_struct, set_string))
351 return false;
352
353 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
354
355 // Verify param: val; type: string_byref_const
356 DCHECK(!val.empty());
357 if (val.empty())
358 return false;
359
360 // Execute
361 int _retval = _struct->set_string(_struct, val.GetStruct());
362
363 // Return type: bool
364 return _retval ? true : false;
365 }
366
367 NO_SANITIZE("cfi-icall")
GetStringByRef(CefString & val)368 void CefTranslatorTestCToCpp::GetStringByRef(CefString& val) {
369 shutdown_checker::AssertNotShutdown();
370
371 cef_translator_test_t* _struct = GetStruct();
372 if (CEF_MEMBER_MISSING(_struct, get_string_by_ref))
373 return;
374
375 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
376
377 // Execute
378 _struct->get_string_by_ref(_struct, val.GetWritableStruct());
379 }
380
381 NO_SANITIZE("cfi-icall")
SetStringList(const std::vector<CefString> & val)382 bool CefTranslatorTestCToCpp::SetStringList(const std::vector<CefString>& val) {
383 shutdown_checker::AssertNotShutdown();
384
385 cef_translator_test_t* _struct = GetStruct();
386 if (CEF_MEMBER_MISSING(_struct, set_string_list))
387 return false;
388
389 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
390
391 // Translate param: val; type: string_vec_byref_const
392 cef_string_list_t valList = cef_string_list_alloc();
393 DCHECK(valList);
394 if (valList)
395 transfer_string_list_contents(val, valList);
396
397 // Execute
398 int _retval = _struct->set_string_list(_struct, valList);
399
400 // Restore param:val; type: string_vec_byref_const
401 if (valList)
402 cef_string_list_free(valList);
403
404 // Return type: bool
405 return _retval ? true : false;
406 }
407
408 NO_SANITIZE("cfi-icall")
GetStringListByRef(StringList & val)409 bool CefTranslatorTestCToCpp::GetStringListByRef(StringList& val) {
410 shutdown_checker::AssertNotShutdown();
411
412 cef_translator_test_t* _struct = GetStruct();
413 if (CEF_MEMBER_MISSING(_struct, get_string_list_by_ref))
414 return false;
415
416 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
417
418 // Translate param: val; type: string_vec_byref
419 cef_string_list_t valList = cef_string_list_alloc();
420 DCHECK(valList);
421 if (valList)
422 transfer_string_list_contents(val, valList);
423
424 // Execute
425 int _retval = _struct->get_string_list_by_ref(_struct, valList);
426
427 // Restore param:val; type: string_vec_byref
428 if (valList) {
429 val.clear();
430 transfer_string_list_contents(valList, val);
431 cef_string_list_free(valList);
432 }
433
434 // Return type: bool
435 return _retval ? true : false;
436 }
437
438 NO_SANITIZE("cfi-icall")
SetStringMap(const StringMap & val)439 bool CefTranslatorTestCToCpp::SetStringMap(const StringMap& val) {
440 shutdown_checker::AssertNotShutdown();
441
442 cef_translator_test_t* _struct = GetStruct();
443 if (CEF_MEMBER_MISSING(_struct, set_string_map))
444 return false;
445
446 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
447
448 // Translate param: val; type: string_map_single_byref_const
449 cef_string_map_t valMap = cef_string_map_alloc();
450 DCHECK(valMap);
451 if (valMap)
452 transfer_string_map_contents(val, valMap);
453
454 // Execute
455 int _retval = _struct->set_string_map(_struct, valMap);
456
457 // Restore param:val; type: string_map_single_byref_const
458 if (valMap)
459 cef_string_map_free(valMap);
460
461 // Return type: bool
462 return _retval ? true : false;
463 }
464
465 NO_SANITIZE("cfi-icall")
GetStringMapByRef(std::map<CefString,CefString> & val)466 bool CefTranslatorTestCToCpp::GetStringMapByRef(
467 std::map<CefString, CefString>& val) {
468 shutdown_checker::AssertNotShutdown();
469
470 cef_translator_test_t* _struct = GetStruct();
471 if (CEF_MEMBER_MISSING(_struct, get_string_map_by_ref))
472 return false;
473
474 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
475
476 // Translate param: val; type: string_map_single_byref
477 cef_string_map_t valMap = cef_string_map_alloc();
478 DCHECK(valMap);
479 if (valMap)
480 transfer_string_map_contents(val, valMap);
481
482 // Execute
483 int _retval = _struct->get_string_map_by_ref(_struct, valMap);
484
485 // Restore param:val; type: string_map_single_byref
486 if (valMap) {
487 val.clear();
488 transfer_string_map_contents(valMap, val);
489 cef_string_map_free(valMap);
490 }
491
492 // Return type: bool
493 return _retval ? true : false;
494 }
495
496 NO_SANITIZE("cfi-icall")
SetStringMultimap(const std::multimap<CefString,CefString> & val)497 bool CefTranslatorTestCToCpp::SetStringMultimap(
498 const std::multimap<CefString, CefString>& val) {
499 shutdown_checker::AssertNotShutdown();
500
501 cef_translator_test_t* _struct = GetStruct();
502 if (CEF_MEMBER_MISSING(_struct, set_string_multimap))
503 return false;
504
505 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
506
507 // Translate param: val; type: string_map_multi_byref_const
508 cef_string_multimap_t valMultimap = cef_string_multimap_alloc();
509 DCHECK(valMultimap);
510 if (valMultimap)
511 transfer_string_multimap_contents(val, valMultimap);
512
513 // Execute
514 int _retval = _struct->set_string_multimap(_struct, valMultimap);
515
516 // Restore param:val; type: string_map_multi_byref_const
517 if (valMultimap)
518 cef_string_multimap_free(valMultimap);
519
520 // Return type: bool
521 return _retval ? true : false;
522 }
523
524 NO_SANITIZE("cfi-icall")
GetStringMultimapByRef(StringMultimap & val)525 bool CefTranslatorTestCToCpp::GetStringMultimapByRef(StringMultimap& val) {
526 shutdown_checker::AssertNotShutdown();
527
528 cef_translator_test_t* _struct = GetStruct();
529 if (CEF_MEMBER_MISSING(_struct, get_string_multimap_by_ref))
530 return false;
531
532 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
533
534 // Translate param: val; type: string_map_multi_byref
535 cef_string_multimap_t valMultimap = cef_string_multimap_alloc();
536 DCHECK(valMultimap);
537 if (valMultimap)
538 transfer_string_multimap_contents(val, valMultimap);
539
540 // Execute
541 int _retval = _struct->get_string_multimap_by_ref(_struct, valMultimap);
542
543 // Restore param:val; type: string_map_multi_byref
544 if (valMultimap) {
545 val.clear();
546 transfer_string_multimap_contents(valMultimap, val);
547 cef_string_multimap_free(valMultimap);
548 }
549
550 // Return type: bool
551 return _retval ? true : false;
552 }
553
GetPoint()554 NO_SANITIZE("cfi-icall") CefPoint CefTranslatorTestCToCpp::GetPoint() {
555 shutdown_checker::AssertNotShutdown();
556
557 cef_translator_test_t* _struct = GetStruct();
558 if (CEF_MEMBER_MISSING(_struct, get_point))
559 return CefPoint();
560
561 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
562
563 // Execute
564 cef_point_t _retval = _struct->get_point(_struct);
565
566 // Return type: simple
567 return _retval;
568 }
569
570 NO_SANITIZE("cfi-icall")
SetPoint(const CefPoint & val)571 bool CefTranslatorTestCToCpp::SetPoint(const CefPoint& val) {
572 shutdown_checker::AssertNotShutdown();
573
574 cef_translator_test_t* _struct = GetStruct();
575 if (CEF_MEMBER_MISSING(_struct, set_point))
576 return false;
577
578 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
579
580 // Execute
581 int _retval = _struct->set_point(_struct, &val);
582
583 // Return type: bool
584 return _retval ? true : false;
585 }
586
587 NO_SANITIZE("cfi-icall")
GetPointByRef(CefPoint & val)588 void CefTranslatorTestCToCpp::GetPointByRef(CefPoint& val) {
589 shutdown_checker::AssertNotShutdown();
590
591 cef_translator_test_t* _struct = GetStruct();
592 if (CEF_MEMBER_MISSING(_struct, get_point_by_ref))
593 return;
594
595 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
596
597 // Execute
598 _struct->get_point_by_ref(_struct, &val);
599 }
600
601 NO_SANITIZE("cfi-icall")
SetPointList(const std::vector<CefPoint> & val)602 bool CefTranslatorTestCToCpp::SetPointList(const std::vector<CefPoint>& val) {
603 shutdown_checker::AssertNotShutdown();
604
605 cef_translator_test_t* _struct = GetStruct();
606 if (CEF_MEMBER_MISSING(_struct, set_point_list))
607 return false;
608
609 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
610
611 // Translate param: val; type: simple_vec_byref_const
612 const size_t valCount = val.size();
613 cef_point_t* valList = NULL;
614 if (valCount > 0) {
615 valList = new cef_point_t[valCount];
616 DCHECK(valList);
617 if (valList) {
618 for (size_t i = 0; i < valCount; ++i) {
619 valList[i] = val[i];
620 }
621 }
622 }
623
624 // Execute
625 int _retval = _struct->set_point_list(_struct, valCount, valList);
626
627 // Restore param:val; type: simple_vec_byref_const
628 if (valList)
629 delete[] valList;
630
631 // Return type: bool
632 return _retval ? true : false;
633 }
634
635 NO_SANITIZE("cfi-icall")
GetPointListByRef(PointList & val)636 bool CefTranslatorTestCToCpp::GetPointListByRef(PointList& val) {
637 shutdown_checker::AssertNotShutdown();
638
639 cef_translator_test_t* _struct = GetStruct();
640 if (CEF_MEMBER_MISSING(_struct, get_point_list_by_ref))
641 return false;
642
643 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
644
645 // Translate param: val; type: simple_vec_byref
646 size_t valSize = val.size();
647 size_t valCount = std::max(GetPointListSize(), valSize);
648 cef_point_t* valList = NULL;
649 if (valCount > 0) {
650 valList = new cef_point_t[valCount];
651 DCHECK(valList);
652 if (valList) {
653 memset(valList, 0, sizeof(cef_point_t) * valCount);
654 }
655 if (valList && valSize > 0) {
656 for (size_t i = 0; i < valSize; ++i) {
657 valList[i] = val[i];
658 }
659 }
660 }
661
662 // Execute
663 int _retval = _struct->get_point_list_by_ref(_struct, &valCount, valList);
664
665 // Restore param:val; type: simple_vec_byref
666 val.clear();
667 if (valCount > 0 && valList) {
668 for (size_t i = 0; i < valCount; ++i) {
669 val.push_back(valList[i]);
670 }
671 delete[] valList;
672 }
673
674 // Return type: bool
675 return _retval ? true : false;
676 }
677
GetPointListSize()678 NO_SANITIZE("cfi-icall") size_t CefTranslatorTestCToCpp::GetPointListSize() {
679 shutdown_checker::AssertNotShutdown();
680
681 cef_translator_test_t* _struct = GetStruct();
682 if (CEF_MEMBER_MISSING(_struct, get_point_list_size))
683 return 0;
684
685 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
686
687 // Execute
688 size_t _retval = _struct->get_point_list_size(_struct);
689
690 // Return type: simple
691 return _retval;
692 }
693
694 NO_SANITIZE("cfi-icall")
695 CefRefPtr<CefTranslatorTestRefPtrLibrary>
GetRefPtrLibrary(int val)696 CefTranslatorTestCToCpp::GetRefPtrLibrary(int val) {
697 shutdown_checker::AssertNotShutdown();
698
699 cef_translator_test_t* _struct = GetStruct();
700 if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library))
701 return nullptr;
702
703 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
704
705 // Execute
706 cef_translator_test_ref_ptr_library_t* _retval =
707 _struct->get_ref_ptr_library(_struct, val);
708
709 // Return type: refptr_same
710 return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
711 }
712
713 NO_SANITIZE("cfi-icall")
SetRefPtrLibrary(CefRefPtr<CefTranslatorTestRefPtrLibrary> val)714 int CefTranslatorTestCToCpp::SetRefPtrLibrary(
715 CefRefPtr<CefTranslatorTestRefPtrLibrary> val) {
716 shutdown_checker::AssertNotShutdown();
717
718 cef_translator_test_t* _struct = GetStruct();
719 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library))
720 return 0;
721
722 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
723
724 // Verify param: val; type: refptr_same
725 DCHECK(val.get());
726 if (!val.get())
727 return 0;
728
729 // Execute
730 int _retval = _struct->set_ref_ptr_library(
731 _struct, CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val));
732
733 // Return type: simple
734 return _retval;
735 }
736
737 NO_SANITIZE("cfi-icall")
738 CefRefPtr<CefTranslatorTestRefPtrLibrary>
SetRefPtrLibraryAndReturn(CefRefPtr<CefTranslatorTestRefPtrLibrary> val)739 CefTranslatorTestCToCpp::SetRefPtrLibraryAndReturn(
740 CefRefPtr<CefTranslatorTestRefPtrLibrary> val) {
741 shutdown_checker::AssertNotShutdown();
742
743 cef_translator_test_t* _struct = GetStruct();
744 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library_and_return))
745 return nullptr;
746
747 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
748
749 // Verify param: val; type: refptr_same
750 DCHECK(val.get());
751 if (!val.get())
752 return nullptr;
753
754 // Execute
755 cef_translator_test_ref_ptr_library_t* _retval =
756 _struct->set_ref_ptr_library_and_return(
757 _struct, CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val));
758
759 // Return type: refptr_same
760 return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
761 }
762
763 NO_SANITIZE("cfi-icall")
SetChildRefPtrLibrary(CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val)764 int CefTranslatorTestCToCpp::SetChildRefPtrLibrary(
765 CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) {
766 shutdown_checker::AssertNotShutdown();
767
768 cef_translator_test_t* _struct = GetStruct();
769 if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_library))
770 return 0;
771
772 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
773
774 // Verify param: val; type: refptr_same
775 DCHECK(val.get());
776 if (!val.get())
777 return 0;
778
779 // Execute
780 int _retval = _struct->set_child_ref_ptr_library(
781 _struct, CefTranslatorTestRefPtrLibraryChildCToCpp::Unwrap(val));
782
783 // Return type: simple
784 return _retval;
785 }
786
787 NO_SANITIZE("cfi-icall")
788 CefRefPtr<CefTranslatorTestRefPtrLibrary>
SetChildRefPtrLibraryAndReturnParent(CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val)789 CefTranslatorTestCToCpp::SetChildRefPtrLibraryAndReturnParent(
790 CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) {
791 shutdown_checker::AssertNotShutdown();
792
793 cef_translator_test_t* _struct = GetStruct();
794 if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_library_and_return_parent))
795 return nullptr;
796
797 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
798
799 // Verify param: val; type: refptr_same
800 DCHECK(val.get());
801 if (!val.get())
802 return nullptr;
803
804 // Execute
805 cef_translator_test_ref_ptr_library_t* _retval =
806 _struct->set_child_ref_ptr_library_and_return_parent(
807 _struct, CefTranslatorTestRefPtrLibraryChildCToCpp::Unwrap(val));
808
809 // Return type: refptr_same
810 return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
811 }
812
813 NO_SANITIZE("cfi-icall")
SetRefPtrLibraryList(const std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>> & val,int val1,int val2)814 bool CefTranslatorTestCToCpp::SetRefPtrLibraryList(
815 const std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>>& val,
816 int val1,
817 int val2) {
818 shutdown_checker::AssertNotShutdown();
819
820 cef_translator_test_t* _struct = GetStruct();
821 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library_list))
822 return false;
823
824 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
825
826 // Translate param: val; type: refptr_vec_same_byref_const
827 const size_t valCount = val.size();
828 cef_translator_test_ref_ptr_library_t** valList = NULL;
829 if (valCount > 0) {
830 valList = new cef_translator_test_ref_ptr_library_t*[valCount];
831 DCHECK(valList);
832 if (valList) {
833 for (size_t i = 0; i < valCount; ++i) {
834 valList[i] = CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val[i]);
835 }
836 }
837 }
838
839 // Execute
840 int _retval =
841 _struct->set_ref_ptr_library_list(_struct, valCount, valList, val1, val2);
842
843 // Restore param:val; type: refptr_vec_same_byref_const
844 if (valList)
845 delete[] valList;
846
847 // Return type: bool
848 return _retval ? true : false;
849 }
850
851 NO_SANITIZE("cfi-icall")
GetRefPtrLibraryListByRef(RefPtrLibraryList & val,int val1,int val2)852 bool CefTranslatorTestCToCpp::GetRefPtrLibraryListByRef(RefPtrLibraryList& val,
853 int val1,
854 int val2) {
855 shutdown_checker::AssertNotShutdown();
856
857 cef_translator_test_t* _struct = GetStruct();
858 if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library_list_by_ref))
859 return false;
860
861 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
862
863 // Translate param: val; type: refptr_vec_same_byref
864 size_t valSize = val.size();
865 size_t valCount = std::max(GetRefPtrLibraryListSize(), valSize);
866 cef_translator_test_ref_ptr_library_t** valList = NULL;
867 if (valCount > 0) {
868 valList = new cef_translator_test_ref_ptr_library_t*[valCount];
869 DCHECK(valList);
870 if (valList) {
871 memset(valList, 0,
872 sizeof(cef_translator_test_ref_ptr_library_t*) * valCount);
873 }
874 if (valList && valSize > 0) {
875 for (size_t i = 0; i < valSize; ++i) {
876 valList[i] = CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val[i]);
877 }
878 }
879 }
880
881 // Execute
882 int _retval = _struct->get_ref_ptr_library_list_by_ref(_struct, &valCount,
883 valList, val1, val2);
884
885 // Restore param:val; type: refptr_vec_same_byref
886 val.clear();
887 if (valCount > 0 && valList) {
888 for (size_t i = 0; i < valCount; ++i) {
889 val.push_back(CefTranslatorTestRefPtrLibraryCToCpp::Wrap(valList[i]));
890 }
891 delete[] valList;
892 }
893
894 // Return type: bool
895 return _retval ? true : false;
896 }
897
898 NO_SANITIZE("cfi-icall")
GetRefPtrLibraryListSize()899 size_t CefTranslatorTestCToCpp::GetRefPtrLibraryListSize() {
900 shutdown_checker::AssertNotShutdown();
901
902 cef_translator_test_t* _struct = GetStruct();
903 if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library_list_size))
904 return 0;
905
906 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
907
908 // Execute
909 size_t _retval = _struct->get_ref_ptr_library_list_size(_struct);
910
911 // Return type: simple
912 return _retval;
913 }
914
915 NO_SANITIZE("cfi-icall")
SetRefPtrClient(CefRefPtr<CefTranslatorTestRefPtrClient> val)916 int CefTranslatorTestCToCpp::SetRefPtrClient(
917 CefRefPtr<CefTranslatorTestRefPtrClient> val) {
918 shutdown_checker::AssertNotShutdown();
919
920 cef_translator_test_t* _struct = GetStruct();
921 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client))
922 return 0;
923
924 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
925
926 // Verify param: val; type: refptr_diff
927 DCHECK(val.get());
928 if (!val.get())
929 return 0;
930
931 // Execute
932 int _retval = _struct->set_ref_ptr_client(
933 _struct, CefTranslatorTestRefPtrClientCppToC::Wrap(val));
934
935 // Return type: simple
936 return _retval;
937 }
938
939 NO_SANITIZE("cfi-icall")
940 CefRefPtr<CefTranslatorTestRefPtrClient>
SetRefPtrClientAndReturn(CefRefPtr<CefTranslatorTestRefPtrClient> val)941 CefTranslatorTestCToCpp::SetRefPtrClientAndReturn(
942 CefRefPtr<CefTranslatorTestRefPtrClient> val) {
943 shutdown_checker::AssertNotShutdown();
944
945 cef_translator_test_t* _struct = GetStruct();
946 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client_and_return))
947 return nullptr;
948
949 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
950
951 // Verify param: val; type: refptr_diff
952 DCHECK(val.get());
953 if (!val.get())
954 return nullptr;
955
956 // Execute
957 cef_translator_test_ref_ptr_client_t* _retval =
958 _struct->set_ref_ptr_client_and_return(
959 _struct, CefTranslatorTestRefPtrClientCppToC::Wrap(val));
960
961 // Return type: refptr_diff
962 return CefTranslatorTestRefPtrClientCppToC::Unwrap(_retval);
963 }
964
965 NO_SANITIZE("cfi-icall")
SetChildRefPtrClient(CefRefPtr<CefTranslatorTestRefPtrClientChild> val)966 int CefTranslatorTestCToCpp::SetChildRefPtrClient(
967 CefRefPtr<CefTranslatorTestRefPtrClientChild> val) {
968 shutdown_checker::AssertNotShutdown();
969
970 cef_translator_test_t* _struct = GetStruct();
971 if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_client))
972 return 0;
973
974 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
975
976 // Verify param: val; type: refptr_diff
977 DCHECK(val.get());
978 if (!val.get())
979 return 0;
980
981 // Execute
982 int _retval = _struct->set_child_ref_ptr_client(
983 _struct, CefTranslatorTestRefPtrClientChildCppToC::Wrap(val));
984
985 // Return type: simple
986 return _retval;
987 }
988
989 NO_SANITIZE("cfi-icall")
990 CefRefPtr<CefTranslatorTestRefPtrClient>
SetChildRefPtrClientAndReturnParent(CefRefPtr<CefTranslatorTestRefPtrClientChild> val)991 CefTranslatorTestCToCpp::SetChildRefPtrClientAndReturnParent(
992 CefRefPtr<CefTranslatorTestRefPtrClientChild> val) {
993 shutdown_checker::AssertNotShutdown();
994
995 cef_translator_test_t* _struct = GetStruct();
996 if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_client_and_return_parent))
997 return nullptr;
998
999 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1000
1001 // Verify param: val; type: refptr_diff
1002 DCHECK(val.get());
1003 if (!val.get())
1004 return nullptr;
1005
1006 // Execute
1007 cef_translator_test_ref_ptr_client_t* _retval =
1008 _struct->set_child_ref_ptr_client_and_return_parent(
1009 _struct, CefTranslatorTestRefPtrClientChildCppToC::Wrap(val));
1010
1011 // Return type: refptr_diff
1012 return CefTranslatorTestRefPtrClientCppToC::Unwrap(_retval);
1013 }
1014
1015 NO_SANITIZE("cfi-icall")
SetRefPtrClientList(const std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>> & val,int val1,int val2)1016 bool CefTranslatorTestCToCpp::SetRefPtrClientList(
1017 const std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>>& val,
1018 int val1,
1019 int val2) {
1020 shutdown_checker::AssertNotShutdown();
1021
1022 cef_translator_test_t* _struct = GetStruct();
1023 if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client_list))
1024 return false;
1025
1026 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1027
1028 // Translate param: val; type: refptr_vec_diff_byref_const
1029 const size_t valCount = val.size();
1030 cef_translator_test_ref_ptr_client_t** valList = NULL;
1031 if (valCount > 0) {
1032 valList = new cef_translator_test_ref_ptr_client_t*[valCount];
1033 DCHECK(valList);
1034 if (valList) {
1035 for (size_t i = 0; i < valCount; ++i) {
1036 valList[i] = CefTranslatorTestRefPtrClientCppToC::Wrap(val[i]);
1037 }
1038 }
1039 }
1040
1041 // Execute
1042 int _retval =
1043 _struct->set_ref_ptr_client_list(_struct, valCount, valList, val1, val2);
1044
1045 // Restore param:val; type: refptr_vec_diff_byref_const
1046 if (valList)
1047 delete[] valList;
1048
1049 // Return type: bool
1050 return _retval ? true : false;
1051 }
1052
1053 NO_SANITIZE("cfi-icall")
GetRefPtrClientListByRef(RefPtrClientList & val,CefRefPtr<CefTranslatorTestRefPtrClient> val1,CefRefPtr<CefTranslatorTestRefPtrClient> val2)1054 bool CefTranslatorTestCToCpp::GetRefPtrClientListByRef(
1055 RefPtrClientList& val,
1056 CefRefPtr<CefTranslatorTestRefPtrClient> val1,
1057 CefRefPtr<CefTranslatorTestRefPtrClient> val2) {
1058 shutdown_checker::AssertNotShutdown();
1059
1060 cef_translator_test_t* _struct = GetStruct();
1061 if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_client_list_by_ref))
1062 return false;
1063
1064 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1065
1066 // Verify param: val1; type: refptr_diff
1067 DCHECK(val1.get());
1068 if (!val1.get())
1069 return false;
1070 // Verify param: val2; type: refptr_diff
1071 DCHECK(val2.get());
1072 if (!val2.get())
1073 return false;
1074
1075 // Translate param: val; type: refptr_vec_diff_byref
1076 size_t valSize = val.size();
1077 size_t valCount = std::max(GetRefPtrLibraryListSize(), valSize);
1078 cef_translator_test_ref_ptr_client_t** valList = NULL;
1079 if (valCount > 0) {
1080 valList = new cef_translator_test_ref_ptr_client_t*[valCount];
1081 DCHECK(valList);
1082 if (valList) {
1083 memset(valList, 0,
1084 sizeof(cef_translator_test_ref_ptr_client_t*) * valCount);
1085 }
1086 if (valList && valSize > 0) {
1087 for (size_t i = 0; i < valSize; ++i) {
1088 valList[i] = CefTranslatorTestRefPtrClientCppToC::Wrap(val[i]);
1089 }
1090 }
1091 }
1092
1093 // Execute
1094 int _retval = _struct->get_ref_ptr_client_list_by_ref(
1095 _struct, &valCount, valList,
1096 CefTranslatorTestRefPtrClientCppToC::Wrap(val1),
1097 CefTranslatorTestRefPtrClientCppToC::Wrap(val2));
1098
1099 // Restore param:val; type: refptr_vec_diff_byref
1100 val.clear();
1101 if (valCount > 0 && valList) {
1102 for (size_t i = 0; i < valCount; ++i) {
1103 val.push_back(CefTranslatorTestRefPtrClientCppToC::Unwrap(valList[i]));
1104 }
1105 delete[] valList;
1106 }
1107
1108 // Return type: bool
1109 return _retval ? true : false;
1110 }
1111
1112 NO_SANITIZE("cfi-icall")
GetRefPtrClientListSize()1113 size_t CefTranslatorTestCToCpp::GetRefPtrClientListSize() {
1114 shutdown_checker::AssertNotShutdown();
1115
1116 cef_translator_test_t* _struct = GetStruct();
1117 if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_client_list_size))
1118 return 0;
1119
1120 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1121
1122 // Execute
1123 size_t _retval = _struct->get_ref_ptr_client_list_size(_struct);
1124
1125 // Return type: simple
1126 return _retval;
1127 }
1128
1129 NO_SANITIZE("cfi-icall")
1130 CefOwnPtr<CefTranslatorTestScopedLibrary>
GetOwnPtrLibrary(int val)1131 CefTranslatorTestCToCpp::GetOwnPtrLibrary(int val) {
1132 shutdown_checker::AssertNotShutdown();
1133
1134 cef_translator_test_t* _struct = GetStruct();
1135 if (CEF_MEMBER_MISSING(_struct, get_own_ptr_library))
1136 return CefOwnPtr<CefTranslatorTestScopedLibrary>();
1137
1138 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1139
1140 // Execute
1141 cef_translator_test_scoped_library_t* _retval =
1142 _struct->get_own_ptr_library(_struct, val);
1143
1144 // Return type: ownptr_same
1145 return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
1146 }
1147
1148 NO_SANITIZE("cfi-icall")
SetOwnPtrLibrary(CefOwnPtr<CefTranslatorTestScopedLibrary> val)1149 int CefTranslatorTestCToCpp::SetOwnPtrLibrary(
1150 CefOwnPtr<CefTranslatorTestScopedLibrary> val) {
1151 shutdown_checker::AssertNotShutdown();
1152
1153 cef_translator_test_t* _struct = GetStruct();
1154 if (CEF_MEMBER_MISSING(_struct, set_own_ptr_library))
1155 return 0;
1156
1157 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1158
1159 // Verify param: val; type: ownptr_same
1160 DCHECK(val.get());
1161 if (!val.get())
1162 return 0;
1163
1164 // Execute
1165 int _retval = _struct->set_own_ptr_library(
1166 _struct, CefTranslatorTestScopedLibraryCToCpp::UnwrapOwn(std::move(val)));
1167
1168 // Return type: simple
1169 return _retval;
1170 }
1171
1172 NO_SANITIZE("cfi-icall")
1173 CefOwnPtr<CefTranslatorTestScopedLibrary>
SetOwnPtrLibraryAndReturn(CefOwnPtr<CefTranslatorTestScopedLibrary> val)1174 CefTranslatorTestCToCpp::SetOwnPtrLibraryAndReturn(
1175 CefOwnPtr<CefTranslatorTestScopedLibrary> val) {
1176 shutdown_checker::AssertNotShutdown();
1177
1178 cef_translator_test_t* _struct = GetStruct();
1179 if (CEF_MEMBER_MISSING(_struct, set_own_ptr_library_and_return))
1180 return CefOwnPtr<CefTranslatorTestScopedLibrary>();
1181
1182 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1183
1184 // Verify param: val; type: ownptr_same
1185 DCHECK(val.get());
1186 if (!val.get())
1187 return CefOwnPtr<CefTranslatorTestScopedLibrary>();
1188
1189 // Execute
1190 cef_translator_test_scoped_library_t* _retval =
1191 _struct->set_own_ptr_library_and_return(
1192 _struct,
1193 CefTranslatorTestScopedLibraryCToCpp::UnwrapOwn(std::move(val)));
1194
1195 // Return type: ownptr_same
1196 return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
1197 }
1198
1199 NO_SANITIZE("cfi-icall")
SetChildOwnPtrLibrary(CefOwnPtr<CefTranslatorTestScopedLibraryChild> val)1200 int CefTranslatorTestCToCpp::SetChildOwnPtrLibrary(
1201 CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) {
1202 shutdown_checker::AssertNotShutdown();
1203
1204 cef_translator_test_t* _struct = GetStruct();
1205 if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_library))
1206 return 0;
1207
1208 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1209
1210 // Verify param: val; type: ownptr_same
1211 DCHECK(val.get());
1212 if (!val.get())
1213 return 0;
1214
1215 // Execute
1216 int _retval = _struct->set_child_own_ptr_library(
1217 _struct,
1218 CefTranslatorTestScopedLibraryChildCToCpp::UnwrapOwn(std::move(val)));
1219
1220 // Return type: simple
1221 return _retval;
1222 }
1223
1224 NO_SANITIZE("cfi-icall")
1225 CefOwnPtr<CefTranslatorTestScopedLibrary>
SetChildOwnPtrLibraryAndReturnParent(CefOwnPtr<CefTranslatorTestScopedLibraryChild> val)1226 CefTranslatorTestCToCpp::SetChildOwnPtrLibraryAndReturnParent(
1227 CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) {
1228 shutdown_checker::AssertNotShutdown();
1229
1230 cef_translator_test_t* _struct = GetStruct();
1231 if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_library_and_return_parent))
1232 return CefOwnPtr<CefTranslatorTestScopedLibrary>();
1233
1234 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1235
1236 // Verify param: val; type: ownptr_same
1237 DCHECK(val.get());
1238 if (!val.get())
1239 return CefOwnPtr<CefTranslatorTestScopedLibrary>();
1240
1241 // Execute
1242 cef_translator_test_scoped_library_t* _retval =
1243 _struct->set_child_own_ptr_library_and_return_parent(
1244 _struct,
1245 CefTranslatorTestScopedLibraryChildCToCpp::UnwrapOwn(std::move(val)));
1246
1247 // Return type: ownptr_same
1248 return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
1249 }
1250
1251 NO_SANITIZE("cfi-icall")
SetOwnPtrClient(CefOwnPtr<CefTranslatorTestScopedClient> val)1252 int CefTranslatorTestCToCpp::SetOwnPtrClient(
1253 CefOwnPtr<CefTranslatorTestScopedClient> val) {
1254 shutdown_checker::AssertNotShutdown();
1255
1256 cef_translator_test_t* _struct = GetStruct();
1257 if (CEF_MEMBER_MISSING(_struct, set_own_ptr_client))
1258 return 0;
1259
1260 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1261
1262 // Verify param: val; type: ownptr_diff
1263 DCHECK(val.get());
1264 if (!val.get())
1265 return 0;
1266
1267 // Execute
1268 int _retval = _struct->set_own_ptr_client(
1269 _struct, CefTranslatorTestScopedClientCppToC::WrapOwn(std::move(val)));
1270
1271 // Return type: simple
1272 return _retval;
1273 }
1274
1275 NO_SANITIZE("cfi-icall")
1276 CefOwnPtr<CefTranslatorTestScopedClient>
SetOwnPtrClientAndReturn(CefOwnPtr<CefTranslatorTestScopedClient> val)1277 CefTranslatorTestCToCpp::SetOwnPtrClientAndReturn(
1278 CefOwnPtr<CefTranslatorTestScopedClient> val) {
1279 shutdown_checker::AssertNotShutdown();
1280
1281 cef_translator_test_t* _struct = GetStruct();
1282 if (CEF_MEMBER_MISSING(_struct, set_own_ptr_client_and_return))
1283 return CefOwnPtr<CefTranslatorTestScopedClient>();
1284
1285 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1286
1287 // Verify param: val; type: ownptr_diff
1288 DCHECK(val.get());
1289 if (!val.get())
1290 return CefOwnPtr<CefTranslatorTestScopedClient>();
1291
1292 // Execute
1293 cef_translator_test_scoped_client_t* _retval =
1294 _struct->set_own_ptr_client_and_return(
1295 _struct,
1296 CefTranslatorTestScopedClientCppToC::WrapOwn(std::move(val)));
1297
1298 // Return type: ownptr_diff
1299 return CefTranslatorTestScopedClientCppToC::UnwrapOwn(_retval);
1300 }
1301
1302 NO_SANITIZE("cfi-icall")
SetChildOwnPtrClient(CefOwnPtr<CefTranslatorTestScopedClientChild> val)1303 int CefTranslatorTestCToCpp::SetChildOwnPtrClient(
1304 CefOwnPtr<CefTranslatorTestScopedClientChild> val) {
1305 shutdown_checker::AssertNotShutdown();
1306
1307 cef_translator_test_t* _struct = GetStruct();
1308 if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_client))
1309 return 0;
1310
1311 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1312
1313 // Verify param: val; type: ownptr_diff
1314 DCHECK(val.get());
1315 if (!val.get())
1316 return 0;
1317
1318 // Execute
1319 int _retval = _struct->set_child_own_ptr_client(
1320 _struct,
1321 CefTranslatorTestScopedClientChildCppToC::WrapOwn(std::move(val)));
1322
1323 // Return type: simple
1324 return _retval;
1325 }
1326
1327 NO_SANITIZE("cfi-icall")
1328 CefOwnPtr<CefTranslatorTestScopedClient>
SetChildOwnPtrClientAndReturnParent(CefOwnPtr<CefTranslatorTestScopedClientChild> val)1329 CefTranslatorTestCToCpp::SetChildOwnPtrClientAndReturnParent(
1330 CefOwnPtr<CefTranslatorTestScopedClientChild> val) {
1331 shutdown_checker::AssertNotShutdown();
1332
1333 cef_translator_test_t* _struct = GetStruct();
1334 if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_client_and_return_parent))
1335 return CefOwnPtr<CefTranslatorTestScopedClient>();
1336
1337 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1338
1339 // Verify param: val; type: ownptr_diff
1340 DCHECK(val.get());
1341 if (!val.get())
1342 return CefOwnPtr<CefTranslatorTestScopedClient>();
1343
1344 // Execute
1345 cef_translator_test_scoped_client_t* _retval =
1346 _struct->set_child_own_ptr_client_and_return_parent(
1347 _struct,
1348 CefTranslatorTestScopedClientChildCppToC::WrapOwn(std::move(val)));
1349
1350 // Return type: ownptr_diff
1351 return CefTranslatorTestScopedClientCppToC::UnwrapOwn(_retval);
1352 }
1353
1354 NO_SANITIZE("cfi-icall")
SetRawPtrLibrary(CefRawPtr<CefTranslatorTestScopedLibrary> val)1355 int CefTranslatorTestCToCpp::SetRawPtrLibrary(
1356 CefRawPtr<CefTranslatorTestScopedLibrary> val) {
1357 shutdown_checker::AssertNotShutdown();
1358
1359 cef_translator_test_t* _struct = GetStruct();
1360 if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_library))
1361 return 0;
1362
1363 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1364
1365 // Verify param: val; type: rawptr_same
1366 DCHECK(val);
1367 if (!val)
1368 return 0;
1369
1370 // Execute
1371 int _retval = _struct->set_raw_ptr_library(
1372 _struct, CefTranslatorTestScopedLibraryCToCpp::UnwrapRaw(val));
1373
1374 // Return type: simple
1375 return _retval;
1376 }
1377
1378 NO_SANITIZE("cfi-icall")
SetChildRawPtrLibrary(CefRawPtr<CefTranslatorTestScopedLibraryChild> val)1379 int CefTranslatorTestCToCpp::SetChildRawPtrLibrary(
1380 CefRawPtr<CefTranslatorTestScopedLibraryChild> val) {
1381 shutdown_checker::AssertNotShutdown();
1382
1383 cef_translator_test_t* _struct = GetStruct();
1384 if (CEF_MEMBER_MISSING(_struct, set_child_raw_ptr_library))
1385 return 0;
1386
1387 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1388
1389 // Verify param: val; type: rawptr_same
1390 DCHECK(val);
1391 if (!val)
1392 return 0;
1393
1394 // Execute
1395 int _retval = _struct->set_child_raw_ptr_library(
1396 _struct, CefTranslatorTestScopedLibraryChildCToCpp::UnwrapRaw(val));
1397
1398 // Return type: simple
1399 return _retval;
1400 }
1401
1402 NO_SANITIZE("cfi-icall")
SetRawPtrLibraryList(const std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>> & val,int val1,int val2)1403 bool CefTranslatorTestCToCpp::SetRawPtrLibraryList(
1404 const std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>>& val,
1405 int val1,
1406 int val2) {
1407 shutdown_checker::AssertNotShutdown();
1408
1409 cef_translator_test_t* _struct = GetStruct();
1410 if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_library_list))
1411 return false;
1412
1413 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1414
1415 // Translate param: val; type: rawptr_vec_same_byref_const
1416 const size_t valCount = val.size();
1417 cef_translator_test_scoped_library_t** valList = NULL;
1418 if (valCount > 0) {
1419 valList = new cef_translator_test_scoped_library_t*[valCount];
1420 DCHECK(valList);
1421 if (valList) {
1422 for (size_t i = 0; i < valCount; ++i) {
1423 valList[i] = CefTranslatorTestScopedLibraryCToCpp::UnwrapRaw(val[i]);
1424 }
1425 }
1426 }
1427
1428 // Execute
1429 int _retval =
1430 _struct->set_raw_ptr_library_list(_struct, valCount, valList, val1, val2);
1431
1432 // Restore param:val; type: rawptr_vec_same_byref_const
1433 if (valList)
1434 delete[] valList;
1435
1436 // Return type: bool
1437 return _retval ? true : false;
1438 }
1439
1440 NO_SANITIZE("cfi-icall")
SetRawPtrClient(CefRawPtr<CefTranslatorTestScopedClient> val)1441 int CefTranslatorTestCToCpp::SetRawPtrClient(
1442 CefRawPtr<CefTranslatorTestScopedClient> val) {
1443 shutdown_checker::AssertNotShutdown();
1444
1445 cef_translator_test_t* _struct = GetStruct();
1446 if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_client))
1447 return 0;
1448
1449 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1450
1451 // Verify param: val; type: rawptr_diff
1452 DCHECK(val);
1453 if (!val)
1454 return 0;
1455
1456 // Translate param: val; type: rawptr_diff
1457 CefOwnPtr<CefTranslatorTestScopedClientCppToC> valPtr(
1458 CefTranslatorTestScopedClientCppToC::WrapRaw(val));
1459
1460 // Execute
1461 int _retval = _struct->set_raw_ptr_client(_struct, valPtr->GetStruct());
1462
1463 // Return type: simple
1464 return _retval;
1465 }
1466
1467 NO_SANITIZE("cfi-icall")
SetChildRawPtrClient(CefRawPtr<CefTranslatorTestScopedClientChild> val)1468 int CefTranslatorTestCToCpp::SetChildRawPtrClient(
1469 CefRawPtr<CefTranslatorTestScopedClientChild> val) {
1470 shutdown_checker::AssertNotShutdown();
1471
1472 cef_translator_test_t* _struct = GetStruct();
1473 if (CEF_MEMBER_MISSING(_struct, set_child_raw_ptr_client))
1474 return 0;
1475
1476 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1477
1478 // Verify param: val; type: rawptr_diff
1479 DCHECK(val);
1480 if (!val)
1481 return 0;
1482
1483 // Translate param: val; type: rawptr_diff
1484 CefOwnPtr<CefTranslatorTestScopedClientChildCppToC> valPtr(
1485 CefTranslatorTestScopedClientChildCppToC::WrapRaw(val));
1486
1487 // Execute
1488 int _retval = _struct->set_child_raw_ptr_client(_struct, valPtr->GetStruct());
1489
1490 // Return type: simple
1491 return _retval;
1492 }
1493
1494 NO_SANITIZE("cfi-icall")
SetRawPtrClientList(const std::vector<CefRawPtr<CefTranslatorTestScopedClient>> & val,int val1,int val2)1495 bool CefTranslatorTestCToCpp::SetRawPtrClientList(
1496 const std::vector<CefRawPtr<CefTranslatorTestScopedClient>>& val,
1497 int val1,
1498 int val2) {
1499 shutdown_checker::AssertNotShutdown();
1500
1501 cef_translator_test_t* _struct = GetStruct();
1502 if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_client_list))
1503 return false;
1504
1505 // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
1506
1507 // Translate param: val; type: rawptr_vec_diff_byref_const
1508 const size_t valCount = val.size();
1509 cef_translator_test_scoped_client_t** valList = NULL;
1510 if (valCount > 0) {
1511 valList = new cef_translator_test_scoped_client_t*[valCount];
1512 DCHECK(valList);
1513 if (valList) {
1514 for (size_t i = 0; i < valCount; ++i) {
1515 valList[i] = CefTranslatorTestScopedClientCppToC::WrapRaw(val[i])
1516 .release()
1517 ->GetStruct();
1518 }
1519 }
1520 }
1521
1522 // Execute
1523 int _retval =
1524 _struct->set_raw_ptr_client_list(_struct, valCount, valList, val1, val2);
1525
1526 // Restore param:val; type: rawptr_vec_diff_byref_const
1527 if (valCount > 0) {
1528 for (size_t i = 0; i < valCount; ++i) {
1529 delete CefTranslatorTestScopedClientCppToC::GetWrapper(valList[i]);
1530 }
1531 }
1532 if (valList)
1533 delete[] valList;
1534
1535 // Return type: bool
1536 return _retval ? true : false;
1537 }
1538
1539 // CONSTRUCTOR - Do not edit by hand.
1540
CefTranslatorTestCToCpp()1541 CefTranslatorTestCToCpp::CefTranslatorTestCToCpp() {}
1542
1543 // DESTRUCTOR - Do not edit by hand.
1544
~CefTranslatorTestCToCpp()1545 CefTranslatorTestCToCpp::~CefTranslatorTestCToCpp() {
1546 shutdown_checker::AssertNotShutdown();
1547 }
1548
1549 template <>
1550 cef_translator_test_t* CefCToCppRefCounted<
1551 CefTranslatorTestCToCpp,
1552 CefTranslatorTest,
UnwrapDerived(CefWrapperType type,CefTranslatorTest * c)1553 cef_translator_test_t>::UnwrapDerived(CefWrapperType type,
1554 CefTranslatorTest* c) {
1555 NOTREACHED() << "Unexpected class type: " << type;
1556 return nullptr;
1557 }
1558
1559 template <>
1560 CefWrapperType CefCToCppRefCounted<CefTranslatorTestCToCpp,
1561 CefTranslatorTest,
1562 cef_translator_test_t>::kWrapperType =
1563 WT_TRANSLATOR_TEST;
1564