Add support for non-ref-counted interface classes (issue #2090)

2025-06-05 21:39:12 +02:00 · 2017-02-07 16:25:11 -05:00
parent 9dd0ca2661
commit 07ba48b082
98 changed files with 6369 additions and 1825 deletions
--- a/libcef_dll/ctocpp/test/translator_test_ctocpp.cc
+++ b/libcef_dll/ctocpp/test/translator_test_ctocpp.cc
@@ -11,11 +11,15 @@
 //

 #include <algorithm>
-#include "libcef_dll/cpptoc/test/translator_test_handler_cpptoc.h"
-#include "libcef_dll/cpptoc/test/translator_test_handler_child_cpptoc.h"
+#include "libcef_dll/cpptoc/test/translator_test_ref_ptr_client_cpptoc.h"
+#include "libcef_dll/cpptoc/test/translator_test_ref_ptr_client_child_cpptoc.h"
+#include "libcef_dll/cpptoc/test/translator_test_scoped_client_cpptoc.h"
+#include "libcef_dll/cpptoc/test/translator_test_scoped_client_child_cpptoc.h"
 #include "libcef_dll/ctocpp/test/translator_test_ctocpp.h"
-#include "libcef_dll/ctocpp/test/translator_test_object_ctocpp.h"
-#include "libcef_dll/ctocpp/test/translator_test_object_child_ctocpp.h"
+#include "libcef_dll/ctocpp/test/translator_test_ref_ptr_library_ctocpp.h"
+#include "libcef_dll/ctocpp/test/translator_test_ref_ptr_library_child_ctocpp.h"
+#include "libcef_dll/ctocpp/test/translator_test_scoped_library_ctocpp.h"
+#include "libcef_dll/ctocpp/test/translator_test_scoped_library_child_ctocpp.h"
 #include "libcef_dll/transfer_util.h"


@@ -632,24 +636,27 @@ size_t CefTranslatorTestCToCpp::GetPointListSize() {
  return _retval;
 }

-CefRefPtr<CefTranslatorTestObject> CefTranslatorTestCToCpp::GetObject(int val) {
+CefRefPtr<CefTranslatorTestRefPtrLibrary> CefTranslatorTestCToCpp::GetRefPtrLibrary(
+    int val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, get_object))
+  if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library))
    return NULL;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Execute
-  cef_translator_test_object_t* _retval = _struct->get_object(_struct,
+  cef_translator_test_ref_ptr_library_t* _retval = _struct->get_ref_ptr_library(
+      _struct,
      val);

  // Return type: refptr_same
-  return CefTranslatorTestObjectCToCpp::Wrap(_retval);
+  return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
 }

-int CefTranslatorTestCToCpp::SetObject(CefRefPtr<CefTranslatorTestObject> val) {
+int CefTranslatorTestCToCpp::SetRefPtrLibrary(
+    CefRefPtr<CefTranslatorTestRefPtrLibrary> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_object))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -660,17 +667,17 @@ int CefTranslatorTestCToCpp::SetObject(CefRefPtr<CefTranslatorTestObject> val) {
    return 0;

  // Execute
-  int _retval = _struct->set_object(_struct,
-      CefTranslatorTestObjectCToCpp::Unwrap(val));
+  int _retval = _struct->set_ref_ptr_library(_struct,
+      CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val));

  // Return type: simple
  return _retval;
 }

-CefRefPtr<CefTranslatorTestObject> CefTranslatorTestCToCpp::SetObjectAndReturn(
-    CefRefPtr<CefTranslatorTestObject> val) {
+CefRefPtr<CefTranslatorTestRefPtrLibrary> CefTranslatorTestCToCpp::SetRefPtrLibraryAndReturn(
+    CefRefPtr<CefTranslatorTestRefPtrLibrary> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_object_and_return))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library_and_return))
    return NULL;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -681,18 +688,18 @@ CefRefPtr<CefTranslatorTestObject> CefTranslatorTestCToCpp::SetObjectAndReturn(
    return NULL;

  // Execute
-  cef_translator_test_object_t* _retval = _struct->set_object_and_return(
-      _struct,
-      CefTranslatorTestObjectCToCpp::Unwrap(val));
+  cef_translator_test_ref_ptr_library_t* _retval =
+      _struct->set_ref_ptr_library_and_return(_struct,
+      CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val));

  // Return type: refptr_same
