mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2025-06-05 21:39:12 +02:00
Add support for non-ref-counted interface classes (issue #2090)
This commit is contained in:
Marshall Greenblatt
241
libcef_dll/cpptoc/cpptoc_scoped.h
Normal file
241
libcef_dll/cpptoc/cpptoc_scoped.h
Normal file
@ -0,0 +1,241 @@
|
||||
// Copyright (c) 2017 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.
|
||||
|
||||
#ifndef CEF_LIBCEF_DLL_CPPTOC_CPPTOC_SCOPED_H_
|
||||
#define CEF_LIBCEF_DLL_CPPTOC_CPPTOC_SCOPED_H_
|
||||
#pragma once
|
||||
|
||||
#include "include/base/cef_logging.h"
|
||||
#include "include/base/cef_macros.h"
|
||||
#include "include/cef_base.h"
|
||||
#include "include/capi/cef_base_capi.h"
|
||||
#include "libcef_dll/ptr_util.h"
|
||||
#include "libcef_dll/wrapper_types.h"
|
||||
|
||||
// Wrap a C++ class with a C structure. This is used when the class
|
||||
// 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 CefCppToCScoped : public CefBaseScoped {
|
||||
public:
|
||||
// Create a new wrapper instance and associated structure reference for
|
||||
// passing an object instance the other side. The wrapper object will be
|
||||
// deleted when |del| is called on the associated structure. The wrapped
|
||||
// object will be deleted when the wrapper object is deleted. For example:
|
||||
//
|
||||
// void MyMethod(CefOwnPtr<MyType> obj) {
|
||||
// my_method(MyTypeCppToC::WrapOwn(obj));
|
||||
// }
|
||||
//
|
||||
// void my_method(my_type_t* struct) {
|
||||
// // Delete the MyTypeCppToC wrapper and the owned MyType object.
|
||||
// struct->del(struct);
|
||||
// }
|
||||
static StructName* WrapOwn(CefOwnPtr<BaseName> c) {
|
||||
if (!c)
|
||||
return NULL;
|
||||
|
||||
// Wrap our object with the CefCppToC class.
|
||||
ClassName* wrapper = new ClassName();
|
||||
wrapper->Initialize(c.release(), true);
|
||||
|
||||
// Return the structure pointer that can now be passed to the other side.
|
||||
return wrapper->GetStruct();
|
||||
}
|
||||
|
||||
// Create a new wrapper instance and associated structure reference for
|
||||
// passing an object instance to the other side. The wrapper object is owned
|
||||
// by the caller. The wrapped object is unowned and must outlive the wrapper.
|
||||
// For example:
|
||||
//
|
||||
// void MyMethod(MyType* obj) {
|
||||
// CefOwnPtr<MyTypeCppToC> MyTypeWrapper = MyTypeCppToC::WrapRaw(obj);
|
||||
// my_method(MyTypeWrapper->GetStruct());
|
||||
// // MyTypeWrapper is deleted when MyMethod() goes out of scope.
|
||||
// }
|
||||
//
|
||||
// void my_method(my_type_t* struct) {
|
||||
// // Access |struct| here but you can't delete it.
|
||||
// }
|
||||
static CefOwnPtr<ClassName> WrapRaw(CefRawPtr<BaseName> c) {
|
||||
if (!c)
|
||||
return CefOwnPtr<ClassName>();
|
||||
|
||||
// Wrap our object with the CefCppToC class.
|
||||
ClassName* wrapper = new ClassName();
|
||||
wrapper->Initialize(c, false);
|
||||
|
||||
// Return the owned wrapper object.
|
||||
return CefOwnPtr<ClassName>(wrapper);
|
||||
}
|
||||
|
||||
// Retrieve the underlying object instance for a structure reference passed
|
||||
// back from the other side. The caller takes ownership of the object. For
|
||||
// example:
|
||||
//
|
||||
// void my_method(my_type_t* struct) {
|
||||
// CefOwnPtr<MyType> MyTypePtr = MyTypeCppToC::UnwrapOwn(struct);
|
||||
// // |struct| has been deleted and should no longer be accessed.
|
||||
// }
|
||||
static CefOwnPtr<BaseName> UnwrapOwn(StructName* s) {
|
||||
if (!s)
|
||||
return CefOwnPtr<BaseName>();
|
||||
|
||||
// Cast our structure to the wrapper structure type.
|
||||
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
|
||||
|
||||
// If the type does not match this object then we need to unwrap as the
|
||||
// derived type.
|
||||
if (wrapperStruct->type_ != kWrapperType)
|
||||
return UnwrapDerivedOwn(wrapperStruct->type_, s);
|
||||
|
||||
// We should own the underlying object currently.
|
||||
DCHECK(wrapperStruct->wrapper_->owned_);
|
||||
DCHECK(wrapperStruct->object_);
|
||||
|
||||
// We're giving up ownership of the underlying object. Clear the pointer so
|
||||
// it doesn't get deleted.
|
||||
BaseName* object = wrapperStruct->object_;
|
||||
wrapperStruct->object_ = NULL;
|
||||
|
||||
delete wrapperStruct->wrapper_;
|
||||
|
||||
// Return the underlying object instance.
|
||||
return CefOwnPtr<BaseName>(object);
|
||||
}
|
||||
|
||||
// Retrieve the underlying object instance for a structure reference passed
|
||||
// back from the other side. Ownership does not change. For example:
|
||||
//
|
||||
// void my_method(my_type_t* struct) {
|
||||
// CefRawPtr<MyType> MyTypePtr = MyTypeCppToC::UnwrapRaw(struct);
|
||||
// // |struct| is still valid.
|
||||
// }
|
||||
static CefRawPtr<BaseName> UnwrapRaw(StructName* s) {
|
||||
if (!s)
|
||||
return NULL;
|
||||
|
||||
// Cast our structure to the wrapper structure type.
|
||||
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
|
||||
|
||||
// If the type does not match this object then we need to unwrap as the
|
||||
// derived type.
|
||||
if (wrapperStruct->type_ != kWrapperType)
|
||||
return UnwrapDerivedRaw(wrapperStruct->type_, s);
|
||||
|
||||
// Return the underlying object instance.
|
||||
return wrapperStruct->object_;
|
||||
}
|
||||
|
||||
// Retrieve the same side wrapper associated with the structure. Ownership
|
||||
// does not change.
|
||||
static ClassName* GetWrapper(StructName* s) {
|
||||
DCHECK(s);
|
||||
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
|
||||
// Verify that the wrapper offset was calculated correctly.
|
||||
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
|
||||
return static_cast<ClassName*>(wrapperStruct->wrapper_);
|
||||
}
|
||||
|
||||
// Retrieve the underlying object instance from our own structure reference
|
||||
// when the reference is passed as the required first parameter of a C API
|
||||
// function call. Ownership of the object does not change.
|
||||
static BaseName* Get(StructName* s) {
|
||||
DCHECK(s);
|
||||
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
|
||||
// Verify that the wrapper offset was calculated correctly.
|
||||
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
|
||||
return wrapperStruct->object_;
|
||||
}
|
||||
|
||||
// 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.
|
||||
StructName* GetStruct() { return &wrapper_struct_.struct_; }
|
||||
|
||||
#if DCHECK_IS_ON()
|
||||
// Simple tracking of allocated objects.
|
||||
static base::AtomicRefCount DebugObjCt; // NOLINT(runtime/int)
|
||||
#endif
|
||||
|
||||
protected:
|
||||
CefCppToCScoped() {
|
||||
wrapper_struct_.type_ = kWrapperType;
|
||||
wrapper_struct_.wrapper_ = this;
|
||||
memset(GetStruct(), 0, sizeof(StructName));
|
||||
|
||||
#if DCHECK_IS_ON()
|
||||
base::AtomicRefCountInc(&DebugObjCt);
|
||||
#endif
|
||||
}
|
||||
|
||||
virtual ~CefCppToCScoped() {
|
||||
// Only delete the underlying object if we own it.
|
||||
if (owned_ && wrapper_struct_.object_)
|
||||
delete wrapper_struct_.object_;
|
||||
|
||||
#if DCHECK_IS_ON()
|
||||
base::AtomicRefCountDec(&DebugObjCt);
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
// Used to associate this wrapper object, the underlying object instance and
|
||||
// the structure that will be passed to the other side.
|
||||
struct WrapperStruct {
|
||||
CefWrapperType type_;
|
||||
BaseName* object_;
|
||||
CefCppToCScoped<ClassName, BaseName, StructName>* wrapper_;
|
||||
StructName struct_;
|
||||
};
|
||||
|
||||
void Initialize(BaseName* obj, bool owned) {
|
||||
wrapper_struct_.object_ = obj;
|
||||
owned_ = owned;
|
||||
|
||||
cef_base_scoped_t* base = reinterpret_cast<cef_base_scoped_t*>(GetStruct());
|
||||
base->size = sizeof(StructName);
|
||||
if (owned)
|
||||
base->del = struct_del;
|
||||
}
|
||||
|
||||
static WrapperStruct* GetWrapperStruct(StructName* s) {
|
||||
// Offset using the WrapperStruct size instead of individual member sizes
|
||||
// to avoid problems due to platform/compiler differences in structure
|
||||
// padding.
|
||||
return reinterpret_cast<WrapperStruct*>(
|
||||
reinterpret_cast<char*>(s) -
|
||||
(sizeof(WrapperStruct) - sizeof(StructName)));
|
||||
}
|
||||
|
||||
// Unwrap as the derived type.
|
||||
static CefOwnPtr<BaseName> UnwrapDerivedOwn(CefWrapperType type,
|
||||
StructName* s);
|
||||
static CefRawPtr<BaseName> UnwrapDerivedRaw(CefWrapperType type,
|
||||
StructName* s);
|
||||
|
||||
static void CEF_CALLBACK struct_del(cef_base_scoped_t* base) {
|
||||
DCHECK(base);
|
||||
if (!base)
|
||||
return;
|
||||
|
||||
WrapperStruct* wrapperStruct =
|
||||
GetWrapperStruct(reinterpret_cast<StructName*>(base));
|
||||
// Verify that the wrapper offset was calculated correctly.
|
||||
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
|
||||
|
||||
// Should only be deleting wrappers that own the underlying object.
|
||||
DCHECK(wrapperStruct->wrapper_->owned_);
|
||||
delete wrapperStruct->wrapper_;
|
||||
}
|
||||
|
||||
WrapperStruct wrapper_struct_;
|
||||
bool owned_;
|
||||
|
||||
static CefWrapperType kWrapperType;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(CefCppToCScoped);
|
||||
};
|
||||
|
||||
#endif // CEF_LIBCEF_DLL_CPPTOC_CPPTOC_SCOPED_H_
|
||||
Reference in New Issue
Block a user