bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename CefBase to CefBaseRefCounted (issue #2090)

Browse Source
This commit is contained in:
Marshall Greenblatt
2017-02-09 17:07:43 -05:00
parent 07ba48b082
commit 0afcb82ee6
679 changed files with 2066 additions and 1962 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
libcef_dll/cpptoc/app_cpptoc.cc
View File

@ -125,16 +125,16 @@ CefAppCppToC::CefAppCppToC() {
GetStruct()->get_render_process_handler = app_get_render_process_handler;
}
template<> CefRefPtr<CefApp> CefCppToC<CefAppCppToC, CefApp,
template<> CefRefPtr<CefApp> CefCppToCRefCounted<CefAppCppToC, CefApp,
cef_app_t>::UnwrapDerived(CefWrapperType type, cef_app_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefAppCppToC, CefApp,
template<> base::AtomicRefCount CefCppToCRefCounted<CefAppCppToC, CefApp,
cef_app_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefAppCppToC, CefApp,
template<> CefWrapperType CefCppToCRefCounted<CefAppCppToC, CefApp,
cef_app_t>::kWrapperType = WT_APP;

4
libcef_dll/cpptoc/app_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_app.h"
#include "include/capi/cef_app_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefAppCppToC
: public CefCppToC<CefAppCppToC, CefApp, cef_app_t> {
: public CefCppToCRefCounted<CefAppCppToC, CefApp, cef_app_t> {
public:
CefAppCppToC();
};

8
libcef_dll/cpptoc/auth_callback_cpptoc.cc
View File

@ -60,7 +60,7 @@ CefAuthCallbackCppToC::CefAuthCallbackCppToC() {
GetStruct()->cancel = auth_callback_cancel;
}
template<> CefRefPtr<CefAuthCallback> CefCppToC<CefAuthCallbackCppToC,
template<> CefRefPtr<CefAuthCallback> CefCppToCRefCounted<CefAuthCallbackCppToC,
CefAuthCallback, cef_auth_callback_t>::UnwrapDerived(CefWrapperType type,
cef_auth_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -68,9 +68,9 @@ template<> CefRefPtr<CefAuthCallback> CefCppToC<CefAuthCallbackCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefAuthCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefAuthCallbackCppToC,
CefAuthCallback, cef_auth_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefAuthCallbackCppToC, CefAuthCallback,
cef_auth_callback_t>::kWrapperType = WT_AUTH_CALLBACK;
template<> CefWrapperType CefCppToCRefCounted<CefAuthCallbackCppToC,
CefAuthCallback, cef_auth_callback_t>::kWrapperType = WT_AUTH_CALLBACK;

4
libcef_dll/cpptoc/auth_callback_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_auth_callback.h"
#include "include/capi/cef_auth_callback_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefAuthCallbackCppToC
: public CefCppToC<CefAuthCallbackCppToC, CefAuthCallback,
: public CefCppToCRefCounted<CefAuthCallbackCppToC, CefAuthCallback,
cef_auth_callback_t> {
public:
CefAuthCallbackCppToC();

22
libcef_dll/cpptoc/base_cpptoc.cc
View File

@ -1,22 +0,0 @@
// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#include "libcef_dll/cpptoc/base_cpptoc.h"
CefBaseCppToC::CefBaseCppToC() {
}
template<> CefRefPtr<CefBase> CefCppToC<CefBaseCppToC, CefBase, cef_base_t>::
UnwrapDerived(CefWrapperType type, cef_base_t* s) {
NOTREACHED();
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBaseCppToC, CefBase,
cef_base_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBaseCppToC, CefBase,cef_base_t>::
kWrapperType = WT_BASE;

24
libcef_dll/cpptoc/base_ref_counted_cpptoc.cc Normal file
View File

@ -0,0 +1,24 @@
// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#include "libcef_dll/cpptoc/base_ref_counted_cpptoc.h"
CefBaseRefCountedCppToC::CefBaseRefCountedCppToC() {
}
template<> CefRefPtr<CefBaseRefCounted> CefCppToCRefCounted<
CefBaseRefCountedCppToC, CefBaseRefCounted, cef_base_ref_counted_t>::
UnwrapDerived(CefWrapperType type, cef_base_ref_counted_t* s) {
NOTREACHED();
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToCRefCounted<CefBaseRefCountedCppToC,
CefBaseRefCounted, cef_base_ref_counted_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToCRefCounted<CefBaseRefCountedCppToC,
CefBaseRefCounted, cef_base_ref_counted_t>::kWrapperType =
WT_BASE_REF_COUNTED;

15
libcef_dll/cpptoc/base_cpptoc.h → libcef_dll/cpptoc/base_ref_counted_cpptoc.h
View File

@ -2,23 +2,24 @@
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#ifndef CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_
#ifndef CEF_LIBCEF_DLL_CPPTOC_BASE_REF_COUNTED_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_BASE_REF_COUNTED_CPPTOC_H_
#pragma once
#include "include/cef_base.h"
#include "include/capi/cef_base_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
#if !defined(WRAPPING_CEF_SHARED)
#error This file can be included wrapper-side only
#endif
// Wrap a C++ class with a C structure.
class CefBaseCppToC
: public CefCppToC<CefBaseCppToC, CefBase, cef_base_t> {
class CefBaseRefCountedCppToC
: public CefCppToCRefCounted<CefBaseRefCountedCppToC, CefBaseRefCounted,
cef_base_ref_counted_t> {
public:
CefBaseCppToC();
CefBaseRefCountedCppToC();
};
#endif // CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_
#endif // CEF_LIBCEF_DLL_CPPTOC_BASE_REF_COUNTED_CPPTOC_H_

2
libcef_dll/cpptoc/base_scoped_cpptoc.cc
View File

@ -27,4 +27,4 @@ template<> base::AtomicRefCount CefCppToCScoped<CefBaseScopedCppToC,
#endif
template<> CefWrapperType CefCppToCScoped<CefBaseScopedCppToC, CefBaseScoped,
cef_base_scoped_t>::kWrapperType = WT_BASE;
cef_base_scoped_t>::kWrapperType = WT_BASE_SCOPED;

6
libcef_dll/cpptoc/before_download_callback_cpptoc.cc
View File

@ -42,7 +42,7 @@ CefBeforeDownloadCallbackCppToC::CefBeforeDownloadCallbackCppToC() {
GetStruct()->cont = before_download_callback_cont;
}
template<> CefRefPtr<CefBeforeDownloadCallback> CefCppToC<CefBeforeDownloadCallbackCppToC,
template<> CefRefPtr<CefBeforeDownloadCallback> CefCppToCRefCounted<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t>::UnwrapDerived(
CefWrapperType type, cef_before_download_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -50,11 +50,11 @@ template<> CefRefPtr<CefBeforeDownloadCallback> CefCppToC<CefBeforeDownloadCallb
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBeforeDownloadCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t>::DebugObjCt =
0;
#endif
template<> CefWrapperType CefCppToC<CefBeforeDownloadCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t>::kWrapperType =
WT_BEFORE_DOWNLOAD_CALLBACK;

4
libcef_dll/cpptoc/before_download_callback_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_download_handler.h"
#include "include/capi/cef_download_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefBeforeDownloadCallbackCppToC
: public CefCppToC<CefBeforeDownloadCallbackCppToC,
: public CefCppToCRefCounted<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t> {
public:
CefBeforeDownloadCallbackCppToC();

10
libcef_dll/cpptoc/binary_value_cpptoc.cc
View File

@ -172,7 +172,7 @@ CefBinaryValueCppToC::CefBinaryValueCppToC() {
GetStruct()->get_data = binary_value_get_data;
}
template<> CefRefPtr<CefBinaryValue> CefCppToC<CefBinaryValueCppToC,
template<> CefRefPtr<CefBinaryValue> CefCppToCRefCounted<CefBinaryValueCppToC,
CefBinaryValue, cef_binary_value_t>::UnwrapDerived(CefWrapperType type,
cef_binary_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -180,9 +180,9 @@ template<> CefRefPtr<CefBinaryValue> CefCppToC<CefBinaryValueCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefBinaryValueCppToC,
CefBinaryValue, cef_binary_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t>::kWrapperType = WT_BINARY_VALUE;
template<> CefWrapperType CefCppToCRefCounted<CefBinaryValueCppToC,
CefBinaryValue, cef_binary_value_t>::kWrapperType = WT_BINARY_VALUE;

4
libcef_dll/cpptoc/binary_value_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_values.h"
#include "include/capi/cef_values_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefBinaryValueCppToC
: public CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
: public CefCppToCRefCounted<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t> {
public:
CefBinaryValueCppToC();

11
libcef_dll/cpptoc/browser_cpptoc.cc
View File

@ -383,16 +383,17 @@ CefBrowserCppToC::CefBrowserCppToC() {
GetStruct()->send_process_message = browser_send_process_message;
}
template<> CefRefPtr<CefBrowser> CefCppToC<CefBrowserCppToC, CefBrowser,
cef_browser_t>::UnwrapDerived(CefWrapperType type, cef_browser_t* s) {
template<> CefRefPtr<CefBrowser> CefCppToCRefCounted<CefBrowserCppToC,
CefBrowser, cef_browser_t>::UnwrapDerived(CefWrapperType type,
cef_browser_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBrowserCppToC, CefBrowser,
cef_browser_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefBrowserCppToC,
CefBrowser, cef_browser_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserCppToC, CefBrowser,
template<> CefWrapperType CefCppToCRefCounted<CefBrowserCppToC, CefBrowser,
cef_browser_t>::kWrapperType = WT_BROWSER;

4
libcef_dll/cpptoc/browser_cpptoc.h
View File

@ -22,12 +22,12 @@
#include "include/capi/cef_browser_capi.h"
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefBrowserCppToC
: public CefCppToC<CefBrowserCppToC, CefBrowser, cef_browser_t> {
: public CefCppToCRefCounted<CefBrowserCppToC, CefBrowser, cef_browser_t> {
public:
CefBrowserCppToC();
};

10
libcef_dll/cpptoc/browser_host_cpptoc.cc
View File

@ -1074,7 +1074,7 @@ CefBrowserHostCppToC::CefBrowserHostCppToC() {
browser_host_get_visible_navigation_entry;
}
template<> CefRefPtr<CefBrowserHost> CefCppToC<CefBrowserHostCppToC,
template<> CefRefPtr<CefBrowserHost> CefCppToCRefCounted<CefBrowserHostCppToC,
CefBrowserHost, cef_browser_host_t>::UnwrapDerived(CefWrapperType type,
cef_browser_host_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -1082,9 +1082,9 @@ template<> CefRefPtr<CefBrowserHost> CefCppToC<CefBrowserHostCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefBrowserHostCppToC,
CefBrowserHost, cef_browser_host_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t>::kWrapperType = WT_BROWSER_HOST;
template<> CefWrapperType CefCppToCRefCounted<CefBrowserHostCppToC,
CefBrowserHost, cef_browser_host_t>::kWrapperType = WT_BROWSER_HOST;

4
libcef_dll/cpptoc/browser_host_cpptoc.h
View File

@ -22,12 +22,12 @@
#include "include/capi/cef_browser_capi.h"
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefBrowserHostCppToC
: public CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
: public CefCppToCRefCounted<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t> {
public:
CefBrowserHostCppToC();

6
libcef_dll/cpptoc/browser_process_handler_cpptoc.cc
View File

@ -114,7 +114,7 @@ CefBrowserProcessHandlerCppToC::CefBrowserProcessHandlerCppToC() {
browser_process_handler_on_schedule_message_pump_work;
}
template<> CefRefPtr<CefBrowserProcessHandler> CefCppToC<CefBrowserProcessHandlerCppToC,
template<> CefRefPtr<CefBrowserProcessHandler> CefCppToCRefCounted<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::UnwrapDerived(
CefWrapperType type, cef_browser_process_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -122,10 +122,10 @@ template<> CefRefPtr<CefBrowserProcessHandler> CefCppToC<CefBrowserProcessHandle
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefBrowserProcessHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserProcessHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::kWrapperType =
WT_BROWSER_PROCESS_HANDLER;

6
libcef_dll/cpptoc/browser_process_handler_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_browser_process_handler.h"
#include "include/capi/cef_browser_process_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefBrowserProcessHandlerCppToC
: public CefCppToC<CefBrowserProcessHandlerCppToC, CefBrowserProcessHandler,
cef_browser_process_handler_t> {
: public CefCppToCRefCounted<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t> {
public:
CefBrowserProcessHandlerCppToC();
};

11
libcef_dll/cpptoc/callback_cpptoc.cc
View File

@ -49,16 +49,17 @@ CefCallbackCppToC::CefCallbackCppToC() {
GetStruct()->cancel = callback_cancel;
}
template<> CefRefPtr<CefCallback> CefCppToC<CefCallbackCppToC, CefCallback,
cef_callback_t>::UnwrapDerived(CefWrapperType type, cef_callback_t* s) {
template<> CefRefPtr<CefCallback> CefCppToCRefCounted<CefCallbackCppToC,
CefCallback, cef_callback_t>::UnwrapDerived(CefWrapperType type,
cef_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefCallbackCppToC, CefCallback,
cef_callback_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefCallbackCppToC,
CefCallback, cef_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCallbackCppToC, CefCallback,
template<> CefWrapperType CefCppToCRefCounted<CefCallbackCppToC, CefCallback,
cef_callback_t>::kWrapperType = WT_CALLBACK;

5
libcef_dll/cpptoc/callback_cpptoc.h
View File

@ -20,12 +20,13 @@
#include "include/cef_callback.h"
#include "include/capi/cef_callback_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefCallbackCppToC
: public CefCppToC<CefCallbackCppToC, CefCallback, cef_callback_t> {
: public CefCppToCRefCounted<CefCallbackCppToC, CefCallback,
cef_callback_t> {
public:
CefCallbackCppToC();
};

6
libcef_dll/cpptoc/client_cpptoc.cc
View File

@ -307,16 +307,16 @@ CefClientCppToC::CefClientCppToC() {
GetStruct()->on_process_message_received = client_on_process_message_received;
}
template<> CefRefPtr<CefClient> CefCppToC<CefClientCppToC, CefClient,
template<> CefRefPtr<CefClient> CefCppToCRefCounted<CefClientCppToC, CefClient,
cef_client_t>::UnwrapDerived(CefWrapperType type, cef_client_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefClientCppToC, CefClient,
template<> base::AtomicRefCount CefCppToCRefCounted<CefClientCppToC, CefClient,
cef_client_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefClientCppToC, CefClient,
template<> CefWrapperType CefCppToCRefCounted<CefClientCppToC, CefClient,
cef_client_t>::kWrapperType = WT_CLIENT;

4
libcef_dll/cpptoc/client_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefClientCppToC
: public CefCppToC<CefClientCppToC, CefClient, cef_client_t> {
: public CefCppToCRefCounted<CefClientCppToC, CefClient, cef_client_t> {
public:
CefClientCppToC();
};

10
libcef_dll/cpptoc/command_line_cpptoc.cc
View File

@ -422,7 +422,7 @@ CefCommandLineCppToC::CefCommandLineCppToC() {
GetStruct()->prepend_wrapper = command_line_prepend_wrapper;
}
template<> CefRefPtr<CefCommandLine> CefCppToC<CefCommandLineCppToC,
template<> CefRefPtr<CefCommandLine> CefCppToCRefCounted<CefCommandLineCppToC,
CefCommandLine, cef_command_line_t>::UnwrapDerived(CefWrapperType type,
cef_command_line_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -430,9 +430,9 @@ template<> CefRefPtr<CefCommandLine> CefCppToC<CefCommandLineCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefCommandLineCppToC,
CefCommandLine, cef_command_line_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t>::kWrapperType = WT_COMMAND_LINE;
template<> CefWrapperType CefCppToCRefCounted<CefCommandLineCppToC,
CefCommandLine, cef_command_line_t>::kWrapperType = WT_COMMAND_LINE;

4
libcef_dll/cpptoc/command_line_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_command_line.h"
#include "include/capi/cef_command_line_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefCommandLineCppToC
: public CefCppToC<CefCommandLineCppToC, CefCommandLine,
: public CefCppToCRefCounted<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t> {
public:
CefCommandLineCppToC();

6
libcef_dll/cpptoc/completion_callback_cpptoc.cc
View File

@ -38,7 +38,7 @@ CefCompletionCallbackCppToC::CefCompletionCallbackCppToC() {
GetStruct()->on_complete = completion_callback_on_complete;
}
template<> CefRefPtr<CefCompletionCallback> CefCppToC<CefCompletionCallbackCppToC,
template<> CefRefPtr<CefCompletionCallback> CefCppToCRefCounted<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::UnwrapDerived(
CefWrapperType type, cef_completion_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -46,10 +46,10 @@ template<> CefRefPtr<CefCompletionCallback> CefCppToC<CefCompletionCallbackCppTo
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefCompletionCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCompletionCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::kWrapperType =
WT_COMPLETION_CALLBACK;

6
libcef_dll/cpptoc/completion_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_callback.h"
#include "include/capi/cef_callback_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefCompletionCallbackCppToC
: public CefCppToC<CefCompletionCallbackCppToC, CefCompletionCallback,
cef_completion_callback_t> {
: public CefCppToCRefCounted<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t> {
public:
CefCompletionCallbackCppToC();
};

6
libcef_dll/cpptoc/context_menu_handler_cpptoc.cc
View File

@ -171,7 +171,7 @@ CefContextMenuHandlerCppToC::CefContextMenuHandlerCppToC() {
context_menu_handler_on_context_menu_dismissed;
}
template<> CefRefPtr<CefContextMenuHandler> CefCppToC<CefContextMenuHandlerCppToC,
template<> CefRefPtr<CefContextMenuHandler> CefCppToCRefCounted<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::UnwrapDerived(
CefWrapperType type, cef_context_menu_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -179,10 +179,10 @@ template<> CefRefPtr<CefContextMenuHandler> CefCppToC<CefContextMenuHandlerCppTo
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefContextMenuHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefContextMenuHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::kWrapperType =
WT_CONTEXT_MENU_HANDLER;

6
libcef_dll/cpptoc/context_menu_handler_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_context_menu_handler.h"
#include "include/capi/cef_context_menu_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefContextMenuHandlerCppToC
: public CefCppToC<CefContextMenuHandlerCppToC, CefContextMenuHandler,
cef_context_menu_handler_t> {
: public CefCppToCRefCounted<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t> {
public:
CefContextMenuHandlerCppToC();
};

6
libcef_dll/cpptoc/context_menu_params_cpptoc.cc
View File

@ -386,7 +386,7 @@ CefContextMenuParamsCppToC::CefContextMenuParamsCppToC() {
GetStruct()->is_pepper_menu = context_menu_params_is_pepper_menu;
}
template<> CefRefPtr<CefContextMenuParams> CefCppToC<CefContextMenuParamsCppToC,
template<> CefRefPtr<CefContextMenuParams> CefCppToCRefCounted<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::UnwrapDerived(
CefWrapperType type, cef_context_menu_params_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -394,10 +394,10 @@ template<> CefRefPtr<CefContextMenuParams> CefCppToC<CefContextMenuParamsCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefContextMenuParamsCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefContextMenuParamsCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::kWrapperType =
WT_CONTEXT_MENU_PARAMS;

6
libcef_dll/cpptoc/context_menu_params_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_context_menu_handler.h"
#include "include/capi/cef_context_menu_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefContextMenuParamsCppToC
: public CefCppToC<CefContextMenuParamsCppToC, CefContextMenuParams,
cef_context_menu_params_t> {
: public CefCppToCRefCounted<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t> {
public:
CefContextMenuParamsCppToC();
};

8
libcef_dll/cpptoc/cookie_manager_cpptoc.cc
View File

@ -234,7 +234,7 @@ CefCookieManagerCppToC::CefCookieManagerCppToC() {
GetStruct()->flush_store = cookie_manager_flush_store;
}
template<> CefRefPtr<CefCookieManager> CefCppToC<CefCookieManagerCppToC,
template<> CefRefPtr<CefCookieManager> CefCppToCRefCounted<CefCookieManagerCppToC,
CefCookieManager, cef_cookie_manager_t>::UnwrapDerived(CefWrapperType type,
cef_cookie_manager_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -242,9 +242,9 @@ template<> CefRefPtr<CefCookieManager> CefCppToC<CefCookieManagerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefCookieManagerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefCookieManagerCppToC,
CefCookieManager, cef_cookie_manager_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCookieManagerCppToC, CefCookieManager,
cef_cookie_manager_t>::kWrapperType = WT_COOKIE_MANAGER;
template<> CefWrapperType CefCppToCRefCounted<CefCookieManagerCppToC,
CefCookieManager, cef_cookie_manager_t>::kWrapperType = WT_COOKIE_MANAGER;

4
libcef_dll/cpptoc/cookie_manager_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_cookie.h"
#include "include/capi/cef_cookie_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefCookieManagerCppToC
: public CefCppToC<CefCookieManagerCppToC, CefCookieManager,
: public CefCppToCRefCounted<CefCookieManagerCppToC, CefCookieManager,
cef_cookie_manager_t> {
public:
CefCookieManagerCppToC();

8
libcef_dll/cpptoc/cookie_visitor_cpptoc.cc
View File

@ -65,7 +65,7 @@ CefCookieVisitorCppToC::CefCookieVisitorCppToC() {
GetStruct()->visit = cookie_visitor_visit;
}
template<> CefRefPtr<CefCookieVisitor> CefCppToC<CefCookieVisitorCppToC,
template<> CefRefPtr<CefCookieVisitor> CefCppToCRefCounted<CefCookieVisitorCppToC,
CefCookieVisitor, cef_cookie_visitor_t>::UnwrapDerived(CefWrapperType type,
cef_cookie_visitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -73,9 +73,9 @@ template<> CefRefPtr<CefCookieVisitor> CefCppToC<CefCookieVisitorCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefCookieVisitorCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefCookieVisitorCppToC,
CefCookieVisitor, cef_cookie_visitor_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCookieVisitorCppToC, CefCookieVisitor,
cef_cookie_visitor_t>::kWrapperType = WT_COOKIE_VISITOR;
template<> CefWrapperType CefCppToCRefCounted<CefCookieVisitorCppToC,
CefCookieVisitor, cef_cookie_visitor_t>::kWrapperType = WT_COOKIE_VISITOR;

4
libcef_dll/cpptoc/cookie_visitor_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_cookie.h"
#include "include/capi/cef_cookie_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefCookieVisitorCppToC
: public CefCppToC<CefCookieVisitorCppToC, CefCookieVisitor,
: public CefCppToCRefCounted<CefCookieVisitorCppToC, CefCookieVisitor,
cef_cookie_visitor_t> {
public:
CefCookieVisitorCppToC();

35
libcef_dll/cpptoc/cpptoc.h → libcef_dll/cpptoc/cpptoc_ref_counted.h
View File

@ -2,8 +2,8 @@
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#ifndef CEF_LIBCEF_DLL_CPPTOC_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_CPPTOC_H_
#ifndef CEF_LIBCEF_DLL_CPPTOC_CPPTOC_REF_COUNTED_H_
#define CEF_LIBCEF_DLL_CPPTOC_CPPTOC_REF_COUNTED_H_
#pragma once
#include "include/base/cef_logging.h"
@ -16,7 +16,7 @@
// implementation exists on this side of the DLL boundary but will have methods
// called from the other side of the DLL boundary.
template <class ClassName, class BaseName, class StructName>
class CefCppToC : public CefBase {
class CefCppToCRefCounted : public CefBaseRefCounted {
public:
// Create a new wrapper instance and associated structure reference for
// passing an object instance the other side.
@ -24,7 +24,7 @@ class CefCppToC : public CefBase {
if (!c.get())
return NULL;
// Wrap our object with the CefCppToC class.
// Wrap our object with the CefCppToCRefCounted class.
ClassName* wrapper = new ClassName();
wrapper->wrapper_struct_.object_ = c.get();
// Add a reference to our wrapper object that will be released once our
@ -69,12 +69,12 @@ class CefCppToC : public CefBase {
}
// If returning the structure across the DLL boundary you should call
// AddRef() on this CefCppToC object. On the other side of the DLL boundary,
// call UnderlyingRelease() on the wrapping CefCToCpp object.
// AddRef() on this CefCppToCRefCounted object. On the other side of the DLL
// boundary, call UnderlyingRelease() on the wrapping CefCToCpp object.
StructName* GetStruct() { return &wrapper_struct_.struct_; }
// CefBase methods increment/decrement reference counts on both this object
// and the underlying wrapper class.
// CefBaseRefCounted methods increment/decrement reference counts on both this
// object and the underlying wrapper class.
void AddRef() const {
UnderlyingAddRef();
ref_count_.AddRef();
@ -95,12 +95,13 @@ class CefCppToC : public CefBase {
#endif
protected:
CefCppToC() {
CefCppToCRefCounted() {
wrapper_struct_.type_ = kWrapperType;
wrapper_struct_.wrapper_ = this;
memset(GetStruct(), 0, sizeof(StructName));
cef_base_t* base = reinterpret_cast<cef_base_t*>(GetStruct());
cef_base_ref_counted_t* base =
reinterpret_cast<cef_base_ref_counted_t*>(GetStruct());
base->size = sizeof(StructName);
base->add_ref = struct_add_ref;
base->release = struct_release;
@ -111,7 +112,7 @@ class CefCppToC : public CefBase {
#endif
}
virtual ~CefCppToC() {
virtual ~CefCppToCRefCounted() {
#if DCHECK_IS_ON()
base::AtomicRefCountDec(&DebugObjCt);
#endif
@ -123,7 +124,7 @@ class CefCppToC : public CefBase {
struct WrapperStruct {
CefWrapperType type_;
BaseName* object_;
CefCppToC<ClassName, BaseName, StructName>* wrapper_;
CefCppToCRefCounted<ClassName, BaseName, StructName>* wrapper_;
StructName struct_;
};
@ -150,7 +151,7 @@ class CefCppToC : public CefBase {
return wrapper_struct_.object_->HasOneRef();
}
static void CEF_CALLBACK struct_add_ref(cef_base_t* base) {
static void CEF_CALLBACK struct_add_ref(cef_base_ref_counted_t* base) {
DCHECK(base);
if (!base)
return;
@ -163,7 +164,7 @@ class CefCppToC : public CefBase {
wrapperStruct->wrapper_->AddRef();
}
static int CEF_CALLBACK struct_release(cef_base_t* base) {
static int CEF_CALLBACK struct_release(cef_base_ref_counted_t* base) {
DCHECK(base);
if (!base)
return 0;
@ -176,7 +177,7 @@ class CefCppToC : public CefBase {
return wrapperStruct->wrapper_->Release();
}
static int CEF_CALLBACK struct_has_one_ref(cef_base_t* base) {
static int CEF_CALLBACK struct_has_one_ref(cef_base_ref_counted_t* base) {
DCHECK(base);
if (!base)
return 0;
@ -194,7 +195,7 @@ class CefCppToC : public CefBase {
static CefWrapperType kWrapperType;
DISALLOW_COPY_AND_ASSIGN(CefCppToC);
DISALLOW_COPY_AND_ASSIGN(CefCppToCRefCounted);
};
#endif // CEF_LIBCEF_DLL_CPPTOC_CPPTOC_H_
#endif // CEF_LIBCEF_DLL_CPPTOC_CPPTOC_REF_COUNTED_H_

6
libcef_dll/cpptoc/delete_cookies_callback_cpptoc.cc
View File

@ -39,7 +39,7 @@ CefDeleteCookiesCallbackCppToC::CefDeleteCookiesCallbackCppToC() {
GetStruct()->on_complete = delete_cookies_callback_on_complete;
}
template<> CefRefPtr<CefDeleteCookiesCallback> CefCppToC<CefDeleteCookiesCallbackCppToC,
template<> CefRefPtr<CefDeleteCookiesCallback> CefCppToCRefCounted<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::UnwrapDerived(
CefWrapperType type, cef_delete_cookies_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -47,10 +47,10 @@ template<> CefRefPtr<CefDeleteCookiesCallback> CefCppToC<CefDeleteCookiesCallbac
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDeleteCookiesCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDeleteCookiesCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::kWrapperType =
WT_DELETE_COOKIES_CALLBACK;

6
libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_cookie.h"
#include "include/capi/cef_cookie_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDeleteCookiesCallbackCppToC
: public CefCppToC<CefDeleteCookiesCallbackCppToC, CefDeleteCookiesCallback,
cef_delete_cookies_callback_t> {
: public CefCppToCRefCounted<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t> {
public:
CefDeleteCookiesCallbackCppToC();
};

8
libcef_dll/cpptoc/dialog_handler_cpptoc.cc
View File

@ -71,7 +71,7 @@ CefDialogHandlerCppToC::CefDialogHandlerCppToC() {
GetStruct()->on_file_dialog = dialog_handler_on_file_dialog;
}
template<> CefRefPtr<CefDialogHandler> CefCppToC<CefDialogHandlerCppToC,
template<> CefRefPtr<CefDialogHandler> CefCppToCRefCounted<CefDialogHandlerCppToC,
CefDialogHandler, cef_dialog_handler_t>::UnwrapDerived(CefWrapperType type,
cef_dialog_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -79,9 +79,9 @@ template<> CefRefPtr<CefDialogHandler> CefCppToC<CefDialogHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDialogHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDialogHandlerCppToC,
CefDialogHandler, cef_dialog_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDialogHandlerCppToC, CefDialogHandler,
cef_dialog_handler_t>::kWrapperType = WT_DIALOG_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefDialogHandlerCppToC,
CefDialogHandler, cef_dialog_handler_t>::kWrapperType = WT_DIALOG_HANDLER;

4
libcef_dll/cpptoc/dialog_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_dialog_handler.h"
#include "include/capi/cef_dialog_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDialogHandlerCppToC
: public CefCppToC<CefDialogHandlerCppToC, CefDialogHandler,
: public CefCppToCRefCounted<CefDialogHandlerCppToC, CefDialogHandler,
cef_dialog_handler_t> {
public:
CefDialogHandlerCppToC();

6
libcef_dll/cpptoc/dictionary_value_cpptoc.cc
View File

@ -663,7 +663,7 @@ CefDictionaryValueCppToC::CefDictionaryValueCppToC() {
GetStruct()->set_list = dictionary_value_set_list;
}
template<> CefRefPtr<CefDictionaryValue> CefCppToC<CefDictionaryValueCppToC,
template<> CefRefPtr<CefDictionaryValue> CefCppToCRefCounted<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::UnwrapDerived(
CefWrapperType type, cef_dictionary_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -671,10 +671,10 @@ template<> CefRefPtr<CefDictionaryValue> CefCppToC<CefDictionaryValueCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDictionaryValueCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDictionaryValueCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::kWrapperType =
WT_DICTIONARY_VALUE;

4
libcef_dll/cpptoc/dictionary_value_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_values.h"
#include "include/capi/cef_values_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDictionaryValueCppToC
: public CefCppToC<CefDictionaryValueCppToC, CefDictionaryValue,
: public CefCppToCRefCounted<CefDictionaryValueCppToC, CefDictionaryValue,
cef_dictionary_value_t> {
public:
CefDictionaryValueCppToC();

9
libcef_dll/cpptoc/display_handler_cpptoc.cc
View File

@ -197,7 +197,7 @@ CefDisplayHandlerCppToC::CefDisplayHandlerCppToC() {
GetStruct()->on_console_message = display_handler_on_console_message;
}
template<> CefRefPtr<CefDisplayHandler> CefCppToC<CefDisplayHandlerCppToC,
template<> CefRefPtr<CefDisplayHandler> CefCppToCRefCounted<CefDisplayHandlerCppToC,
CefDisplayHandler, cef_display_handler_t>::UnwrapDerived(
CefWrapperType type, cef_display_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -205,9 +205,10 @@ template<> CefRefPtr<CefDisplayHandler> CefCppToC<CefDisplayHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDisplayHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDisplayHandlerCppToC,
CefDisplayHandler, cef_display_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDisplayHandlerCppToC, CefDisplayHandler,
cef_display_handler_t>::kWrapperType = WT_DISPLAY_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefDisplayHandlerCppToC,
CefDisplayHandler, cef_display_handler_t>::kWrapperType =
WT_DISPLAY_HANDLER;

4
libcef_dll/cpptoc/display_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_display_handler.h"
#include "include/capi/cef_display_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDisplayHandlerCppToC
: public CefCppToC<CefDisplayHandlerCppToC, CefDisplayHandler,
: public CefCppToCRefCounted<CefDisplayHandlerCppToC, CefDisplayHandler,
cef_display_handler_t> {
public:
CefDisplayHandlerCppToC();

10
libcef_dll/cpptoc/domdocument_cpptoc.cc
View File

@ -263,7 +263,7 @@ CefDOMDocumentCppToC::CefDOMDocumentCppToC() {
GetStruct()->get_complete_url = domdocument_get_complete_url;
}
template<> CefRefPtr<CefDOMDocument> CefCppToC<CefDOMDocumentCppToC,
template<> CefRefPtr<CefDOMDocument> CefCppToCRefCounted<CefDOMDocumentCppToC,
CefDOMDocument, cef_domdocument_t>::UnwrapDerived(CefWrapperType type,
cef_domdocument_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -271,9 +271,9 @@ template<> CefRefPtr<CefDOMDocument> CefCppToC<CefDOMDocumentCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefDOMDocumentCppToC,
CefDOMDocument, cef_domdocument_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t>::kWrapperType = WT_DOMDOCUMENT;
template<> CefWrapperType CefCppToCRefCounted<CefDOMDocumentCppToC,
CefDOMDocument, cef_domdocument_t>::kWrapperType = WT_DOMDOCUMENT;

4
libcef_dll/cpptoc/domdocument_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_dom.h"
#include "include/capi/cef_dom_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDOMDocumentCppToC
: public CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
: public CefCppToCRefCounted<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t> {
public:
CefDOMDocumentCppToC();

11
libcef_dll/cpptoc/domnode_cpptoc.cc
View File

@ -479,16 +479,17 @@ CefDOMNodeCppToC::CefDOMNodeCppToC() {
GetStruct()->get_element_bounds = domnode_get_element_bounds;
}
template<> CefRefPtr<CefDOMNode> CefCppToC<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::UnwrapDerived(CefWrapperType type, cef_domnode_t* s) {
template<> CefRefPtr<CefDOMNode> CefCppToCRefCounted<CefDOMNodeCppToC,
CefDOMNode, cef_domnode_t>::UnwrapDerived(CefWrapperType type,
cef_domnode_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefDOMNodeCppToC,
CefDOMNode, cef_domnode_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMNodeCppToC, CefDOMNode,
template<> CefWrapperType CefCppToCRefCounted<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::kWrapperType = WT_DOMNODE;

4
libcef_dll/cpptoc/domnode_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_dom.h"
#include "include/capi/cef_dom_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDOMNodeCppToC
: public CefCppToC<CefDOMNodeCppToC, CefDOMNode, cef_domnode_t> {
: public CefCppToCRefCounted<CefDOMNodeCppToC, CefDOMNode, cef_domnode_t> {
public:
CefDOMNodeCppToC();
};

10
libcef_dll/cpptoc/domvisitor_cpptoc.cc
View File

@ -44,7 +44,7 @@ CefDOMVisitorCppToC::CefDOMVisitorCppToC() {
GetStruct()->visit = domvisitor_visit;
}
template<> CefRefPtr<CefDOMVisitor> CefCppToC<CefDOMVisitorCppToC,
template<> CefRefPtr<CefDOMVisitor> CefCppToCRefCounted<CefDOMVisitorCppToC,
CefDOMVisitor, cef_domvisitor_t>::UnwrapDerived(CefWrapperType type,
cef_domvisitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -52,9 +52,9 @@ template<> CefRefPtr<CefDOMVisitor> CefCppToC<CefDOMVisitorCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor,
cef_domvisitor_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefDOMVisitorCppToC,
CefDOMVisitor, cef_domvisitor_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor,
cef_domvisitor_t>::kWrapperType = WT_DOMVISITOR;
template<> CefWrapperType CefCppToCRefCounted<CefDOMVisitorCppToC,
CefDOMVisitor, cef_domvisitor_t>::kWrapperType = WT_DOMVISITOR;

5
libcef_dll/cpptoc/domvisitor_cpptoc.h
View File

@ -20,12 +20,13 @@
#include "include/cef_dom.h"
#include "include/capi/cef_dom_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDOMVisitorCppToC
: public CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor, cef_domvisitor_t> {
: public CefCppToCRefCounted<CefDOMVisitorCppToC, CefDOMVisitor,
cef_domvisitor_t> {
public:
CefDOMVisitorCppToC();
};

6
libcef_dll/cpptoc/download_handler_cpptoc.cc
View File

@ -95,7 +95,7 @@ CefDownloadHandlerCppToC::CefDownloadHandlerCppToC() {
GetStruct()->on_download_updated = download_handler_on_download_updated;
}
template<> CefRefPtr<CefDownloadHandler> CefCppToC<CefDownloadHandlerCppToC,
template<> CefRefPtr<CefDownloadHandler> CefCppToCRefCounted<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::UnwrapDerived(
CefWrapperType type, cef_download_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -103,10 +103,10 @@ template<> CefRefPtr<CefDownloadHandler> CefCppToC<CefDownloadHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDownloadHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::kWrapperType =
WT_DOWNLOAD_HANDLER;

4
libcef_dll/cpptoc/download_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_download_handler.h"
#include "include/capi/cef_download_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDownloadHandlerCppToC
: public CefCppToC<CefDownloadHandlerCppToC, CefDownloadHandler,
: public CefCppToCRefCounted<CefDownloadHandlerCppToC, CefDownloadHandler,
cef_download_handler_t> {
public:
CefDownloadHandlerCppToC();

6
libcef_dll/cpptoc/download_image_callback_cpptoc.cc
View File

@ -49,7 +49,7 @@ CefDownloadImageCallbackCppToC::CefDownloadImageCallbackCppToC() {
download_image_callback_on_download_image_finished;
}
template<> CefRefPtr<CefDownloadImageCallback> CefCppToC<CefDownloadImageCallbackCppToC,
template<> CefRefPtr<CefDownloadImageCallback> CefCppToCRefCounted<CefDownloadImageCallbackCppToC,
CefDownloadImageCallback, cef_download_image_callback_t>::UnwrapDerived(
CefWrapperType type, cef_download_image_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -57,10 +57,10 @@ template<> CefRefPtr<CefDownloadImageCallback> CefCppToC<CefDownloadImageCallbac
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDownloadImageCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDownloadImageCallbackCppToC,
CefDownloadImageCallback, cef_download_image_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadImageCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefDownloadImageCallbackCppToC,
CefDownloadImageCallback, cef_download_image_callback_t>::kWrapperType =
WT_DOWNLOAD_IMAGE_CALLBACK;

6
libcef_dll/cpptoc/download_image_callback_cpptoc.h
View File

@ -22,13 +22,13 @@
#include "include/capi/cef_browser_capi.h"
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDownloadImageCallbackCppToC
: public CefCppToC<CefDownloadImageCallbackCppToC, CefDownloadImageCallback,
cef_download_image_callback_t> {
: public CefCppToCRefCounted<CefDownloadImageCallbackCppToC,
CefDownloadImageCallback, cef_download_image_callback_t> {
public:
CefDownloadImageCallbackCppToC();
};

6
libcef_dll/cpptoc/download_item_callback_cpptoc.cc
View File

@ -64,7 +64,7 @@ CefDownloadItemCallbackCppToC::CefDownloadItemCallbackCppToC() {
GetStruct()->resume = download_item_callback_resume;
}
template<> CefRefPtr<CefDownloadItemCallback> CefCppToC<CefDownloadItemCallbackCppToC,
template<> CefRefPtr<CefDownloadItemCallback> CefCppToCRefCounted<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::UnwrapDerived(
CefWrapperType type, cef_download_item_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -72,10 +72,10 @@ template<> CefRefPtr<CefDownloadItemCallback> CefCppToC<CefDownloadItemCallbackC
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDownloadItemCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadItemCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::kWrapperType =
WT_DOWNLOAD_ITEM_CALLBACK;

6
libcef_dll/cpptoc/download_item_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_download_handler.h"
#include "include/capi/cef_download_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDownloadItemCallbackCppToC
: public CefCppToC<CefDownloadItemCallbackCppToC, CefDownloadItemCallback,
cef_download_item_callback_t> {
: public CefCppToCRefCounted<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t> {
public:
CefDownloadItemCallbackCppToC();
};

8
libcef_dll/cpptoc/download_item_cpptoc.cc
View File

@ -293,7 +293,7 @@ CefDownloadItemCppToC::CefDownloadItemCppToC() {
GetStruct()->get_mime_type = download_item_get_mime_type;
}
template<> CefRefPtr<CefDownloadItem> CefCppToC<CefDownloadItemCppToC,
template<> CefRefPtr<CefDownloadItem> CefCppToCRefCounted<CefDownloadItemCppToC,
CefDownloadItem, cef_download_item_t>::UnwrapDerived(CefWrapperType type,
cef_download_item_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -301,9 +301,9 @@ template<> CefRefPtr<CefDownloadItem> CefCppToC<CefDownloadItemCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDownloadItemCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefDownloadItemCppToC,
CefDownloadItem, cef_download_item_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadItemCppToC, CefDownloadItem,
cef_download_item_t>::kWrapperType = WT_DOWNLOAD_ITEM;
template<> CefWrapperType CefCppToCRefCounted<CefDownloadItemCppToC,
CefDownloadItem, cef_download_item_t>::kWrapperType = WT_DOWNLOAD_ITEM;

4
libcef_dll/cpptoc/download_item_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_download_item.h"
#include "include/capi/cef_download_item_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDownloadItemCppToC
: public CefCppToC<CefDownloadItemCppToC, CefDownloadItem,
: public CefCppToCRefCounted<CefDownloadItemCppToC, CefDownloadItem,
cef_download_item_t> {
public:
CefDownloadItemCppToC();

11
libcef_dll/cpptoc/drag_data_cpptoc.cc
View File

@ -397,16 +397,17 @@ CefDragDataCppToC::CefDragDataCppToC() {
GetStruct()->add_file = drag_data_add_file;
}
template<> CefRefPtr<CefDragData> CefCppToC<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::UnwrapDerived(CefWrapperType type, cef_drag_data_t* s) {
template<> CefRefPtr<CefDragData> CefCppToCRefCounted<CefDragDataCppToC,
CefDragData, cef_drag_data_t>::UnwrapDerived(CefWrapperType type,
cef_drag_data_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefDragDataCppToC,
CefDragData, cef_drag_data_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDragDataCppToC, CefDragData,
template<> CefWrapperType CefCppToCRefCounted<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::kWrapperType = WT_DRAG_DATA;

5
libcef_dll/cpptoc/drag_data_cpptoc.h
View File

@ -20,12 +20,13 @@
#include "include/cef_drag_data.h"
#include "include/capi/cef_drag_data_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefDragDataCppToC
: public CefCppToC<CefDragDataCppToC, CefDragData, cef_drag_data_t> {
: public CefCppToCRefCounted<CefDragDataCppToC, CefDragData,
cef_drag_data_t> {
public:
CefDragDataCppToC();
};

10
libcef_dll/cpptoc/drag_handler_cpptoc.cc
View File

@ -89,7 +89,7 @@ CefDragHandlerCppToC::CefDragHandlerCppToC() {
drag_handler_on_draggable_regions_changed;
}
template<> CefRefPtr<CefDragHandler> CefCppToC<CefDragHandlerCppToC,
template<> CefRefPtr<CefDragHandler> CefCppToCRefCounted<CefDragHandlerCppToC,
CefDragHandler, cef_drag_handler_t>::UnwrapDerived(CefWrapperType type,
cef_drag_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -97,9 +97,9 @@ template<> CefRefPtr<CefDragHandler> CefCppToC<CefDragHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefDragHandlerCppToC,
CefDragHandler, cef_drag_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t>::kWrapperType = WT_DRAG_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefDragHandlerCppToC,
CefDragHandler, cef_drag_handler_t>::kWrapperType = WT_DRAG_HANDLER;

4
libcef_dll/cpptoc/drag_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_drag_handler.h"
#include "include/capi/cef_drag_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefDragHandlerCppToC
: public CefCppToC<CefDragHandlerCppToC, CefDragHandler,
: public CefCppToCRefCounted<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t> {
public:
CefDragHandlerCppToC();

6
libcef_dll/cpptoc/end_tracing_callback_cpptoc.cc
View File

@ -45,7 +45,7 @@ CefEndTracingCallbackCppToC::CefEndTracingCallbackCppToC() {
end_tracing_callback_on_end_tracing_complete;
}
template<> CefRefPtr<CefEndTracingCallback> CefCppToC<CefEndTracingCallbackCppToC,
template<> CefRefPtr<CefEndTracingCallback> CefCppToCRefCounted<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::UnwrapDerived(
CefWrapperType type, cef_end_tracing_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -53,10 +53,10 @@ template<> CefRefPtr<CefEndTracingCallback> CefCppToC<CefEndTracingCallbackCppTo
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefEndTracingCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefEndTracingCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::kWrapperType =
WT_END_TRACING_CALLBACK;

6
libcef_dll/cpptoc/end_tracing_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_trace.h"
#include "include/capi/cef_trace_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefEndTracingCallbackCppToC
: public CefCppToC<CefEndTracingCallbackCppToC, CefEndTracingCallback,
cef_end_tracing_callback_t> {
: public CefCppToCRefCounted<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t> {
public:
CefEndTracingCallbackCppToC();
};

6
libcef_dll/cpptoc/file_dialog_callback_cpptoc.cc
View File

@ -64,7 +64,7 @@ CefFileDialogCallbackCppToC::CefFileDialogCallbackCppToC() {
GetStruct()->cancel = file_dialog_callback_cancel;
}
template<> CefRefPtr<CefFileDialogCallback> CefCppToC<CefFileDialogCallbackCppToC,
template<> CefRefPtr<CefFileDialogCallback> CefCppToCRefCounted<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::UnwrapDerived(
CefWrapperType type, cef_file_dialog_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -72,10 +72,10 @@ template<> CefRefPtr<CefFileDialogCallback> CefCppToC<CefFileDialogCallbackCppTo
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefFileDialogCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFileDialogCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::kWrapperType =
WT_FILE_DIALOG_CALLBACK;

6
libcef_dll/cpptoc/file_dialog_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_dialog_handler.h"
#include "include/capi/cef_dialog_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefFileDialogCallbackCppToC
: public CefCppToC<CefFileDialogCallbackCppToC, CefFileDialogCallback,
cef_file_dialog_callback_t> {
: public CefCppToCRefCounted<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t> {
public:
CefFileDialogCallbackCppToC();
};

10
libcef_dll/cpptoc/find_handler_cpptoc.cc
View File

@ -58,7 +58,7 @@ CefFindHandlerCppToC::CefFindHandlerCppToC() {
GetStruct()->on_find_result = find_handler_on_find_result;
}
template<> CefRefPtr<CefFindHandler> CefCppToC<CefFindHandlerCppToC,
template<> CefRefPtr<CefFindHandler> CefCppToCRefCounted<CefFindHandlerCppToC,
CefFindHandler, cef_find_handler_t>::UnwrapDerived(CefWrapperType type,
cef_find_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -66,9 +66,9 @@ template<> CefRefPtr<CefFindHandler> CefCppToC<CefFindHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefFindHandlerCppToC,
CefFindHandler, cef_find_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t>::kWrapperType = WT_FIND_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefFindHandlerCppToC,
CefFindHandler, cef_find_handler_t>::kWrapperType = WT_FIND_HANDLER;

4
libcef_dll/cpptoc/find_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_find_handler.h"
#include "include/capi/cef_find_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefFindHandlerCppToC
: public CefCppToC<CefFindHandlerCppToC, CefFindHandler,
: public CefCppToCRefCounted<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t> {
public:
CefFindHandlerCppToC();

8
libcef_dll/cpptoc/focus_handler_cpptoc.cc
View File

@ -85,7 +85,7 @@ CefFocusHandlerCppToC::CefFocusHandlerCppToC() {
GetStruct()->on_got_focus = focus_handler_on_got_focus;
}
template<> CefRefPtr<CefFocusHandler> CefCppToC<CefFocusHandlerCppToC,
template<> CefRefPtr<CefFocusHandler> CefCppToCRefCounted<CefFocusHandlerCppToC,
CefFocusHandler, cef_focus_handler_t>::UnwrapDerived(CefWrapperType type,
cef_focus_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -93,9 +93,9 @@ template<> CefRefPtr<CefFocusHandler> CefCppToC<CefFocusHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefFocusHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefFocusHandlerCppToC,
CefFocusHandler, cef_focus_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFocusHandlerCppToC, CefFocusHandler,
cef_focus_handler_t>::kWrapperType = WT_FOCUS_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefFocusHandlerCppToC,
CefFocusHandler, cef_focus_handler_t>::kWrapperType = WT_FOCUS_HANDLER;

4
libcef_dll/cpptoc/focus_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_focus_handler.h"
#include "include/capi/cef_focus_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefFocusHandlerCppToC
: public CefCppToC<CefFocusHandlerCppToC, CefFocusHandler,
: public CefCppToCRefCounted<CefFocusHandlerCppToC, CefFocusHandler,
cef_focus_handler_t> {
public:
CefFocusHandlerCppToC();

6
libcef_dll/cpptoc/frame_cpptoc.cc
View File

@ -397,16 +397,16 @@ CefFrameCppToC::CefFrameCppToC() {
GetStruct()->visit_dom = frame_visit_dom;
}
template<> CefRefPtr<CefFrame> CefCppToC<CefFrameCppToC, CefFrame,
template<> CefRefPtr<CefFrame> CefCppToCRefCounted<CefFrameCppToC, CefFrame,
cef_frame_t>::UnwrapDerived(CefWrapperType type, cef_frame_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefFrameCppToC, CefFrame,
template<> base::AtomicRefCount CefCppToCRefCounted<CefFrameCppToC, CefFrame,
cef_frame_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFrameCppToC, CefFrame,
template<> CefWrapperType CefCppToCRefCounted<CefFrameCppToC, CefFrame,
cef_frame_t>::kWrapperType = WT_FRAME;

4
libcef_dll/cpptoc/frame_cpptoc.h
View File

@ -24,12 +24,12 @@
#include "include/capi/cef_browser_capi.h"
#include "include/cef_v8.h"
#include "include/capi/cef_v8_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefFrameCppToC
: public CefCppToC<CefFrameCppToC, CefFrame, cef_frame_t> {
: public CefCppToCRefCounted<CefFrameCppToC, CefFrame, cef_frame_t> {
public:
CefFrameCppToC();
};

6
libcef_dll/cpptoc/geolocation_callback_cpptoc.cc
View File

@ -39,7 +39,7 @@ CefGeolocationCallbackCppToC::CefGeolocationCallbackCppToC() {
GetStruct()->cont = geolocation_callback_cont;
}
template<> CefRefPtr<CefGeolocationCallback> CefCppToC<CefGeolocationCallbackCppToC,
template<> CefRefPtr<CefGeolocationCallback> CefCppToCRefCounted<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::UnwrapDerived(
CefWrapperType type, cef_geolocation_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -47,10 +47,10 @@ template<> CefRefPtr<CefGeolocationCallback> CefCppToC<CefGeolocationCallbackCpp
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefGeolocationCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefGeolocationCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::kWrapperType =
WT_GEOLOCATION_CALLBACK;

6
libcef_dll/cpptoc/geolocation_callback_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_geolocation_handler.h"
#include "include/capi/cef_geolocation_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefGeolocationCallbackCppToC
: public CefCppToC<CefGeolocationCallbackCppToC, CefGeolocationCallback,
cef_geolocation_callback_t> {
: public CefCppToCRefCounted<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t> {
public:
CefGeolocationCallbackCppToC();
};

6
libcef_dll/cpptoc/geolocation_handler_cpptoc.cc
View File

@ -84,7 +84,7 @@ CefGeolocationHandlerCppToC::CefGeolocationHandlerCppToC() {
geolocation_handler_on_cancel_geolocation_permission;
}
template<> CefRefPtr<CefGeolocationHandler> CefCppToC<CefGeolocationHandlerCppToC,
template<> CefRefPtr<CefGeolocationHandler> CefCppToCRefCounted<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::UnwrapDerived(
CefWrapperType type, cef_geolocation_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -92,10 +92,10 @@ template<> CefRefPtr<CefGeolocationHandler> CefCppToC<CefGeolocationHandlerCppTo
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefGeolocationHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefGeolocationHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::kWrapperType =
WT_GEOLOCATION_HANDLER;

6
libcef_dll/cpptoc/geolocation_handler_cpptoc.h
View File

@ -20,13 +20,13 @@
#include "include/cef_geolocation_handler.h"
#include "include/capi/cef_geolocation_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefGeolocationHandlerCppToC
: public CefCppToC<CefGeolocationHandlerCppToC, CefGeolocationHandler,
cef_geolocation_handler_t> {
: public CefCppToCRefCounted<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t> {
public:
CefGeolocationHandlerCppToC();
};

6
libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc
View File

@ -49,7 +49,7 @@ CefGetGeolocationCallbackCppToC::CefGetGeolocationCallbackCppToC() {
GetStruct()->on_location_update = get_geolocation_callback_on_location_update;
}
template<> CefRefPtr<CefGetGeolocationCallback> CefCppToC<CefGetGeolocationCallbackCppToC,
template<> CefRefPtr<CefGetGeolocationCallback> CefCppToCRefCounted<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t>::UnwrapDerived(
CefWrapperType type, cef_get_geolocation_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -57,11 +57,11 @@ template<> CefRefPtr<CefGetGeolocationCallback> CefCppToC<CefGetGeolocationCallb
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefGetGeolocationCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t>::DebugObjCt =
0;
#endif
template<> CefWrapperType CefCppToC<CefGetGeolocationCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t>::kWrapperType =
WT_GET_GEOLOCATION_CALLBACK;

4
libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_geolocation.h"
#include "include/capi/cef_geolocation_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefGetGeolocationCallbackCppToC
: public CefCppToC<CefGetGeolocationCallbackCppToC,
: public CefCppToCRefCounted<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t> {
public:
CefGetGeolocationCallbackCppToC();

6
libcef_dll/cpptoc/image_cpptoc.cc
View File

@ -388,16 +388,16 @@ CefImageCppToC::CefImageCppToC() {
GetStruct()->get_as_jpeg = image_get_as_jpeg;
}
template<> CefRefPtr<CefImage> CefCppToC<CefImageCppToC, CefImage,
template<> CefRefPtr<CefImage> CefCppToCRefCounted<CefImageCppToC, CefImage,
cef_image_t>::UnwrapDerived(CefWrapperType type, cef_image_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefImageCppToC, CefImage,
template<> base::AtomicRefCount CefCppToCRefCounted<CefImageCppToC, CefImage,
cef_image_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefImageCppToC, CefImage,
template<> CefWrapperType CefCppToCRefCounted<CefImageCppToC, CefImage,
cef_image_t>::kWrapperType = WT_IMAGE;

4
libcef_dll/cpptoc/image_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_image.h"
#include "include/capi/cef_image_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefImageCppToC
: public CefCppToC<CefImageCppToC, CefImage, cef_image_t> {
: public CefCppToCRefCounted<CefImageCppToC, CefImage, cef_image_t> {
public:
CefImageCppToC();
};

6
libcef_dll/cpptoc/jsdialog_callback_cpptoc.cc
View File

@ -41,7 +41,7 @@ CefJSDialogCallbackCppToC::CefJSDialogCallbackCppToC() {
GetStruct()->cont = jsdialog_callback_cont;
}
template<> CefRefPtr<CefJSDialogCallback> CefCppToC<CefJSDialogCallbackCppToC,
template<> CefRefPtr<CefJSDialogCallback> CefCppToCRefCounted<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::UnwrapDerived(
CefWrapperType type, cef_jsdialog_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -49,10 +49,10 @@ template<> CefRefPtr<CefJSDialogCallback> CefCppToC<CefJSDialogCallbackCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefJSDialogCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefJSDialogCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::kWrapperType =
WT_JSDIALOG_CALLBACK;

4
libcef_dll/cpptoc/jsdialog_callback_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_jsdialog_handler.h"
#include "include/capi/cef_jsdialog_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefJSDialogCallbackCppToC
: public CefCppToC<CefJSDialogCallbackCppToC, CefJSDialogCallback,
: public CefCppToCRefCounted<CefJSDialogCallbackCppToC, CefJSDialogCallback,
cef_jsdialog_callback_t> {
public:
CefJSDialogCallbackCppToC();

6
libcef_dll/cpptoc/jsdialog_handler_cpptoc.cc
View File

@ -142,7 +142,7 @@ CefJSDialogHandlerCppToC::CefJSDialogHandlerCppToC() {
GetStruct()->on_dialog_closed = jsdialog_handler_on_dialog_closed;
}
template<> CefRefPtr<CefJSDialogHandler> CefCppToC<CefJSDialogHandlerCppToC,
template<> CefRefPtr<CefJSDialogHandler> CefCppToCRefCounted<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::UnwrapDerived(
CefWrapperType type, cef_jsdialog_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -150,10 +150,10 @@ template<> CefRefPtr<CefJSDialogHandler> CefCppToC<CefJSDialogHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefJSDialogHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefJSDialogHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::kWrapperType =
WT_JSDIALOG_HANDLER;

4
libcef_dll/cpptoc/jsdialog_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_jsdialog_handler.h"
#include "include/capi/cef_jsdialog_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefJSDialogHandlerCppToC
: public CefCppToC<CefJSDialogHandlerCppToC, CefJSDialogHandler,
: public CefCppToCRefCounted<CefJSDialogHandlerCppToC, CefJSDialogHandler,
cef_jsdialog_handler_t> {
public:
CefJSDialogHandlerCppToC();

6
libcef_dll/cpptoc/keyboard_handler_cpptoc.cc
View File

@ -105,7 +105,7 @@ CefKeyboardHandlerCppToC::CefKeyboardHandlerCppToC() {
GetStruct()->on_key_event = keyboard_handler_on_key_event;
}
template<> CefRefPtr<CefKeyboardHandler> CefCppToC<CefKeyboardHandlerCppToC,
template<> CefRefPtr<CefKeyboardHandler> CefCppToCRefCounted<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::UnwrapDerived(
CefWrapperType type, cef_keyboard_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -113,10 +113,10 @@ template<> CefRefPtr<CefKeyboardHandler> CefCppToC<CefKeyboardHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefKeyboardHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefKeyboardHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::kWrapperType =
WT_KEYBOARD_HANDLER;

4
libcef_dll/cpptoc/keyboard_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_keyboard_handler.h"
#include "include/capi/cef_keyboard_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefKeyboardHandlerCppToC
: public CefCppToC<CefKeyboardHandlerCppToC, CefKeyboardHandler,
: public CefCppToCRefCounted<CefKeyboardHandlerCppToC, CefKeyboardHandler,
cef_keyboard_handler_t> {
public:
CefKeyboardHandlerCppToC();

6
libcef_dll/cpptoc/life_span_handler_cpptoc.cc
View File

@ -188,7 +188,7 @@ CefLifeSpanHandlerCppToC::CefLifeSpanHandlerCppToC() {
GetStruct()->on_before_close = life_span_handler_on_before_close;
}
template<> CefRefPtr<CefLifeSpanHandler> CefCppToC<CefLifeSpanHandlerCppToC,
template<> CefRefPtr<CefLifeSpanHandler> CefCppToCRefCounted<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::UnwrapDerived(
CefWrapperType type, cef_life_span_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -196,10 +196,10 @@ template<> CefRefPtr<CefLifeSpanHandler> CefCppToC<CefLifeSpanHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefLifeSpanHandlerCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefLifeSpanHandlerCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::kWrapperType =
WT_LIFE_SPAN_HANDLER;

4
libcef_dll/cpptoc/life_span_handler_cpptoc.h
View File

@ -22,12 +22,12 @@
#include "include/capi/cef_life_span_handler_capi.h"
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefLifeSpanHandlerCppToC
: public CefCppToC<CefLifeSpanHandlerCppToC, CefLifeSpanHandler,
: public CefCppToCRefCounted<CefLifeSpanHandlerCppToC, CefLifeSpanHandler,
cef_life_span_handler_t> {
public:
CefLifeSpanHandlerCppToC();

10
libcef_dll/cpptoc/list_value_cpptoc.cc
View File

@ -540,17 +540,17 @@ CefListValueCppToC::CefListValueCppToC() {
GetStruct()->set_list = list_value_set_list;
}
template<> CefRefPtr<CefListValue> CefCppToC<CefListValueCppToC, CefListValue,
cef_list_value_t>::UnwrapDerived(CefWrapperType type,
template<> CefRefPtr<CefListValue> CefCppToCRefCounted<CefListValueCppToC,
CefListValue, cef_list_value_t>::UnwrapDerived(CefWrapperType type,
cef_list_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefListValueCppToC, CefListValue,
cef_list_value_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefListValueCppToC,
CefListValue, cef_list_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefListValueCppToC, CefListValue,
template<> CefWrapperType CefCppToCRefCounted<CefListValueCppToC, CefListValue,
cef_list_value_t>::kWrapperType = WT_LIST_VALUE;

5
libcef_dll/cpptoc/list_value_cpptoc.h
View File

@ -20,12 +20,13 @@
#include "include/cef_values.h"
#include "include/capi/cef_values_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefListValueCppToC
: public CefCppToC<CefListValueCppToC, CefListValue, cef_list_value_t> {
: public CefCppToCRefCounted<CefListValueCppToC, CefListValue,
cef_list_value_t> {
public:
CefListValueCppToC();
};

10
libcef_dll/cpptoc/load_handler_cpptoc.cc
View File

@ -130,7 +130,7 @@ CefLoadHandlerCppToC::CefLoadHandlerCppToC() {
GetStruct()->on_load_error = load_handler_on_load_error;
}
template<> CefRefPtr<CefLoadHandler> CefCppToC<CefLoadHandlerCppToC,
template<> CefRefPtr<CefLoadHandler> CefCppToCRefCounted<CefLoadHandlerCppToC,
CefLoadHandler, cef_load_handler_t>::UnwrapDerived(CefWrapperType type,
cef_load_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -138,9 +138,9 @@ template<> CefRefPtr<CefLoadHandler> CefCppToC<CefLoadHandlerCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefLoadHandlerCppToC,
CefLoadHandler, cef_load_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t>::kWrapperType = WT_LOAD_HANDLER;
template<> CefWrapperType CefCppToCRefCounted<CefLoadHandlerCppToC,
CefLoadHandler, cef_load_handler_t>::kWrapperType = WT_LOAD_HANDLER;

4
libcef_dll/cpptoc/load_handler_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_load_handler.h"
#include "include/capi/cef_load_handler_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefLoadHandlerCppToC
: public CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
: public CefCppToCRefCounted<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t> {
public:
CefLoadHandlerCppToC();

10
libcef_dll/cpptoc/menu_model_cpptoc.cc
View File

@ -1037,17 +1037,17 @@ CefMenuModelCppToC::CefMenuModelCppToC() {
GetStruct()->get_accelerator_at = menu_model_get_accelerator_at;
}
template<> CefRefPtr<CefMenuModel> CefCppToC<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::UnwrapDerived(CefWrapperType type,
template<> CefRefPtr<CefMenuModel> CefCppToCRefCounted<CefMenuModelCppToC,
CefMenuModel, cef_menu_model_t>::UnwrapDerived(CefWrapperType type,
cef_menu_model_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::DebugObjCt = 0;
template<> base::AtomicRefCount CefCppToCRefCounted<CefMenuModelCppToC,
CefMenuModel, cef_menu_model_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefMenuModelCppToC, CefMenuModel,
template<> CefWrapperType CefCppToCRefCounted<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::kWrapperType = WT_MENU_MODEL;

5
libcef_dll/cpptoc/menu_model_cpptoc.h
View File

@ -20,12 +20,13 @@
#include "include/cef_menu_model.h"
#include "include/capi/cef_menu_model_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefMenuModelCppToC
: public CefCppToC<CefMenuModelCppToC, CefMenuModel, cef_menu_model_t> {
: public CefCppToCRefCounted<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t> {
public:
CefMenuModelCppToC();
};

6
libcef_dll/cpptoc/menu_model_delegate_cpptoc.cc
View File

@ -113,7 +113,7 @@ CefMenuModelDelegateCppToC::CefMenuModelDelegateCppToC() {
GetStruct()->format_label = menu_model_delegate_format_label;
}
template<> CefRefPtr<CefMenuModelDelegate> CefCppToC<CefMenuModelDelegateCppToC,
template<> CefRefPtr<CefMenuModelDelegate> CefCppToCRefCounted<CefMenuModelDelegateCppToC,
CefMenuModelDelegate, cef_menu_model_delegate_t>::UnwrapDerived(
CefWrapperType type, cef_menu_model_delegate_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -121,10 +121,10 @@ template<> CefRefPtr<CefMenuModelDelegate> CefCppToC<CefMenuModelDelegateCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefMenuModelDelegateCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefMenuModelDelegateCppToC,
CefMenuModelDelegate, cef_menu_model_delegate_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefMenuModelDelegateCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefMenuModelDelegateCppToC,
CefMenuModelDelegate, cef_menu_model_delegate_t>::kWrapperType =
WT_MENU_MODEL_DELEGATE;

6
libcef_dll/cpptoc/menu_model_delegate_cpptoc.h
View File

@ -22,13 +22,13 @@
#include "include/capi/cef_menu_model_delegate_capi.h"
#include "include/cef_menu_model.h"
#include "include/capi/cef_menu_model_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefMenuModelDelegateCppToC
: public CefCppToC<CefMenuModelDelegateCppToC, CefMenuModelDelegate,
cef_menu_model_delegate_t> {
: public CefCppToCRefCounted<CefMenuModelDelegateCppToC,
CefMenuModelDelegate, cef_menu_model_delegate_t> {
public:
CefMenuModelDelegateCppToC();
};

6
libcef_dll/cpptoc/navigation_entry_cpptoc.cc
View File

@ -188,7 +188,7 @@ CefNavigationEntryCppToC::CefNavigationEntryCppToC() {
GetStruct()->get_sslstatus = navigation_entry_get_sslstatus;
}
template<> CefRefPtr<CefNavigationEntry> CefCppToC<CefNavigationEntryCppToC,
template<> CefRefPtr<CefNavigationEntry> CefCppToCRefCounted<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::UnwrapDerived(
CefWrapperType type, cef_navigation_entry_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -196,10 +196,10 @@ template<> CefRefPtr<CefNavigationEntry> CefCppToC<CefNavigationEntryCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefNavigationEntryCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefNavigationEntryCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::kWrapperType =
WT_NAVIGATION_ENTRY;

4
libcef_dll/cpptoc/navigation_entry_cpptoc.h
View File

@ -20,12 +20,12 @@
#include "include/cef_navigation_entry.h"
#include "include/capi/cef_navigation_entry_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed DLL-side only.
class CefNavigationEntryCppToC
: public CefCppToC<CefNavigationEntryCppToC, CefNavigationEntry,
: public CefCppToCRefCounted<CefNavigationEntryCppToC, CefNavigationEntry,
cef_navigation_entry_t> {
public:
CefNavigationEntryCppToC();

6
libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.cc
View File

@ -52,7 +52,7 @@ CefNavigationEntryVisitorCppToC::CefNavigationEntryVisitorCppToC() {
GetStruct()->visit = navigation_entry_visitor_visit;
}
template<> CefRefPtr<CefNavigationEntryVisitor> CefCppToC<CefNavigationEntryVisitorCppToC,
template<> CefRefPtr<CefNavigationEntryVisitor> CefCppToCRefCounted<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t>::UnwrapDerived(
CefWrapperType type, cef_navigation_entry_visitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -60,11 +60,11 @@ template<> CefRefPtr<CefNavigationEntryVisitor> CefCppToC<CefNavigationEntryVisi
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefNavigationEntryVisitorCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t>::DebugObjCt =
0;
#endif
template<> CefWrapperType CefCppToC<CefNavigationEntryVisitorCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t>::kWrapperType =
WT_NAVIGATION_ENTRY_VISITOR;

4
libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.h
View File

@ -22,12 +22,12 @@
#include "include/capi/cef_browser_capi.h"
#include "include/cef_client.h"
#include "include/capi/cef_client_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
#include "libcef_dll/cpptoc/cpptoc_ref_counted.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefNavigationEntryVisitorCppToC
: public CefCppToC<CefNavigationEntryVisitorCppToC,
: public CefCppToCRefCounted<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t> {
public:
CefNavigationEntryVisitorCppToC();

6
libcef_dll/cpptoc/pdf_print_callback_cpptoc.cc
View File

@ -44,7 +44,7 @@ CefPdfPrintCallbackCppToC::CefPdfPrintCallbackCppToC() {
GetStruct()->on_pdf_print_finished = pdf_print_callback_on_pdf_print_finished;
}
template<> CefRefPtr<CefPdfPrintCallback> CefCppToC<CefPdfPrintCallbackCppToC,
template<> CefRefPtr<CefPdfPrintCallback> CefCppToCRefCounted<CefPdfPrintCallbackCppToC,
CefPdfPrintCallback, cef_pdf_print_callback_t>::UnwrapDerived(
CefWrapperType type, cef_pdf_print_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
@ -52,10 +52,10 @@ template<> CefRefPtr<CefPdfPrintCallback> CefCppToC<CefPdfPrintCallbackCppToC,
}
#if DCHECK_IS_ON()
template<> base::AtomicRefCount CefCppToC<CefPdfPrintCallbackCppToC,
template<> base::AtomicRefCount CefCppToCRefCounted<CefPdfPrintCallbackCppToC,
CefPdfPrintCallback, cef_pdf_print_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefPdfPrintCallbackCppToC,
template<> CefWrapperType CefCppToCRefCounted<CefPdfPrintCallbackCppToC,
CefPdfPrintCallback, cef_pdf_print_callback_t>::kWrapperType =
WT_PDF_PRINT_CALLBACK;

Some files were not shown because too many files have changed in this diff Show More