-  return CefTranslatorTestObjectCToCpp::Wrap(_retval);
+  return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
 }

-int CefTranslatorTestCToCpp::SetChildObject(
-    CefRefPtr<CefTranslatorTestObjectChild> val) {
+int CefTranslatorTestCToCpp::SetChildRefPtrLibrary(
+    CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_child_object))
+  if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_library))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -703,17 +710,17 @@ int CefTranslatorTestCToCpp::SetChildObject(
    return 0;

  // Execute
-  int _retval = _struct->set_child_object(_struct,
-      CefTranslatorTestObjectChildCToCpp::Unwrap(val));
+  int _retval = _struct->set_child_ref_ptr_library(_struct,
+      CefTranslatorTestRefPtrLibraryChildCToCpp::Unwrap(val));

  // Return type: simple
  return _retval;
 }

-CefRefPtr<CefTranslatorTestObject> CefTranslatorTestCToCpp::SetChildObjectAndReturnParent(
-    CefRefPtr<CefTranslatorTestObjectChild> val) {
+CefRefPtr<CefTranslatorTestRefPtrLibrary> CefTranslatorTestCToCpp::SetChildRefPtrLibraryAndReturnParent(
+    CefRefPtr<CefTranslatorTestRefPtrLibraryChild> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_child_object_and_return_parent))
+  if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_library_and_return_parent))
    return NULL;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -724,38 +731,38 @@ CefRefPtr<CefTranslatorTestObject> CefTranslatorTestCToCpp::SetChildObjectAndRet
    return NULL;

  // Execute
-  cef_translator_test_object_t* _retval =
-      _struct->set_child_object_and_return_parent(_struct,
-      CefTranslatorTestObjectChildCToCpp::Unwrap(val));
+  cef_translator_test_ref_ptr_library_t* _retval =
+      _struct->set_child_ref_ptr_library_and_return_parent(_struct,
+      CefTranslatorTestRefPtrLibraryChildCToCpp::Unwrap(val));

  // Return type: refptr_same
-  return CefTranslatorTestObjectCToCpp::Wrap(_retval);
+  return CefTranslatorTestRefPtrLibraryCToCpp::Wrap(_retval);
 }

-bool CefTranslatorTestCToCpp::SetObjectList(
-    const std::vector<CefRefPtr<CefTranslatorTestObject>>& val, int val1,
+bool CefTranslatorTestCToCpp::SetRefPtrLibraryList(
+    const std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>>& val, int val1,
    int val2) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_object_list))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_library_list))
    return false;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Translate param: val; type: refptr_vec_same_byref_const
  const size_t valCount = val.size();
-  cef_translator_test_object_t** valList = NULL;
+  cef_translator_test_ref_ptr_library_t** valList = NULL;
  if (valCount > 0) {
-    valList = new cef_translator_test_object_t*[valCount];
+    valList = new cef_translator_test_ref_ptr_library_t*[valCount];
    DCHECK(valList);
    if (valList) {
      for (size_t i = 0; i < valCount; ++i) {
-        valList[i] = CefTranslatorTestObjectCToCpp::Unwrap(val[i]);
+        valList[i] = CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val[i]);
      }
    }
  }

  // Execute
-  int _retval = _struct->set_object_list(_struct,
+  int _retval = _struct->set_ref_ptr_library_list(_struct,
      valCount,
      valList,
      val1,
@@ -769,33 +776,34 @@ bool CefTranslatorTestCToCpp::SetObjectList(
  return _retval?true:false;
 }

-bool CefTranslatorTestCToCpp::GetObjectListByRef(ObjectList& val, int val1,
-    int val2) {
+bool CefTranslatorTestCToCpp::GetRefPtrLibraryListByRef(RefPtrLibraryList& val,
+    int val1, int val2) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, get_object_list_by_ref))
+  if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library_list_by_ref))
    return false;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Translate param: val; type: refptr_vec_same_byref
  size_t valSize = val.size();
-  size_t valCount = std::max(GetObjectListSize(), valSize);
-  cef_translator_test_object_t** valList = NULL;
+  size_t valCount = std::max(GetRefPtrLibraryListSize(), valSize);
+  cef_translator_test_ref_ptr_library_t** valList = NULL;
  if (valCount > 0) {
-    valList = new cef_translator_test_object_t*[valCount];
+    valList = new cef_translator_test_ref_ptr_library_t*[valCount];
    DCHECK(valList);
    if (valList) {
-       memset(valList, 0, sizeof(cef_translator_test_object_t*)*valCount);
+       memset(valList, 0, sizeof(
+           cef_translator_test_ref_ptr_library_t*)*valCount);
    }
    if (valList && valSize > 0) {
      for (size_t i = 0; i < valSize; ++i) {
-        valList[i] = CefTranslatorTestObjectCToCpp::Unwrap(val[i]);
+        valList[i] = CefTranslatorTestRefPtrLibraryCToCpp::Unwrap(val[i]);
      }
    }
  }

  // Execute
-  int _retval = _struct->get_object_list_by_ref(_struct,
+  int _retval = _struct->get_ref_ptr_library_list_by_ref(_struct,
      &valCount,
      valList,
      val1,
@@ -805,7 +813,7 @@ bool CefTranslatorTestCToCpp::GetObjectListByRef(ObjectList& val, int val1,
  val.clear();
  if (valCount > 0 && valList) {
    for (size_t i = 0; i < valCount; ++i) {
-      val.push_back(CefTranslatorTestObjectCToCpp::Wrap(valList[i]));
+      val.push_back(CefTranslatorTestRefPtrLibraryCToCpp::Wrap(valList[i]));
    }
    delete [] valList;
  }
@@ -814,24 +822,24 @@ bool CefTranslatorTestCToCpp::GetObjectListByRef(ObjectList& val, int val1,
  return _retval?true:false;
 }

-size_t CefTranslatorTestCToCpp::GetObjectListSize() {
+size_t CefTranslatorTestCToCpp::GetRefPtrLibraryListSize() {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, get_object_list_size))
+  if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_library_list_size))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Execute
-  size_t _retval = _struct->get_object_list_size(_struct);
+  size_t _retval = _struct->get_ref_ptr_library_list_size(_struct);

  // Return type: simple
  return _retval;
 }

-int CefTranslatorTestCToCpp::SetHandler(
-    CefRefPtr<CefTranslatorTestHandler> val) {
+int CefTranslatorTestCToCpp::SetRefPtrClient(
+    CefRefPtr<CefTranslatorTestRefPtrClient> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_handler))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -842,17 +850,17 @@ int CefTranslatorTestCToCpp::SetHandler(
    return 0;

  // Execute
-  int _retval = _struct->set_handler(_struct,
-      CefTranslatorTestHandlerCppToC::Wrap(val));
+  int _retval = _struct->set_ref_ptr_client(_struct,
+      CefTranslatorTestRefPtrClientCppToC::Wrap(val));

  // Return type: simple
  return _retval;
 }

-CefRefPtr<CefTranslatorTestHandler> CefTranslatorTestCToCpp::SetHandlerAndReturn(
-    CefRefPtr<CefTranslatorTestHandler> val) {
+CefRefPtr<CefTranslatorTestRefPtrClient> CefTranslatorTestCToCpp::SetRefPtrClientAndReturn(
+    CefRefPtr<CefTranslatorTestRefPtrClient> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_handler_and_return))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client_and_return))
    return NULL;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -863,18 +871,18 @@ CefRefPtr<CefTranslatorTestHandler> CefTranslatorTestCToCpp::SetHandlerAndReturn
    return NULL;

  // Execute
-  cef_translator_test_handler_t* _retval = _struct->set_handler_and_return(
-      _struct,
-      CefTranslatorTestHandlerCppToC::Wrap(val));
+  cef_translator_test_ref_ptr_client_t* _retval =
+      _struct->set_ref_ptr_client_and_return(_struct,
+      CefTranslatorTestRefPtrClientCppToC::Wrap(val));

  // Return type: refptr_diff
-  return CefTranslatorTestHandlerCppToC::Unwrap(_retval);
+  return CefTranslatorTestRefPtrClientCppToC::Unwrap(_retval);
 }

-int CefTranslatorTestCToCpp::SetChildHandler(
-    CefRefPtr<CefTranslatorTestHandlerChild> val) {
+int CefTranslatorTestCToCpp::SetChildRefPtrClient(
+    CefRefPtr<CefTranslatorTestRefPtrClientChild> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_child_handler))
+  if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_client))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -885,17 +893,17 @@ int CefTranslatorTestCToCpp::SetChildHandler(
    return 0;

  // Execute
-  int _retval = _struct->set_child_handler(_struct,
-      CefTranslatorTestHandlerChildCppToC::Wrap(val));
+  int _retval = _struct->set_child_ref_ptr_client(_struct,
+      CefTranslatorTestRefPtrClientChildCppToC::Wrap(val));

  // Return type: simple
  return _retval;
 }

-CefRefPtr<CefTranslatorTestHandler> CefTranslatorTestCToCpp::SetChildHandlerAndReturnParent(
-    CefRefPtr<CefTranslatorTestHandlerChild> val) {
+CefRefPtr<CefTranslatorTestRefPtrClient> CefTranslatorTestCToCpp::SetChildRefPtrClientAndReturnParent(
+    CefRefPtr<CefTranslatorTestRefPtrClientChild> val) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_child_handler_and_return_parent))
+  if (CEF_MEMBER_MISSING(_struct, set_child_ref_ptr_client_and_return_parent))
    return NULL;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -906,38 +914,38 @@ CefRefPtr<CefTranslatorTestHandler> CefTranslatorTestCToCpp::SetChildHandlerAndR
    return NULL;

  // Execute
-  cef_translator_test_handler_t* _retval =
-      _struct->set_child_handler_and_return_parent(_struct,
-      CefTranslatorTestHandlerChildCppToC::Wrap(val));
+  cef_translator_test_ref_ptr_client_t* _retval =
+      _struct->set_child_ref_ptr_client_and_return_parent(_struct,
+      CefTranslatorTestRefPtrClientChildCppToC::Wrap(val));

  // Return type: refptr_diff
-  return CefTranslatorTestHandlerCppToC::Unwrap(_retval);
+  return CefTranslatorTestRefPtrClientCppToC::Unwrap(_retval);
 }

-bool CefTranslatorTestCToCpp::SetHandlerList(
-    const std::vector<CefRefPtr<CefTranslatorTestHandler>>& val, int val1,
+bool CefTranslatorTestCToCpp::SetRefPtrClientList(
+    const std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>>& val, int val1,
    int val2) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, set_handler_list))
+  if (CEF_MEMBER_MISSING(_struct, set_ref_ptr_client_list))
    return false;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Translate param: val; type: refptr_vec_diff_byref_const
  const size_t valCount = val.size();
-  cef_translator_test_handler_t** valList = NULL;
+  cef_translator_test_ref_ptr_client_t** valList = NULL;
  if (valCount > 0) {
-    valList = new cef_translator_test_handler_t*[valCount];
+    valList = new cef_translator_test_ref_ptr_client_t*[valCount];
    DCHECK(valList);
    if (valList) {
      for (size_t i = 0; i < valCount; ++i) {
-        valList[i] = CefTranslatorTestHandlerCppToC::Wrap(val[i]);
+        valList[i] = CefTranslatorTestRefPtrClientCppToC::Wrap(val[i]);
      }
    }
  }

  // Execute
-  int _retval = _struct->set_handler_list(_struct,
+  int _retval = _struct->set_ref_ptr_client_list(_struct,
      valCount,
      valList,
      val1,
@@ -951,11 +959,11 @@ bool CefTranslatorTestCToCpp::SetHandlerList(
  return _retval?true:false;
 }

-bool CefTranslatorTestCToCpp::GetHandlerListByRef(HandlerList& val,
-    CefRefPtr<CefTranslatorTestHandler> val1,
-    CefRefPtr<CefTranslatorTestHandler> val2) {
+bool CefTranslatorTestCToCpp::GetRefPtrClientListByRef(RefPtrClientList& val,
+    CefRefPtr<CefTranslatorTestRefPtrClient> val1,
+    CefRefPtr<CefTranslatorTestRefPtrClient> val2) {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, get_handler_list_by_ref))
+  if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_client_list_by_ref))
    return false;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@@ -971,33 +979,34 @@ bool CefTranslatorTestCToCpp::GetHandlerListByRef(HandlerList& val,

  // Translate param: val; type: refptr_vec_diff_byref
  size_t valSize = val.size();
-  size_t valCount = std::max(GetObjectListSize(), valSize);
-  cef_translator_test_handler_t** valList = NULL;
+  size_t valCount = std::max(GetRefPtrLibraryListSize(), valSize);
+  cef_translator_test_ref_ptr_client_t** valList = NULL;
  if (valCount > 0) {
-    valList = new cef_translator_test_handler_t*[valCount];
+    valList = new cef_translator_test_ref_ptr_client_t*[valCount];
    DCHECK(valList);
    if (valList) {
-       memset(valList, 0, sizeof(cef_translator_test_handler_t*)*valCount);
+       memset(valList, 0, sizeof(
+           cef_translator_test_ref_ptr_client_t*)*valCount);
    }
    if (valList && valSize > 0) {
      for (size_t i = 0; i < valSize; ++i) {
-        valList[i] = CefTranslatorTestHandlerCppToC::Wrap(val[i]);
+        valList[i] = CefTranslatorTestRefPtrClientCppToC::Wrap(val[i]);
      }
    }
  }

  // Execute
-  int _retval = _struct->get_handler_list_by_ref(_struct,
+  int _retval = _struct->get_ref_ptr_client_list_by_ref(_struct,
      &valCount,
      valList,
-      CefTranslatorTestHandlerCppToC::Wrap(val1),
-      CefTranslatorTestHandlerCppToC::Wrap(val2));
+      CefTranslatorTestRefPtrClientCppToC::Wrap(val1),
+      CefTranslatorTestRefPtrClientCppToC::Wrap(val2));

  // Restore param:val; type: refptr_vec_diff_byref
  val.clear();
  if (valCount > 0 && valList) {
    for (size_t i = 0; i < valCount; ++i) {
-      val.push_back(CefTranslatorTestHandlerCppToC::Unwrap(valList[i]));
+      val.push_back(CefTranslatorTestRefPtrClientCppToC::Unwrap(valList[i]));
    }
    delete [] valList;
  }
@@ -1006,20 +1015,381 @@ bool CefTranslatorTestCToCpp::GetHandlerListByRef(HandlerList& val,
  return _retval?true:false;
 }

-size_t CefTranslatorTestCToCpp::GetHandlerListSize() {
+size_t CefTranslatorTestCToCpp::GetRefPtrClientListSize() {
  cef_translator_test_t* _struct = GetStruct();
-  if (CEF_MEMBER_MISSING(_struct, get_handler_list_size))
+  if (CEF_MEMBER_MISSING(_struct, get_ref_ptr_client_list_size))
    return 0;

  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

  // Execute
-  size_t _retval = _struct->get_handler_list_size(_struct);
+  size_t _retval = _struct->get_ref_ptr_client_list_size(_struct);

  // Return type: simple
  return _retval;
 }

+CefOwnPtr<CefTranslatorTestScopedLibrary> CefTranslatorTestCToCpp::GetOwnPtrLibrary(
+    int val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, get_own_ptr_library))
+    return CefOwnPtr<CefTranslatorTestScopedLibrary>();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  cef_translator_test_scoped_library_t* _retval = _struct->get_own_ptr_library(
+      _struct,
+      val);
+
+  // Return type: ownptr_same
+  return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
+}
+
+int CefTranslatorTestCToCpp::SetOwnPtrLibrary(
+    CefOwnPtr<CefTranslatorTestScopedLibrary> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_own_ptr_library))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_same
+  DCHECK(val.get());
+  if (!val.get())
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_own_ptr_library(_struct,
+      CefTranslatorTestScopedLibraryCToCpp::UnwrapOwn(OWN_PASS(val)));
+
+  // Return type: simple
+  return _retval;
+}
+
+CefOwnPtr<CefTranslatorTestScopedLibrary> CefTranslatorTestCToCpp::SetOwnPtrLibraryAndReturn(
+    CefOwnPtr<CefTranslatorTestScopedLibrary> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_own_ptr_library_and_return))
+    return CefOwnPtr<CefTranslatorTestScopedLibrary>();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_same
+  DCHECK(val.get());
+  if (!val.get())
+    return CefOwnPtr<CefTranslatorTestScopedLibrary>();
+
+  // Execute
+  cef_translator_test_scoped_library_t* _retval =
+      _struct->set_own_ptr_library_and_return(_struct,
+      CefTranslatorTestScopedLibraryCToCpp::UnwrapOwn(OWN_PASS(val)));
+
+  // Return type: ownptr_same
+  return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
+}
+
+int CefTranslatorTestCToCpp::SetChildOwnPtrLibrary(
+    CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_library))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_same
+  DCHECK(val.get());
+  if (!val.get())
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_child_own_ptr_library(_struct,
+      CefTranslatorTestScopedLibraryChildCToCpp::UnwrapOwn(OWN_PASS(val)));
+
+  // Return type: simple
+  return _retval;
+}
+
+CefOwnPtr<CefTranslatorTestScopedLibrary> CefTranslatorTestCToCpp::SetChildOwnPtrLibraryAndReturnParent(
+    CefOwnPtr<CefTranslatorTestScopedLibraryChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_library_and_return_parent))
+    return CefOwnPtr<CefTranslatorTestScopedLibrary>();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_same
+  DCHECK(val.get());
+  if (!val.get())
+    return CefOwnPtr<CefTranslatorTestScopedLibrary>();
+
+  // Execute
+  cef_translator_test_scoped_library_t* _retval =
+      _struct->set_child_own_ptr_library_and_return_parent(_struct,
+      CefTranslatorTestScopedLibraryChildCToCpp::UnwrapOwn(OWN_PASS(val)));
+
+  // Return type: ownptr_same
+  return CefTranslatorTestScopedLibraryCToCpp::Wrap(_retval);
+}
+
+int CefTranslatorTestCToCpp::SetOwnPtrClient(
+    CefOwnPtr<CefTranslatorTestScopedClient> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_own_ptr_client))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_diff
+  DCHECK(val.get());
+  if (!val.get())
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_own_ptr_client(_struct,
+      CefTranslatorTestScopedClientCppToC::WrapOwn(OWN_PASS(val)));
+
+  // Return type: simple
+  return _retval;
+}
+
+CefOwnPtr<CefTranslatorTestScopedClient> CefTranslatorTestCToCpp::SetOwnPtrClientAndReturn(
+    CefOwnPtr<CefTranslatorTestScopedClient> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_own_ptr_client_and_return))
+    return CefOwnPtr<CefTranslatorTestScopedClient>();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_diff
+  DCHECK(val.get());
+  if (!val.get())
+    return CefOwnPtr<CefTranslatorTestScopedClient>();
+
+  // Execute
+  cef_translator_test_scoped_client_t* _retval =
+      _struct->set_own_ptr_client_and_return(_struct,
+      CefTranslatorTestScopedClientCppToC::WrapOwn(OWN_PASS(val)));
+
+  // Return type: ownptr_diff
+  return CefTranslatorTestScopedClientCppToC::UnwrapOwn(_retval);
+}
+
+int CefTranslatorTestCToCpp::SetChildOwnPtrClient(
+    CefOwnPtr<CefTranslatorTestScopedClientChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_client))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_diff
+  DCHECK(val.get());
+  if (!val.get())
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_child_own_ptr_client(_struct,
+      CefTranslatorTestScopedClientChildCppToC::WrapOwn(OWN_PASS(val)));
+
+  // Return type: simple
+  return _retval;
+}
+
+CefOwnPtr<CefTranslatorTestScopedClient> CefTranslatorTestCToCpp::SetChildOwnPtrClientAndReturnParent(
+    CefOwnPtr<CefTranslatorTestScopedClientChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_own_ptr_client_and_return_parent))
+    return CefOwnPtr<CefTranslatorTestScopedClient>();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: ownptr_diff
+  DCHECK(val.get());
+  if (!val.get())
+    return CefOwnPtr<CefTranslatorTestScopedClient>();
+
+  // Execute
+  cef_translator_test_scoped_client_t* _retval =
+      _struct->set_child_own_ptr_client_and_return_parent(_struct,
+      CefTranslatorTestScopedClientChildCppToC::WrapOwn(OWN_PASS(val)));
+
+  // Return type: ownptr_diff
+  return CefTranslatorTestScopedClientCppToC::UnwrapOwn(_retval);
+}
+
+int CefTranslatorTestCToCpp::SetRawPtrLibrary(
+    CefRawPtr<CefTranslatorTestScopedLibrary> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_library))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: rawptr_same
+  DCHECK(val);
+  if (!val)
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_raw_ptr_library(_struct,
+      CefTranslatorTestScopedLibraryCToCpp::UnwrapRaw(val));
+
+  // Return type: simple
+  return _retval;
+}
+
+int CefTranslatorTestCToCpp::SetChildRawPtrLibrary(
+    CefRawPtr<CefTranslatorTestScopedLibraryChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_raw_ptr_library))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: rawptr_same
+  DCHECK(val);
+  if (!val)
+    return 0;
+
+  // Execute
+  int _retval = _struct->set_child_raw_ptr_library(_struct,
+      CefTranslatorTestScopedLibraryChildCToCpp::UnwrapRaw(val));
+
+  // Return type: simple
+  return _retval;
+}
+
+bool CefTranslatorTestCToCpp::SetRawPtrLibraryList(
+    const std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>>& val, int val1,
+    int val2) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_library_list))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Translate param: val; type: rawptr_vec_same_byref_const
+  const size_t valCount = val.size();
+  cef_translator_test_scoped_library_t** valList = NULL;
+  if (valCount > 0) {
+    valList = new cef_translator_test_scoped_library_t*[valCount];
+    DCHECK(valList);
+    if (valList) {
+      for (size_t i = 0; i < valCount; ++i) {
+        valList[i] = CefTranslatorTestScopedLibraryCToCpp::UnwrapRaw(val[i]);
+      }
+    }
+  }
+
+  // Execute
+  int _retval = _struct->set_raw_ptr_library_list(_struct,
+      valCount,
+      valList,
+      val1,
+      val2);
+
+  // Restore param:val; type: rawptr_vec_same_byref_const
+  if (valList)
+    delete [] valList;
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+int CefTranslatorTestCToCpp::SetRawPtrClient(
+    CefRawPtr<CefTranslatorTestScopedClient> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_client))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: rawptr_diff
+  DCHECK(val);
+  if (!val)
+    return 0;
+
+  // Translate param: val; type: rawptr_diff
+  CefOwnPtr<CefTranslatorTestScopedClientCppToC> valPtr(
+      CefTranslatorTestScopedClientCppToC::WrapRaw(val));
+
+  // Execute
+  int _retval = _struct->set_raw_ptr_client(_struct,
+      valPtr->GetStruct());
+
+  // Return type: simple
+  return _retval;
+}
+
+int CefTranslatorTestCToCpp::SetChildRawPtrClient(
+    CefRawPtr<CefTranslatorTestScopedClientChild> val) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_child_raw_ptr_client))
+    return 0;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: val; type: rawptr_diff
+  DCHECK(val);
+  if (!val)
+    return 0;
+
+  // Translate param: val; type: rawptr_diff
+  CefOwnPtr<CefTranslatorTestScopedClientChildCppToC> valPtr(
+      CefTranslatorTestScopedClientChildCppToC::WrapRaw(val));
+
+  // Execute
+  int _retval = _struct->set_child_raw_ptr_client(_struct,
+      valPtr->GetStruct());
+
+  // Return type: simple
+  return _retval;
+}
+
+bool CefTranslatorTestCToCpp::SetRawPtrClientList(
+    const std::vector<CefRawPtr<CefTranslatorTestScopedClient>>& val, int val1,
+    int val2) {
+  cef_translator_test_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, set_raw_ptr_client_list))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Translate param: val; type: rawptr_vec_diff_byref_const
+  const size_t valCount = val.size();
+  cef_translator_test_scoped_client_t** valList = NULL;
+  if (valCount > 0) {
+    valList = new cef_translator_test_scoped_client_t*[valCount];
+    DCHECK(valList);
+    if (valList) {
+      for (size_t i = 0; i < valCount; ++i) {
+        valList[i] = CefTranslatorTestScopedClientCppToC::WrapRaw(
+            val[i]).release()->GetStruct();
+      }
+    }
+  }
+
+  // Execute
+  int _retval = _struct->set_raw_ptr_client_list(_struct,
+      valCount,
+      valList,
+      val1,
+      val2);
+
+  // Restore param:val; type: rawptr_vec_diff_byref_const
+  if (valCount > 0) {
+    for (size_t i = 0; i < valCount; ++i) {
+      delete CefTranslatorTestScopedClientCppToC::GetWrapper(valList[i]);
+    }
+  }
+  if (valList)
+    delete [] valList;
+
+  // Return type: bool
+  return _retval?true:false;
+}
+

 // CONSTRUCTOR - Do not edit by hand.