bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-03-09 16:40:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

Apply clang-format to all C, C++ and ObjC files (issue #2171)

Browse Source
This commit is contained in:
Marshall Greenblatt 2017-05-17 11:29:28 +02:00
parent a566549e04
commit 31d9407ee2
1331 changed files with 33014 additions and 32258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cef_paths.gypi
View File

@ -8,6 +8,8 @@
# by hand. See the translator.README.txt file in the tools directory for # by hand. See the translator.README.txt file in the tools directory for
# more information. # more information.
# #
# $hash=9b613878ab9c9f72136f890b1df4a145d6341790$
#
{ {
'variables': { 'variables': {

12
include/base/cef_atomic_ref_count.h
View File

@ -63,7 +63,7 @@ namespace base {
typedef subtle::Atomic32 AtomicRefCount; typedef subtle::Atomic32 AtomicRefCount;
// Increment a reference count by "increment", which must exceed 0. // Increment a reference count by "increment", which must exceed 0.
inline void AtomicRefCountIncN(volatile AtomicRefCount *ptr, inline void AtomicRefCountIncN(volatile AtomicRefCount* ptr,
AtomicRefCount increment) { AtomicRefCount increment) {
subtle::NoBarrier_AtomicIncrement(ptr, increment); subtle::NoBarrier_AtomicIncrement(ptr, increment);
} }
@ -72,7 +72,7 @@ inline void AtomicRefCountIncN(volatile AtomicRefCount *ptr,
// and return whether the result is non-zero. // and return whether the result is non-zero.
// Insert barriers to ensure that state written before the reference count // Insert barriers to ensure that state written before the reference count
// became zero will be visible to a thread that has just made the count zero. // became zero will be visible to a thread that has just made the count zero.
inline bool AtomicRefCountDecN(volatile AtomicRefCount *ptr, inline bool AtomicRefCountDecN(volatile AtomicRefCount* ptr,
AtomicRefCount decrement) { AtomicRefCount decrement) {
ANNOTATE_HAPPENS_BEFORE(ptr); ANNOTATE_HAPPENS_BEFORE(ptr);
bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0); bool res = (subtle::Barrier_AtomicIncrement(ptr, -decrement) != 0);
@ -83,14 +83,14 @@ inline bool AtomicRefCountDecN(volatile AtomicRefCount *ptr,
} }
// Increment a reference count by 1. // Increment a reference count by 1.
inline void AtomicRefCountInc(volatile AtomicRefCount *ptr) { inline void AtomicRefCountInc(volatile AtomicRefCount* ptr) {
base::AtomicRefCountIncN(ptr, 1); base::AtomicRefCountIncN(ptr, 1);
} }
// Decrement a reference count by 1 and return whether the result is non-zero. // Decrement a reference count by 1 and return whether the result is non-zero.
// Insert barriers to ensure that state written before the reference count // Insert barriers to ensure that state written before the reference count
// became zero will be visible to a thread that has just made the count zero. // became zero will be visible to a thread that has just made the count zero.
inline bool AtomicRefCountDec(volatile AtomicRefCount *ptr) { inline bool AtomicRefCountDec(volatile AtomicRefCount* ptr) {
return base::AtomicRefCountDecN(ptr, 1); return base::AtomicRefCountDecN(ptr, 1);
} }
@ -100,7 +100,7 @@ inline bool AtomicRefCountDec(volatile AtomicRefCount *ptr) {
// the test for a reference count of one, and performs the memory barrier // the test for a reference count of one, and performs the memory barrier
// needed for the owning thread to act on the object, knowing that it has // needed for the owning thread to act on the object, knowing that it has
// exclusive access to the object. // exclusive access to the object.
inline bool AtomicRefCountIsOne(volatile AtomicRefCount *ptr) { inline bool AtomicRefCountIsOne(volatile AtomicRefCount* ptr) {
bool res = (subtle::Acquire_Load(ptr) == 1); bool res = (subtle::Acquire_Load(ptr) == 1);
if (res) { if (res) {
ANNOTATE_HAPPENS_AFTER(ptr); ANNOTATE_HAPPENS_AFTER(ptr);
@ -111,7 +111,7 @@ inline bool AtomicRefCountIsOne(volatile AtomicRefCount *ptr) {
// Return whether the reference count is zero. With conventional object // Return whether the reference count is zero. With conventional object
// referencing counting, the object will be destroyed, so the reference count // referencing counting, the object will be destroyed, so the reference count
// should never be zero. Hence this is generally used for a debug check. // should never be zero. Hence this is generally used for a debug check.
inline bool AtomicRefCountIsZero(volatile AtomicRefCount *ptr) { inline bool AtomicRefCountIsZero(volatile AtomicRefCount* ptr) {
bool res = (subtle::Acquire_Load(ptr) == 0); bool res = (subtle::Acquire_Load(ptr) == 0);
if (res) { if (res) {
ANNOTATE_HAPPENS_AFTER(ptr); ANNOTATE_HAPPENS_AFTER(ptr);

3
include/base/cef_atomicops.h
View File

@ -122,8 +122,7 @@ Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
// *ptr with the increment applied. This routine implies no memory barriers. // *ptr with the increment applied. This routine implies no memory barriers.
Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment); Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
Atomic32 increment);
// These following lower-level operations are typically useful only to people // These following lower-level operations are typically useful only to people
// implementing higher-level synchronization operations like spinlocks, // implementing higher-level synchronization operations like spinlocks,

8
include/base/cef_basictypes.h
View File

@ -43,11 +43,11 @@
// On Mac OS X, |long long| is used for 64-bit types for compatibility with // On Mac OS X, |long long| is used for 64-bit types for compatibility with
// <inttypes.h> format macros even in the LP64 model. // <inttypes.h> format macros even in the LP64 model.
#if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) #if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
typedef long int64; // NOLINT(runtime/int) typedef long int64;
typedef unsigned long uint64; // NOLINT(runtime/int) typedef unsigned long uint64;
#else #else
typedef long long int64; // NOLINT(runtime/int) typedef long long int64;
typedef unsigned long long uint64; // NOLINT(runtime/int) typedef unsigned long long uint64;
#endif #endif
// TODO: Remove these type guards. These are to avoid conflicts with // TODO: Remove these type guards. These are to avoid conflicts with

223
include/base/cef_bind.h
View File

@ -89,34 +89,32 @@
namespace base { namespace base {
template <typename Functor> template <typename Functor>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void()> void()>::UnboundRunType>
::UnboundRunType>
Bind(Functor functor) { Bind(Functor functor) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
typedef cef_internal::BindState<RunnableType, RunType, void()> BindState; typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor))); new BindState(cef_internal::MakeRunnable(functor)));
} }
template <typename Functor, typename P1> template <typename Functor, typename P1>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)> void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1) { Bind(Functor functor, const P1& p1) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -131,39 +129,39 @@ Bind(Functor functor, const P1& p1) {
// invoked function will receive a reference to the stored copy of the // invoked function will receive a reference to the stored copy of the
// argument and not the original. // argument and not the original.
COMPILE_ASSERT( COMPILE_ASSERT(
!(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ), !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value, !is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array); first_bound_argument_to_method_cannot_be_array);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)> BindState; RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1)); new BindState(cef_internal::MakeRunnable(functor), p1));
} }
template <typename Functor, typename P1, typename P2> template <typename Functor, typename P1, typename P2>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType)> typename cef_internal::CallbackParamTraits<P2>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2) { Bind(Functor functor, const P1& p1, const P2& p2) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -179,15 +177,14 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
// argument and not the original. // argument and not the original.
COMPILE_ASSERT( COMPILE_ASSERT(
!(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A2Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -195,27 +192,28 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
first_bound_argument_to_method_cannot_be_array); first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr); p2_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P2>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2)); new BindState(cef_internal::MakeRunnable(functor), p1, p2));
} }
template <typename Functor, typename P1, typename P2, typename P3> template <typename Functor, typename P1, typename P2, typename P3>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType)> typename cef_internal::CallbackParamTraits<P3>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) { Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -232,15 +230,14 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
COMPILE_ASSERT( COMPILE_ASSERT(
!(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A3Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -250,29 +247,30 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
p2_is_refcounted_type_and_needs_scoped_refptr); p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr); p3_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P3>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3)); new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
} }
template <typename Functor, typename P1, typename P2, typename P3, typename P4> template <typename Functor, typename P1, typename P2, typename P3, typename P4>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType)> typename cef_internal::CallbackParamTraits<P4>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) { Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -290,15 +288,14 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
!(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value || !(is_non_const_reference<typename BoundFunctorTraits::A1Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A4Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -310,33 +307,42 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
p3_is_refcounted_type_and_needs_scoped_refptr); p3_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
p4_is_refcounted_type_and_needs_scoped_refptr); p4_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P4>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4)); new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4));
} }
template <typename Functor, typename P1, typename P2, typename P3, typename P4, template <typename Functor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5> typename P5>
base::Callback< base::Callback<typename cef_internal::BindState<
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType)> typename cef_internal::CallbackParamTraits<P5>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, Bind(Functor functor,
const P1& p1,
const P2& p2,
const P3& p3,
const P4& p4,
const P5& p5) { const P5& p5) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -355,15 +361,14 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
is_non_const_reference<typename BoundFunctorTraits::A2Type>::value || is_non_const_reference<typename BoundFunctorTraits::A2Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A5Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -377,22 +382,27 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
p4_is_refcounted_type_and_needs_scoped_refptr); p4_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
p5_is_refcounted_type_and_needs_scoped_refptr); p5_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P5>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>( return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5)); new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
} }
template <typename Functor, typename P1, typename P2, typename P3, typename P4, template <typename Functor,
typename P5, typename P6> typename P1,
base::Callback< typename P2,
typename cef_internal::BindState< typename P3,
typename P4,
typename P5,
typename P6>
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@ -400,12 +410,18 @@ base::Callback<
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType, typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType)> typename cef_internal::CallbackParamTraits<P6>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, Bind(Functor functor,
const P5& p5, const P6& p6) { const P1& p1,
const P2& p2,
const P3& p3,
const P4& p4,
const P5& p5,
const P6& p6) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -425,15 +441,14 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
is_non_const_reference<typename BoundFunctorTraits::A3Type>::value || is_non_const_reference<typename BoundFunctorTraits::A3Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A6Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -449,23 +464,29 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
p5_is_refcounted_type_and_needs_scoped_refptr); p5_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
p6_is_refcounted_type_and_needs_scoped_refptr); p6_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType, typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P6>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>(new BindState(
return Callback<typename BindState::UnboundRunType>( cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
} }
template <typename Functor, typename P1, typename P2, typename P3, typename P4, template <typename Functor,
typename P5, typename P6, typename P7> typename P1,
base::Callback< typename P2,
typename cef_internal::BindState< typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType, typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType, typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@ -474,12 +495,19 @@ base::Callback<
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType, typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType, typename cef_internal::CallbackParamTraits<P6>::StorageType,
typename cef_internal::CallbackParamTraits<P7>::StorageType)> typename cef_internal::CallbackParamTraits<P7>::StorageType)>::
::UnboundRunType> UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, Bind(Functor functor,
const P5& p5, const P6& p6, const P7& p7) { const P1& p1,
const P2& p2,
const P3& p3,
const P4& p4,
const P5& p5,
const P6& p6,
const P7& p7) {
// Typedefs for how to store and run the functor. // Typedefs for how to store and run the functor.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType; typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType; typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our // Use RunnableType::RunType instead of RunType above because our
@ -500,15 +528,14 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
is_non_const_reference<typename BoundFunctorTraits::A4Type>::value || is_non_const_reference<typename BoundFunctorTraits::A4Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A5Type>::value || is_non_const_reference<typename BoundFunctorTraits::A5Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A6Type>::value || is_non_const_reference<typename BoundFunctorTraits::A6Type>::value ||
is_non_const_reference<typename BoundFunctorTraits::A7Type>::value ), is_non_const_reference<typename BoundFunctorTraits::A7Type>::value),
do_not_bind_functions_with_nonconst_ref); do_not_bind_functions_with_nonconst_ref);
// For methods, we need to be careful for parameter 1. We do not require // For methods, we need to be careful for parameter 1. We do not require
// a scoped_refptr because BindState<> itself takes care of AddRef() for // a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target // methods. We also disallow binding of an array as the method's target
// object. // object.
COMPILE_ASSERT( COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value, !cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr); p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value || COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
@ -526,19 +553,19 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
p6_is_refcounted_type_and_needs_scoped_refptr); p6_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value, COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
p7_is_refcounted_type_and_needs_scoped_refptr); p7_is_refcounted_type_and_needs_scoped_refptr);
typedef cef_internal::BindState<RunnableType, RunType, typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType, void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType, typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType, typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType, typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType, typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType, typename cef_internal::CallbackParamTraits<P6>::StorageType,
typename cef_internal::CallbackParamTraits<P7>::StorageType)> BindState; typename cef_internal::CallbackParamTraits<P7>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>(new BindState(
return Callback<typename BindState::UnboundRunType>( cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, p7));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
p7));
} }
} // namespace base } // namespace base

63
include/base/cef_bind_helpers.h
View File

@ -274,20 +274,20 @@ class SupportsAddRefAndRelease {
// instantiate Base is made. We disable the warning for this definition. // instantiate Base is made. We disable the warning for this definition.
#if defined(OS_WIN) #if defined(OS_WIN)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4624) #pragma warning(disable : 4624)
#endif #endif
struct Base : public T, public BaseMixin { struct Base : public T, public BaseMixin {};
};
#if defined(OS_WIN) #if defined(OS_WIN)
#pragma warning(pop) #pragma warning(pop)
#endif #endif
template <void(BaseMixin::*)(void)> struct Helper {}; template <void (BaseMixin::*)(void)>
struct Helper {};
template <typename C> template <typename C>
static No& Check(Helper<&C::AddRef>*); static No& Check(Helper<&C::AddRef>*);
template <typename > template <typename>
static Yes& Check(...); static Yes& Check(...);
public: public:
@ -297,22 +297,18 @@ class SupportsAddRefAndRelease {
// Helpers to assert that arguments of a recounted type are bound with a // Helpers to assert that arguments of a recounted type are bound with a
// scoped_refptr. // scoped_refptr.
template <bool IsClasstype, typename T> template <bool IsClasstype, typename T>
struct UnsafeBindtoRefCountedArgHelper : false_type { struct UnsafeBindtoRefCountedArgHelper : false_type {};
};
template <typename T> template <typename T>
struct UnsafeBindtoRefCountedArgHelper<true, T> struct UnsafeBindtoRefCountedArgHelper<true, T>
: integral_constant<bool, SupportsAddRefAndRelease<T>::value> { : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {};
};
template <typename T> template <typename T>
struct UnsafeBindtoRefCountedArg : false_type { struct UnsafeBindtoRefCountedArg : false_type {};
};
template <typename T> template <typename T>
struct UnsafeBindtoRefCountedArg<T*> struct UnsafeBindtoRefCountedArg<T*>
: UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> { : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {};
};
template <typename T> template <typename T>
class HasIsMethodTag { class HasIsMethodTag {
@ -334,6 +330,7 @@ class UnretainedWrapper {
public: public:
explicit UnretainedWrapper(T* o) : ptr_(o) {} explicit UnretainedWrapper(T* o) : ptr_(o) {}
T* get() const { return ptr_; } T* get() const { return ptr_; }
private: private:
T* ptr_; T* ptr_;
}; };
@ -343,6 +340,7 @@ class ConstRefWrapper {
public: public:
explicit ConstRefWrapper(const T& o) : ptr_(&o) {} explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
const T& get() const { return *ptr_; } const T& get() const { return *ptr_; }
private: private:
const T* ptr_; const T* ptr_;
}; };
@ -355,7 +353,7 @@ struct IgnoreResultHelper {
}; };
template <typename T> template <typename T>
struct IgnoreResultHelper<Callback<T> > { struct IgnoreResultHelper<Callback<T>> {
explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {} explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
const Callback<T>& functor_; const Callback<T>& functor_;
@ -409,8 +407,7 @@ class PassedWrapper {
public: public:
explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {} explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
PassedWrapper(const PassedWrapper& other) PassedWrapper(const PassedWrapper& other)
: is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) { : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {}
}
T Pass() const { T Pass() const {
CHECK(is_valid_); CHECK(is_valid_);
is_valid_ = false; is_valid_ = false;
@ -430,7 +427,7 @@ struct UnwrapTraits {
}; };
template <typename T> template <typename T>
struct UnwrapTraits<UnretainedWrapper<T> > { struct UnwrapTraits<UnretainedWrapper<T>> {
typedef T* ForwardType; typedef T* ForwardType;
static ForwardType Unwrap(UnretainedWrapper<T> unretained) { static ForwardType Unwrap(UnretainedWrapper<T> unretained) {
return unretained.get(); return unretained.get();
@ -438,7 +435,7 @@ struct UnwrapTraits<UnretainedWrapper<T> > {
}; };
template <typename T> template <typename T>
struct UnwrapTraits<ConstRefWrapper<T> > { struct UnwrapTraits<ConstRefWrapper<T>> {
typedef const T& ForwardType; typedef const T& ForwardType;
static ForwardType Unwrap(ConstRefWrapper<T> const_ref) { static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {
return const_ref.get(); return const_ref.get();
@ -446,31 +443,27 @@ struct UnwrapTraits<ConstRefWrapper<T> > {
}; };
template <typename T> template <typename T>
struct UnwrapTraits<scoped_refptr<T> > { struct UnwrapTraits<scoped_refptr<T>> {
typedef T* ForwardType; typedef T* ForwardType;
static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); } static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
}; };
template <typename T> template <typename T>
struct UnwrapTraits<WeakPtr<T> > { struct UnwrapTraits<WeakPtr<T>> {
typedef const WeakPtr<T>& ForwardType; typedef const WeakPtr<T>& ForwardType;
static ForwardType Unwrap(const WeakPtr<T>& o) { return o; } static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
}; };
template <typename T> template <typename T>
struct UnwrapTraits<OwnedWrapper<T> > { struct UnwrapTraits<OwnedWrapper<T>> {
typedef T* ForwardType; typedef T* ForwardType;
static ForwardType Unwrap(const OwnedWrapper<T>& o) { static ForwardType Unwrap(const OwnedWrapper<T>& o) { return o.get(); }
return o.get();
}
}; };
template <typename T> template <typename T>
struct UnwrapTraits<PassedWrapper<T> > { struct UnwrapTraits<PassedWrapper<T>> {
typedef T ForwardType; typedef T ForwardType;
static T Unwrap(PassedWrapper<T>& o) { static T Unwrap(PassedWrapper<T>& o) { return o.Pass(); }
return o.Pass();
}
}; };
// Utility for handling different refcounting semantics in the Bind() // Utility for handling different refcounting semantics in the Bind()
@ -505,7 +498,7 @@ struct MaybeRefcount<true, T*> {
// No need to additionally AddRef() and Release() since we are storing a // No need to additionally AddRef() and Release() since we are storing a
// scoped_refptr<> inside the storage object already. // scoped_refptr<> inside the storage object already.
template <typename T> template <typename T>
struct MaybeRefcount<true, scoped_refptr<T> > { struct MaybeRefcount<true, scoped_refptr<T>> {
static void AddRef(const scoped_refptr<T>& o) {} static void AddRef(const scoped_refptr<T>& o) {}
static void Release(const scoped_refptr<T>& o) {} static void Release(const scoped_refptr<T>& o) {}
}; };
@ -526,10 +519,10 @@ template <bool IsMethod, typename P1>
struct IsWeakMethod : public false_type {}; struct IsWeakMethod : public false_type {};
template <typename T> template <typename T>
struct IsWeakMethod<true, WeakPtr<T> > : public true_type {}; struct IsWeakMethod<true, WeakPtr<T>> : public true_type {};
template <typename T> template <typename T>
struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {}; struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T>>> : public true_type {};
} // namespace cef_internal } // namespace cef_internal
@ -567,14 +560,14 @@ static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
} }
template <typename T> template <typename T>
static inline cef_internal::IgnoreResultHelper<Callback<T> > static inline cef_internal::IgnoreResultHelper<Callback<T>> IgnoreResult(
IgnoreResult(const Callback<T>& data) { const Callback<T>& data) {
return cef_internal::IgnoreResultHelper<Callback<T> >(data); return cef_internal::IgnoreResultHelper<Callback<T>>(data);
} }
void DoNothing(); void DoNothing();
template<typename T> template <typename T>
void DeletePointer(T* obj) { void DeletePointer(T* obj) {
delete obj; delete obj;
} }

10
include/base/cef_build.h
View File

@ -27,7 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_ #ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
#define CEF_INCLUDE_BASE_CEF_BUILD_H_ #define CEF_INCLUDE_BASE_CEF_BUILD_H_
#pragma once #pragma once
@ -116,12 +115,10 @@
// Type detection for wchar_t. // Type detection for wchar_t.
#if defined(OS_WIN) #if defined(OS_WIN)
#define WCHAR_T_IS_UTF16 #define WCHAR_T_IS_UTF16
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \ #elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
defined(__WCHAR_MAX__) && \
(__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff) (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
#define WCHAR_T_IS_UTF32 #define WCHAR_T_IS_UTF32
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \ #elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
defined(__WCHAR_MAX__) && \
(__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff) (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
// On Posix, we'll detect short wchar_t, but projects aren't guaranteed to // On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
// compile in this mode (in particular, Chrome doesn't). This is intended for // compile in this mode (in particular, Chrome doesn't). This is intended for
@ -191,8 +188,7 @@
// Check for C++11 template alias support which was added in VS2013 and GCC4.7. // Check for C++11 template alias support which was added in VS2013 and GCC4.7.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
#if __cplusplus > 199711L || \ #if __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER >= 1800) || \
(defined(_MSC_VER) && _MSC_VER >= 1800) || \
(defined(__GNUC__) && \ (defined(__GNUC__) && \
(__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ >= 40700)) (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ >= 40700))
#define HAS_CPP11_TEMPLATE_ALIAS_SUPPORT #define HAS_CPP11_TEMPLATE_ALIAS_SUPPORT

174
include/base/cef_callback.h
View File

@ -45,9 +45,9 @@
// If the Chromium implementation diverges the below implementation should be // If the Chromium implementation diverges the below implementation should be
// updated to match. // updated to match.
#include "include/base/internal/cef_callback_internal.h"
#include "include/base/cef_callback_forward.h" #include "include/base/cef_callback_forward.h"
#include "include/base/cef_template_util.h" #include "include/base/cef_template_util.h"
#include "include/base/internal/cef_callback_internal.h"
// NOTE: Header files that do not require the full definition of Callback or // NOTE: Header files that do not require the full definition of Callback or
// Closure should #include "base/cef_callback_forward.h" instead of this file. // Closure should #include "base/cef_callback_forward.h" instead of this file.
@ -407,21 +407,20 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(); typedef R(RunType)();
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -437,9 +436,7 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(cef_internal::BindStateBase*);
cef_internal::BindStateBase*);
}; };
template <typename R, typename A1> template <typename R, typename A1>
@ -447,21 +444,20 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1); typedef R(RunType)(A1);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -477,10 +473,9 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType); typename cef_internal::CallbackParamTraits<A1>::ForwardType);
}; };
template <typename R, typename A1, typename A2> template <typename R, typename A1, typename A2>
@ -488,21 +483,20 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2); typedef R(RunType)(A1, A2);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -520,11 +514,10 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType); typename cef_internal::CallbackParamTraits<A2>::ForwardType);
}; };
template <typename R, typename A1, typename A2, typename A3> template <typename R, typename A1, typename A2, typename A3>
@ -532,21 +525,20 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2, A3); typedef R(RunType)(A1, A2, A3);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -566,12 +558,11 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType, typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType); typename cef_internal::CallbackParamTraits<A3>::ForwardType);
}; };
template <typename R, typename A1, typename A2, typename A3, typename A4> template <typename R, typename A1, typename A2, typename A3, typename A4>
@ -579,21 +570,20 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2, A3, A4); typedef R(RunType)(A1, A2, A3, A4);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -615,36 +605,38 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType, typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType, typename cef_internal::CallbackParamTraits<A3>::ForwardType,
typename cef_internal::CallbackParamTraits<A4>::ForwardType); typename cef_internal::CallbackParamTraits<A4>::ForwardType);
}; };
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5> typename A5>
class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase { class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2, A3, A4, A5); typedef R(RunType)(A1, A2, A3, A4, A5);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -660,45 +652,47 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
PolymorphicInvoke f = PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1), return f(
cef_internal::CallbackForward(a2), bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5));
cef_internal::CallbackForward(a5));
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType, typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType, typename cef_internal::CallbackParamTraits<A3>::ForwardType,
typename cef_internal::CallbackParamTraits<A4>::ForwardType, typename cef_internal::CallbackParamTraits<A4>::ForwardType,
typename cef_internal::CallbackParamTraits<A5>::ForwardType); typename cef_internal::CallbackParamTraits<A5>::ForwardType);
}; };
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6> typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase { class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2, A3, A4, A5, A6); typedef R(RunType)(A1, A2, A3, A4, A5, A6);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -715,16 +709,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
PolymorphicInvoke f = PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1), return f(
cef_internal::CallbackForward(a2), bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a6)); cef_internal::CallbackForward(a6));
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType, typename cef_internal::CallbackParamTraits<A2>::ForwardType,
@ -732,30 +725,35 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
typename cef_internal::CallbackParamTraits<A4>::ForwardType, typename cef_internal::CallbackParamTraits<A4>::ForwardType,
typename cef_internal::CallbackParamTraits<A5>::ForwardType, typename cef_internal::CallbackParamTraits<A5>::ForwardType,
typename cef_internal::CallbackParamTraits<A6>::ForwardType); typename cef_internal::CallbackParamTraits<A6>::ForwardType);
}; };
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6, typename A7> typename A1,
class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBase { typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class Callback<R(A1, A2, A3, A4, A5, A6, A7)>
: public cef_internal::CallbackBase {
public: public:
typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7); typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
Callback() : CallbackBase(NULL) { } Callback() : CallbackBase(NULL) {}
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details. // return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType> template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType, Callback(
BoundArgsType>* bind_state) cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) { : CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke // Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has // so the compiler will typecheck that the passed in Run() method has
// the correct type. // the correct type.
PolymorphicInvoke invoke_func = PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType> &cef_internal::BindState<Runnable, BindRunType,
::InvokerType::Run; BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func); polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
} }
@ -773,17 +771,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
PolymorphicInvoke f = PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_); reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1), return f(
cef_internal::CallbackForward(a2), bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a3), cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a5), cef_internal::CallbackForward(a6), cef_internal::CallbackForward(a7));
cef_internal::CallbackForward(a6),
cef_internal::CallbackForward(a7));
} }
private: private:
typedef R(*PolymorphicInvoke)( typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*, cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType, typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType, typename cef_internal::CallbackParamTraits<A2>::ForwardType,
@ -792,10 +788,8 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
typename cef_internal::CallbackParamTraits<A5>::ForwardType, typename cef_internal::CallbackParamTraits<A5>::ForwardType,
typename cef_internal::CallbackParamTraits<A6>::ForwardType, typename cef_internal::CallbackParamTraits<A6>::ForwardType,
typename cef_internal::CallbackParamTraits<A7>::ForwardType); typename cef_internal::CallbackParamTraits<A7>::ForwardType);
}; };
// Syntactic sugar to make Callbacks<void(void)> easier to declare since it // Syntactic sugar to make Callbacks<void(void)> easier to declare since it
// will be used in a lot of APIs with delayed execution. // will be used in a lot of APIs with delayed execution.
typedef Callback<void(void)> Closure; typedef Callback<void(void)> Closure;

57
include/base/cef_callback_list.h
View File

@ -48,12 +48,12 @@
#include <list> #include <list>
#include "include/base/cef_basictypes.h" #include "include/base/cef_basictypes.h"
#include "include/base/cef_callback.h"
#include "include/base/internal/cef_callback_internal.h"
#include "include/base/cef_build.h" #include "include/base/cef_build.h"
#include "include/base/cef_callback.h"
#include "include/base/cef_logging.h" #include "include/base/cef_logging.h"
#include "include/base/cef_macros.h" #include "include/base/cef_macros.h"
#include "include/base/cef_scoped_ptr.h" #include "include/base/cef_scoped_ptr.h"
#include "include/base/internal/cef_callback_internal.h"
// OVERVIEW: // OVERVIEW:
// //
@ -120,9 +120,7 @@ class CallbackListBase {
public: public:
Subscription(CallbackListBase<CallbackType>* list, Subscription(CallbackListBase<CallbackType>* list,
typename std::list<CallbackType>::iterator iter) typename std::list<CallbackType>::iterator iter)
: list_(list), : list_(list), iter_(iter) {}
iter_(iter) {
}
~Subscription() { ~Subscription() {
if (list_->active_iterator_count_) { if (list_->active_iterator_count_) {
@ -167,14 +165,12 @@ class CallbackListBase {
class Iterator { class Iterator {
public: public:
explicit Iterator(CallbackListBase<CallbackType>* list) explicit Iterator(CallbackListBase<CallbackType>* list)
: list_(list), : list_(list), list_iter_(list_->callbacks_.begin()) {
list_iter_(list_->callbacks_.begin()) {
++list_->active_iterator_count_; ++list_->active_iterator_count_;
} }
Iterator(const Iterator& iter) Iterator(const Iterator& iter)
: list_(iter.list_), : list_(iter.list_), list_iter_(iter.list_iter_) {
list_iter_(iter.list_iter_) {
++list_->active_iterator_count_; ++list_->active_iterator_count_;
} }
@ -210,9 +206,7 @@ class CallbackListBase {
// Returns an instance of a CallbackListBase::Iterator which can be used // Returns an instance of a CallbackListBase::Iterator which can be used
// to run callbacks. // to run callbacks.
Iterator GetIterator() { Iterator GetIterator() { return Iterator(this); }
return Iterator(this);
}
// Compact the list: remove any entries which were NULLed out during // Compact the list: remove any entries which were NULLed out during
// iteration. // iteration.
@ -242,11 +236,12 @@ class CallbackListBase {
} // namespace cef_internal } // namespace cef_internal
template <typename Sig> class CallbackList; template <typename Sig>
class CallbackList;
template <> template <>
class CallbackList<void(void)> class CallbackList<void(void)>
: public cef_internal::CallbackListBase<Callback<void(void)> > { : public cef_internal::CallbackListBase<Callback<void(void)>> {
public: public:
typedef Callback<void(void)> CallbackType; typedef Callback<void(void)> CallbackType;
@ -267,7 +262,7 @@ class CallbackList<void(void)>
template <typename A1> template <typename A1>
class CallbackList<void(A1)> class CallbackList<void(A1)>
: public cef_internal::CallbackListBase<Callback<void(A1)> > { : public cef_internal::CallbackListBase<Callback<void(A1)>> {
public: public:
typedef Callback<void(A1)> CallbackType; typedef Callback<void(A1)> CallbackType;
@ -288,7 +283,7 @@ class CallbackList<void(A1)>
template <typename A1, typename A2> template <typename A1, typename A2>
class CallbackList<void(A1, A2)> class CallbackList<void(A1, A2)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2)> > { : public cef_internal::CallbackListBase<Callback<void(A1, A2)>> {
public: public:
typedef Callback<void(A1, A2)> CallbackType; typedef Callback<void(A1, A2)> CallbackType;
@ -310,7 +305,7 @@ class CallbackList<void(A1, A2)>
template <typename A1, typename A2, typename A3> template <typename A1, typename A2, typename A3>
class CallbackList<void(A1, A2, A3)> class CallbackList<void(A1, A2, A3)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)> > { : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)>> {
public: public:
typedef Callback<void(A1, A2, A3)> CallbackType; typedef Callback<void(A1, A2, A3)> CallbackType;
@ -333,7 +328,7 @@ class CallbackList<void(A1, A2, A3)>
template <typename A1, typename A2, typename A3, typename A4> template <typename A1, typename A2, typename A3, typename A4>
class CallbackList<void(A1, A2, A3, A4)> class CallbackList<void(A1, A2, A3, A4)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > { : public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)>> {
public: public:
typedef Callback<void(A1, A2, A3, A4)> CallbackType; typedef Callback<void(A1, A2, A3, A4)> CallbackType;
@ -357,7 +352,8 @@ class CallbackList<void(A1, A2, A3, A4)>
template <typename A1, typename A2, typename A3, typename A4, typename A5> template <typename A1, typename A2, typename A3, typename A4, typename A5>
class CallbackList<void(A1, A2, A3, A4, A5)> class CallbackList<void(A1, A2, A3, A4, A5)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5)> > { : public cef_internal::CallbackListBase<
Callback<void(A1, A2, A3, A4, A5)>> {
public: public:
typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType; typedef Callback<void(A1, A2, A3, A4, A5)> CallbackType;
@ -380,11 +376,15 @@ class CallbackList<void(A1, A2, A3, A4, A5)>
DISALLOW_COPY_AND_ASSIGN(CallbackList); DISALLOW_COPY_AND_ASSIGN(CallbackList);
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6> typename A6>
class CallbackList<void(A1, A2, A3, A4, A5, A6)> class CallbackList<void(A1, A2, A3, A4, A5, A6)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, : public cef_internal::CallbackListBase<
A6)> > { Callback<void(A1, A2, A3, A4, A5, A6)>> {
public: public:
typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType; typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
@ -408,11 +408,16 @@ class CallbackList<void(A1, A2, A3, A4, A5, A6)>
DISALLOW_COPY_AND_ASSIGN(CallbackList); DISALLOW_COPY_AND_ASSIGN(CallbackList);
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1,
typename A6, typename A7> typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)> class CallbackList<void(A1, A2, A3, A4, A5, A6, A7)>
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, A6, : public cef_internal::CallbackListBase<
A7)> > { Callback<void(A1, A2, A3, A4, A5, A6, A7)>> {
public: public:
typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType; typedef Callback<void(A1, A2, A3, A4, A5, A6, A7)> CallbackType;

53
include/base/cef_cancelable_callback.h
View File

@ -83,8 +83,8 @@
// updated to match. // updated to match.
#include "include/base/cef_bind.h" #include "include/base/cef_bind.h"
#include "include/base/cef_callback.h"
#include "include/base/cef_build.h" #include "include/base/cef_build.h"
#include "include/base/cef_callback.h"
#include "include/base/cef_logging.h" #include "include/base/cef_logging.h"
#include "include/base/cef_macros.h" #include "include/base/cef_macros.h"
#include "include/base/cef_weak_ptr.h" #include "include/base/cef_weak_ptr.h"
@ -102,8 +102,7 @@ class CancelableCallback<void(void)> {
// |callback| must not be null. // |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(void)>& callback) explicit CancelableCallback(const base::Callback<void(void)>& callback)
: weak_factory_(this), : weak_factory_(this), callback_(callback) {
callback_(callback) {
DCHECK(!callback.is_null()); DCHECK(!callback.is_null());
InitializeForwarder(); InitializeForwarder();
} }
@ -118,9 +117,7 @@ class CancelableCallback<void(void)> {
} }
// Returns true if the wrapped callback has been cancelled. // Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const { bool IsCancelled() const { return callback_.is_null(); }
return callback_.is_null();
}
// Sets |callback| as the closure that may be cancelled. |callback| may not // Sets |callback| as the closure that may be cancelled. |callback| may not
// be null. Outstanding and any previously wrapped callbacks are cancelled. // be null. Outstanding and any previously wrapped callbacks are cancelled.
@ -137,14 +134,10 @@ class CancelableCallback<void(void)> {
} }
// Returns a callback that can be disabled by calling Cancel(). // Returns a callback that can be disabled by calling Cancel().
const base::Callback<void(void)>& callback() const { const base::Callback<void(void)>& callback() const { return forwarder_; }
return forwarder_;
}
private: private:
void Forward() { void Forward() { callback_.Run(); }
callback_.Run();
}
// Helper method to bind |forwarder_| using a weak pointer from // Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|. // |weak_factory_|.
@ -154,7 +147,7 @@ class CancelableCallback<void(void)> {
} }
// Used to ensure Forward() is not run when this object is destroyed. // Used to ensure Forward() is not run when this object is destroyed.
base::WeakPtrFactory<CancelableCallback<void(void)> > weak_factory_; base::WeakPtrFactory<CancelableCallback<void(void)>> weak_factory_;
// The wrapper closure. // The wrapper closure.
base::Callback<void(void)> forwarder_; base::Callback<void(void)> forwarder_;
@ -172,8 +165,7 @@ class CancelableCallback<void(A1)> {
// |callback| must not be null. // |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(A1)>& callback) explicit CancelableCallback(const base::Callback<void(A1)>& callback)
: weak_factory_(this), : weak_factory_(this), callback_(callback) {
callback_(callback) {
DCHECK(!callback.is_null()); DCHECK(!callback.is_null());
InitializeForwarder(); InitializeForwarder();
} }
@ -188,9 +180,7 @@ class CancelableCallback<void(A1)> {
} }
// Returns true if the wrapped callback has been cancelled. // Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const { bool IsCancelled() const { return callback_.is_null(); }
return callback_.is_null();
}
// Sets |callback| as the closure that may be cancelled. |callback| may not // Sets |callback| as the closure that may be cancelled. |callback| may not
// be null. Outstanding and any previously wrapped callbacks are cancelled. // be null. Outstanding and any previously wrapped callbacks are cancelled.
@ -207,14 +197,10 @@ class CancelableCallback<void(A1)> {
} }
// Returns a callback that can be disabled by calling Cancel(). // Returns a callback that can be disabled by calling Cancel().
const base::Callback<void(A1)>& callback() const { const base::Callback<void(A1)>& callback() const { return forwarder_; }
return forwarder_;
}
private: private:
void Forward(A1 a1) const { void Forward(A1 a1) const { callback_.Run(a1); }
callback_.Run(a1);
}
// Helper method to bind |forwarder_| using a weak pointer from // Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|. // |weak_factory_|.
@ -224,7 +210,7 @@ class CancelableCallback<void(A1)> {
} }
// Used to ensure Forward() is not run when this object is destroyed. // Used to ensure Forward() is not run when this object is destroyed.
base::WeakPtrFactory<CancelableCallback<void(A1)> > weak_factory_; base::WeakPtrFactory<CancelableCallback<void(A1)>> weak_factory_;
// The wrapper closure. // The wrapper closure.
base::Callback<void(A1)> forwarder_; base::Callback<void(A1)> forwarder_;
@ -242,8 +228,7 @@ class CancelableCallback<void(A1, A2)> {
// |callback| must not be null. // |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback) explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
: weak_factory_(this), : weak_factory_(this), callback_(callback) {
callback_(callback) {
DCHECK(!callback.is_null()); DCHECK(!callback.is_null());
InitializeForwarder(); InitializeForwarder();
} }
@ -258,9 +243,7 @@ class CancelableCallback<void(A1, A2)> {
} }
// Returns true if the wrapped callback has been cancelled. // Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const { bool IsCancelled() const { return callback_.is_null(); }
return callback_.is_null();
}
// Sets |callback| as the closure that may be cancelled. |callback| may not // Sets |callback| as the closure that may be cancelled. |callback| may not
// be null. Outstanding and any previously wrapped callbacks are cancelled. // be null. Outstanding and any previously wrapped callbacks are cancelled.
@ -277,14 +260,10 @@ class CancelableCallback<void(A1, A2)> {
} }
// Returns a callback that can be disabled by calling Cancel(). // Returns a callback that can be disabled by calling Cancel().
const base::Callback<void(A1, A2)>& callback() const { const base::Callback<void(A1, A2)>& callback() const { return forwarder_; }
return forwarder_;
}
private: private:
void Forward(A1 a1, A2 a2) const { void Forward(A1 a1, A2 a2) const { callback_.Run(a1, a2); }
callback_.Run(a1, a2);
}
// Helper method to bind |forwarder_| using a weak pointer from // Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|. // |weak_factory_|.
@ -294,7 +273,7 @@ class CancelableCallback<void(A1, A2)> {
} }
// Used to ensure Forward() is not run when this object is destroyed. // Used to ensure Forward() is not run when this object is destroyed.
base::WeakPtrFactory<CancelableCallback<void(A1, A2)> > weak_factory_; base::WeakPtrFactory<CancelableCallback<void(A1, A2)>> weak_factory_;
// The wrapper closure. // The wrapper closure.
base::Callback<void(A1, A2)> forwarder_; base::Callback<void(A1, A2)> forwarder_;

8
include/base/cef_lock.h
View File

@ -125,9 +125,7 @@ class AutoLock {
public: public:
struct AlreadyAcquired {}; struct AlreadyAcquired {};
explicit AutoLock(Lock& lock) : lock_(lock) { explicit AutoLock(Lock& lock) : lock_(lock) { lock_.Acquire(); }
lock_.Acquire();
}
AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) { AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
lock_.AssertAcquired(); lock_.AssertAcquired();
@ -153,9 +151,7 @@ class AutoUnlock {
lock_.Release(); lock_.Release();
} }
~AutoUnlock() { ~AutoUnlock() { lock_.Acquire(); }
lock_.Acquire();
}
private: private:
Lock& lock_; Lock& lock_;

164
include/base/cef_logging.h
View File

@ -158,9 +158,9 @@
// updated to match. // updated to match.
#include <cassert> #include <cassert>
#include <string>
#include <cstring> #include <cstring>
#include <sstream> #include <sstream>
#include <string>
#include "include/base/cef_build.h" #include "include/base/cef_build.h"
#include "include/base/cef_macros.h" #include "include/base/cef_macros.h"
@ -202,31 +202,26 @@ const LogSeverity LOG_DFATAL = LOG_FATAL;
// by LOG() and LOG_IF, etc. Since these are used all over our code, it's // by LOG() and LOG_IF, etc. Since these are used all over our code, it's
// better to have compact code for these operations. // better to have compact code for these operations.
#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO , \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_INFO, \
##__VA_ARGS__) ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING , \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_WARNING, \
##__VA_ARGS__) ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR , \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_ERROR, \
##__VA_ARGS__) ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL , \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_FATAL, \
##__VA_ARGS__) ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL , \ cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL, \
##__VA_ARGS__) ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_INFO \ #define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
COMPACT_GOOGLE_LOG_EX_INFO(LogMessage) #define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
#define COMPACT_GOOGLE_LOG_WARNING \ #define COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage) #define COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
#define COMPACT_GOOGLE_LOG_ERROR \ #define COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
#define COMPACT_GOOGLE_LOG_FATAL \
COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
#define COMPACT_GOOGLE_LOG_DFATAL \
COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
#if defined(OS_WIN) #if defined(OS_WIN)
// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets // wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
@ -236,7 +231,7 @@ const LogSeverity LOG_DFATAL = LOG_FATAL;
// the Windows SDK does for consistency. // the Windows SDK does for consistency.
#define ERROR 0 #define ERROR 0
#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__) COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR #define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
// Needed for LOG_IS_ON(ERROR). // Needed for LOG_IS_ON(ERROR).
const LogSeverity LOG_0 = LOG_ERROR; const LogSeverity LOG_0 = LOG_ERROR;
@ -246,7 +241,7 @@ const LogSeverity LOG_0 = LOG_ERROR;
// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will // LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
// always fire if they fail. // always fire if they fail.
#define LOG_IS_ON(severity) \ #define LOG_IS_ON(severity) \
((::cef::logging::LOG_ ## severity) >= ::cef::logging::GetMinLogLevel()) ((::cef::logging::LOG_##severity) >= ::cef::logging::GetMinLogLevel())
// We can't do any caching tricks with VLOG_IS_ON() like the // We can't do any caching tricks with VLOG_IS_ON() like the
// google-glog version since it requires GCC extensions. This means // google-glog version since it requires GCC extensions. This means
@ -258,7 +253,7 @@ const LogSeverity LOG_0 = LOG_ERROR;
// Helper macro which avoids evaluating the arguments to a stream if // Helper macro which avoids evaluating the arguments to a stream if
// the condition doesn't hold. // the condition doesn't hold.
#define LAZY_STREAM(stream, condition) \ #define LAZY_STREAM(stream, condition) \
!(condition) ? (void) 0 : ::cef::logging::LogMessageVoidify() & (stream) !(condition) ? (void)0 : ::cef::logging::LogMessageVoidify() & (stream)
// We use the preprocessor's merging operator, "##", so that, e.g., // We use the preprocessor's merging operator, "##", so that, e.g.,
// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny // LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny
@ -268,7 +263,7 @@ const LogSeverity LOG_0 = LOG_ERROR;
// impossible to stream something like a string directly to an unnamed // impossible to stream something like a string directly to an unnamed
// ostream. We employ a neat hack by calling the stream() member // ostream. We employ a neat hack by calling the stream() member
// function of LogMessage which seems to avoid the problem. // function of LogMessage which seems to avoid the problem.
#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream() #define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_##severity.stream()
#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity)) #define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
#define LOG_IF(severity, condition) \ #define LOG_IF(severity, condition) \
@ -288,14 +283,16 @@ const LogSeverity LOG_0 = LOG_ERROR;
LAZY_STREAM(VLOG_STREAM(verbose_level), \ LAZY_STREAM(VLOG_STREAM(verbose_level), \
VLOG_IS_ON(verbose_level) && (condition)) VLOG_IS_ON(verbose_level) && (condition))
#if defined (OS_WIN) #if defined(OS_WIN)
#define VPLOG_STREAM(verbose_level) \ #define VPLOG_STREAM(verbose_level) \
cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \ cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
::cef::logging::GetLastSystemErrorCode()).stream() ::cef::logging::GetLastSystemErrorCode()) \
.stream()
#elif defined(OS_POSIX) #elif defined(OS_POSIX)
#define VPLOG_STREAM(verbose_level) \ #define VPLOG_STREAM(verbose_level) \
cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \ cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
::cef::logging::GetLastSystemErrorCode()).stream() ::cef::logging::GetLastSystemErrorCode()) \
.stream()
#endif #endif
#define VPLOG(verbose_level) \ #define VPLOG(verbose_level) \
@ -314,23 +311,24 @@ const LogSeverity LOG_0 = LOG_ERROR;
#if defined(OS_WIN) #if defined(OS_WIN)
#define PLOG_STREAM(severity) \ #define PLOG_STREAM(severity) \
COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \ COMPACT_GOOGLE_LOG_EX_##severity(Win32ErrorLogMessage, \
::cef::logging::GetLastSystemErrorCode()).stream() ::cef::logging::GetLastSystemErrorCode()) \
.stream()
#elif defined(OS_POSIX) #elif defined(OS_POSIX)
#define PLOG_STREAM(severity) \ #define PLOG_STREAM(severity) \
COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \ COMPACT_GOOGLE_LOG_EX_##severity(ErrnoLogMessage, \
::cef::logging::GetLastSystemErrorCode()).stream() ::cef::logging::GetLastSystemErrorCode()) \
.stream()
#endif #endif
#define PLOG(severity) \ #define PLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
#define PLOG_IF(severity, condition) \ #define PLOG_IF(severity, condition) \
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
// The actual stream used isn't important. // The actual stream used isn't important.
#define EAT_STREAM_PARAMETERS \ #define EAT_STREAM_PARAMETERS \
true ? (void) 0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL) true ? (void)0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
// CHECK dies with a fatal error if condition is not true. It is *not* // CHECK dies with a fatal error if condition is not true. It is *not*
// controlled by NDEBUG, so the check will be executed regardless of // controlled by NDEBUG, so the check will be executed regardless of
@ -353,16 +351,15 @@ const LogSeverity LOG_0 = LOG_ERROR;
// TODO(akalin): Rewrite this so that constructs like if (...) // TODO(akalin): Rewrite this so that constructs like if (...)
// CHECK_EQ(...) else { ... } work properly. // CHECK_EQ(...) else { ... } work properly.
#define CHECK_OP(name, op, val1, val2) \ #define CHECK_OP(name, op, val1, val2) \
if (std::string* _result = \ if (std::string* _result = cef::logging::Check##name##Impl( \
cef::logging::Check##name##Impl((val1), (val2), \ (val1), (val2), #val1 " " #op " " #val2)) \
#val1 " " #op " " #val2)) \
cef::logging::LogMessage(__FILE__, __LINE__, _result).stream() cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()
// Build the error message string. This is separate from the "Impl" // Build the error message string. This is separate from the "Impl"
// function template because it is not performance critical and so can // function template because it is not performance critical and so can
// be out of line, while the "Impl" code should be inline. Caller // be out of line, while the "Impl" code should be inline. Caller
// takes ownership of the returned string. // takes ownership of the returned string.
template<class t1, class t2> template <class t1, class t2>
std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) { std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
std::ostringstream ss; std::ostringstream ss;
ss << names << " (" << v1 << " vs. " << v2 << ")"; ss << names << " (" << v1 << " vs. " << v2 << ")";
@ -374,20 +371,25 @@ std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
#if !defined(COMPILER_MSVC) #if !defined(COMPILER_MSVC)
// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
// in logging.cc. // in logging.cc.
extern template std::string* MakeCheckOpString<int, int>( extern template std::string* MakeCheckOpString<int, int>(const int&,
const int&, const int&, const char* names); const int&,
extern template const char* names);
std::string* MakeCheckOpString<unsigned long, unsigned long>( extern template std::string* MakeCheckOpString<unsigned long, unsigned long>(
const unsigned long&, const unsigned long&, const char* names); const unsigned long&,
extern template const unsigned long&,
std::string* MakeCheckOpString<unsigned long, unsigned int>( const char* names);
const unsigned long&, const unsigned int&, const char* names); extern template std::string* MakeCheckOpString<unsigned long, unsigned int>(
extern template const unsigned long&,
std::string* MakeCheckOpString<unsigned int, unsigned long>( const unsigned int&,
const unsigned int&, const unsigned long&, const char* names); const char* names);
extern template extern template std::string* MakeCheckOpString<unsigned int, unsigned long>(
std::string* MakeCheckOpString<std::string, std::string>( const unsigned int&,
const std::string&, const std::string&, const char* name); const unsigned long&,
const char* names);
extern template std::string* MakeCheckOpString<std::string, std::string>(
const std::string&,
const std::string&,
const char* name);
#endif #endif
// Helper functions for CHECK_OP macro. // Helper functions for CHECK_OP macro.
@ -398,27 +400,31 @@ std::string* MakeCheckOpString<std::string, std::string>(
template <class t1, class t2> \ template <class t1, class t2> \
inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \ inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
const char* names) { \ const char* names) { \
if (v1 op v2) return NULL; \ if (v1 op v2) \
else return MakeCheckOpString(v1, v2, names); \ return NULL; \
else \
return MakeCheckOpString(v1, v2, names); \
} \ } \
inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \ inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
if (v1 op v2) return NULL; \ if (v1 op v2) \
else return MakeCheckOpString(v1, v2, names); \ return NULL; \
else \
return MakeCheckOpString(v1, v2, names); \
} }
DEFINE_CHECK_OP_IMPL(EQ, ==) DEFINE_CHECK_OP_IMPL(EQ, ==)
DEFINE_CHECK_OP_IMPL(NE, !=) DEFINE_CHECK_OP_IMPL(NE, !=)
DEFINE_CHECK_OP_IMPL(LE, <=) DEFINE_CHECK_OP_IMPL(LE, <=)
DEFINE_CHECK_OP_IMPL(LT, < ) DEFINE_CHECK_OP_IMPL(LT, <)
DEFINE_CHECK_OP_IMPL(GE, >=) DEFINE_CHECK_OP_IMPL(GE, >=)
DEFINE_CHECK_OP_IMPL(GT, > ) DEFINE_CHECK_OP_IMPL(GT, >)
#undef DEFINE_CHECK_OP_IMPL #undef DEFINE_CHECK_OP_IMPL
#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2) #define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2) #define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2) #define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2) #define CHECK_LT(val1, val2) CHECK_OP(LT, <, val1, val2)
#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2) #define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2) #define CHECK_GT(val1, val2) CHECK_OP(GT, >, val1, val2)
#if defined(NDEBUG) #if defined(NDEBUG)
#define ENABLE_DLOG 0 #define ENABLE_DLOG 0
@ -471,11 +477,9 @@ enum { DEBUG_MODE = ENABLE_DLOG };
#undef ENABLE_DLOG #undef ENABLE_DLOG
#define DLOG(severity) \ #define DLOG(severity) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
#define DPLOG(severity) \ #define DPLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel)) #define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
@ -486,7 +490,7 @@ enum { DEBUG_MODE = ENABLE_DLOG };
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__) COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
const LogSeverity LOG_DCHECK = LOG_FATAL; const LogSeverity LOG_DCHECK = LOG_FATAL;
@ -494,7 +498,7 @@ const LogSeverity LOG_DCHECK = LOG_FATAL;
// These are just dummy values. // These are just dummy values.
#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__) COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO
const LogSeverity LOG_DCHECK = LOG_INFO; const LogSeverity LOG_DCHECK = LOG_INFO;
@ -519,8 +523,9 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
if (DCHECK_IS_ON()) \ if (DCHECK_IS_ON()) \
if (std::string* _result = cef::logging::Check##name##Impl( \ if (std::string* _result = cef::logging::Check##name##Impl( \
(val1), (val2), #val1 " " #op " " #val2)) \ (val1), (val2), #val1 " " #op " " #val2)) \
cef::logging::LogMessage(__FILE__, __LINE__, \ cef::logging::LogMessage(__FILE__, __LINE__, ::cef::logging::LOG_DCHECK, \
::cef::logging::LOG_DCHECK, _result).stream() _result) \
.stream()
// Equality/Inequality checks - compare two values, and log a // Equality/Inequality checks - compare two values, and log a
// LOG_DCHECK message including the two values when the result is not // LOG_DCHECK message including the two values when the result is not
@ -544,13 +549,13 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2) #define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2) #define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2) #define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2) #define DCHECK_LT(val1, val2) DCHECK_OP(LT, <, val1, val2)
#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2) #define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2) #define DCHECK_GT(val1, val2) DCHECK_OP(GT, >, val1, val2)
#if defined(NDEBUG) && defined(OS_CHROMEOS) #if defined(NDEBUG) && defined(OS_CHROMEOS)
#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \ #define NOTREACHED() \
__FUNCTION__ << ". " LOG(ERROR) << "NOTREACHED() hit in " << __FUNCTION__ << ". "
#else #else
#define NOTREACHED() DCHECK(false) #define NOTREACHED() DCHECK(false)
#endif #endif
@ -577,7 +582,9 @@ class LogMessage {
LogMessage(const char* file, int line, std::string* result); LogMessage(const char* file, int line, std::string* result);
// Used for DCHECK_EQ(), etc. Takes ownership of the given string. // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
LogMessage(const char* file, int line, LogSeverity severity, LogMessage(const char* file,
int line,
LogSeverity severity,
std::string* result); std::string* result);
~LogMessage(); ~LogMessage();
@ -617,7 +624,7 @@ class LogMessage {
// A non-macro interface to the log facility; (useful // A non-macro interface to the log facility; (useful
// when the logging level is not a compile-time constant). // when the logging level is not a compile-time constant).
inline void LogAtLevel(int const log_level, std::string const &msg) { inline void LogAtLevel(int const log_level, std::string const& msg) {
LogMessage(__FILE__, __LINE__, log_level).stream() << msg; LogMessage(__FILE__, __LINE__, log_level).stream() << msg;
} }
@ -626,10 +633,10 @@ inline void LogAtLevel(int const log_level, std::string const &msg) {
// is not used" and "statement has no effect". // is not used" and "statement has no effect".
class LogMessageVoidify { class LogMessageVoidify {
public: public:
LogMessageVoidify() { } LogMessageVoidify() {}
// This has to be an operator with a precedence lower than << but // This has to be an operator with a precedence lower than << but
// higher than ?: // higher than ?:
void operator&(std::ostream&) { } void operator&(std::ostream&) {}
}; };
#if defined(OS_WIN) #if defined(OS_WIN)
@ -739,12 +746,13 @@ inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
#elif NOTIMPLEMENTED_POLICY == 4 #elif NOTIMPLEMENTED_POLICY == 4
#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
#elif NOTIMPLEMENTED_POLICY == 5 #elif NOTIMPLEMENTED_POLICY == 5
#define NOTIMPLEMENTED() do {\ #define NOTIMPLEMENTED() \
static bool logged_once = false;\ do { \
LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\ static bool logged_once = false; \
logged_once = true;\ LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
} while(0);\ logged_once = true; \
EAT_STREAM_PARAMETERS } while (0); \
EAT_STREAM_PARAMETERS
#endif #endif
#endif // !USING_CHROMIUM_INCLUDES #endif // !USING_CHROMIUM_INCLUDES

17
include/base/cef_macros.h
View File

@ -126,14 +126,13 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
namespace cef { namespace cef {
template <bool> template <bool>
struct CompileAssert { struct CompileAssert {};
};
} // namespace cef } // namespace cef
#define COMPILE_ASSERT(expr, msg) \ #define COMPILE_ASSERT(expr, msg) \
typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \ typedef cef::CompileAssert<(bool(expr))> \
ALLOW_UNUSED_TYPE msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE
// Implementation details of COMPILE_ASSERT: // Implementation details of COMPILE_ASSERT:
// //
@ -187,8 +186,8 @@ struct CompileAssert {
// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled. // MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
// The warning remains disabled until popped by MSVC_POP_WARNING. // The warning remains disabled until popped by MSVC_POP_WARNING.
#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \ #define MSVC_PUSH_DISABLE_WARNING(n) \
__pragma(warning(disable:n)) __pragma(warning(push)) __pragma(warning(disable : n))
// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level. The level // MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level. The level
// remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all // remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all
@ -207,9 +206,9 @@ struct CompileAssert {
// //
// Compiler warning C4355: 'this': used in base member initializer list: // Compiler warning C4355: 'this': used in base member initializer list:
// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx // http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
#define ALLOW_THIS_IN_INITIALIZER_LIST(code) MSVC_PUSH_DISABLE_WARNING(4355) \ #define ALLOW_THIS_IN_INITIALIZER_LIST(code) \
code \ MSVC_PUSH_DISABLE_WARNING(4355) \
MSVC_POP_WARNING() code MSVC_POP_WARNING()
#else // !COMPILER_MSVC #else // !COMPILER_MSVC
#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code #define ALLOW_THIS_IN_INITIALIZER_LIST(code) code

2
include/base/cef_move.h
View File

@ -248,10 +248,12 @@
}; \ }; \
type(type&); \ type(type&); \
void operator=(type&); \ void operator=(type&); \
\
public: \ public: \
operator rvalue_type() { return rvalue_type(this); } \ operator rvalue_type() { return rvalue_type(this); } \
type Pass() { return type(rvalue_type(this)); } \ type Pass() { return type(rvalue_type(this)); } \
typedef void MoveOnlyTypeForCPP03; \ typedef void MoveOnlyTypeForCPP03; \
\
private: private:
#endif // !USING_CHROMIUM_INCLUDES #endif // !USING_CHROMIUM_INCLUDES

17
include/base/cef_platform_thread.h
View File

@ -69,21 +69,14 @@ class PlatformThreadRef {
public: public:
typedef cef_platform_thread_handle_t RefType; typedef cef_platform_thread_handle_t RefType;
PlatformThreadRef() PlatformThreadRef() : id_(0) {}
: id_(0) {
}
explicit PlatformThreadRef(RefType id) explicit PlatformThreadRef(RefType id) : id_(id) {}
: id_(id) {
}
bool operator==(PlatformThreadRef other) const { bool operator==(PlatformThreadRef other) const { return id_ == other.id_; }
return id_ == other.id_;
} bool is_null() const { return id_ == 0; }
bool is_null() const {
return id_ == 0;
}
private: private:
RefType id_; RefType id_;
}; };

72
include/base/cef_ref_counted.h
View File

@ -64,43 +64,43 @@ class RefCountedBase {
protected: protected:
RefCountedBase() RefCountedBase()
: ref_count_(0) : ref_count_(0)
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
, in_dtor_(false) ,
#endif in_dtor_(false)
#endif
{ {
} }
~RefCountedBase() { ~RefCountedBase() {
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()"; DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
#endif #endif
} }
void AddRef() const { void AddRef() const {
// TODO(maruel): Add back once it doesn't assert 500 times/sec. // TODO(maruel): Add back once it doesn't assert 500 times/sec.
// Current thread books the critical section "AddRelease" // Current thread books the critical section "AddRelease"
// without release it. // without release it.
// DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_); // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
DCHECK(!in_dtor_); DCHECK(!in_dtor_);
#endif #endif
++ref_count_; ++ref_count_;
} }
// Returns true if the object should self-delete. // Returns true if the object should self-delete.
bool Release() const { bool Release() const {
// TODO(maruel): Add back once it doesn't assert 500 times/sec. // TODO(maruel): Add back once it doesn't assert 500 times/sec.
// Current thread books the critical section "AddRelease" // Current thread books the critical section "AddRelease"
// without release it. // without release it.
// DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_); // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
DCHECK(!in_dtor_); DCHECK(!in_dtor_);
#endif #endif
if (--ref_count_ == 0) { if (--ref_count_ == 0) {
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
in_dtor_ = true; in_dtor_ = true;
#endif #endif
return true; return true;
} }
return false; return false;
@ -160,9 +160,7 @@ class RefCounted : public cef_subtle::RefCountedBase {
public: public:
RefCounted() {} RefCounted() {}
void AddRef() const { void AddRef() const { cef_subtle::RefCountedBase::AddRef(); }
cef_subtle::RefCountedBase::AddRef();
}
void Release() const { void Release() const {
if (cef_subtle::RefCountedBase::Release()) { if (cef_subtle::RefCountedBase::Release()) {
@ -178,18 +176,19 @@ class RefCounted : public cef_subtle::RefCountedBase {
}; };
// Forward declaration. // Forward declaration.
template <class T, typename Traits> class RefCountedThreadSafe; template <class T, typename Traits>
class RefCountedThreadSafe;
// Default traits for RefCountedThreadSafe<T>. Deletes the object when its ref // Default traits for RefCountedThreadSafe<T>. Deletes the object when its ref
// count reaches 0. Overload to delete it on a different thread etc. // count reaches 0. Overload to delete it on a different thread etc.
template<typename T> template <typename T>
struct DefaultRefCountedThreadSafeTraits { struct DefaultRefCountedThreadSafeTraits {
static void Destruct(const T* x) { static void Destruct(const T* x) {
// Delete through RefCountedThreadSafe to make child classes only need to be // Delete through RefCountedThreadSafe to make child classes only need to be
// friend with RefCountedThreadSafe instead of this struct, which is an // friend with RefCountedThreadSafe instead of this struct, which is an
// implementation detail. // implementation detail.
RefCountedThreadSafe<T, RefCountedThreadSafe<T, DefaultRefCountedThreadSafeTraits>::DeleteInternal(
DefaultRefCountedThreadSafeTraits>::DeleteInternal(x); x);
} }
}; };
@ -205,14 +204,12 @@ struct DefaultRefCountedThreadSafeTraits {
// private: // private:
// friend class base::RefCountedThreadSafe<MyFoo>; // friend class base::RefCountedThreadSafe<MyFoo>;
// ~MyFoo(); // ~MyFoo();
template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> > template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T>>
class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase { class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
public: public:
RefCountedThreadSafe() {} RefCountedThreadSafe() {}
void AddRef() const { void AddRef() const { cef_subtle::RefCountedThreadSafeBase::AddRef(); }
cef_subtle::RefCountedThreadSafeBase::AddRef();
}
void Release() const { void Release() const {
if (cef_subtle::RefCountedThreadSafeBase::Release()) { if (cef_subtle::RefCountedThreadSafeBase::Release()) {
@ -234,9 +231,9 @@ class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
// A thread-safe wrapper for some piece of data so we can place other // A thread-safe wrapper for some piece of data so we can place other
// things in scoped_refptrs<>. // things in scoped_refptrs<>.
// //
template<typename T> template <typename T>
class RefCountedData class RefCountedData
: public base::RefCountedThreadSafe< base::RefCountedData<T> > { : public base::RefCountedThreadSafe<base::RefCountedData<T>> {
public: public:
RefCountedData() : data() {} RefCountedData() : data() {}
RefCountedData(const T& in_value) : data(in_value) {} RefCountedData(const T& in_value) : data(in_value) {}
@ -244,7 +241,7 @@ class RefCountedData
T data; T data;
private: private:
friend class base::RefCountedThreadSafe<base::RefCountedData<T> >; friend class base::RefCountedThreadSafe<base::RefCountedData<T>>;
~RefCountedData() {} ~RefCountedData() {}
}; };
@ -303,8 +300,7 @@ class scoped_refptr {
public: public:
typedef T element_type; typedef T element_type;
scoped_refptr() : ptr_(NULL) { scoped_refptr() : ptr_(NULL) {}
}
scoped_refptr(T* p) : ptr_(p) { scoped_refptr(T* p) : ptr_(p) {
if (ptr_) if (ptr_)
@ -364,9 +360,7 @@ class scoped_refptr {
*pp = p; *pp = p;
} }
void swap(scoped_refptr<T>& r) { void swap(scoped_refptr<T>& r) { swap(&r.ptr_); }
swap(&r.ptr_);
}
protected: protected:
T* ptr_; T* ptr_;

78
include/base/cef_scoped_ptr.h
View File

@ -154,7 +154,8 @@ class RefCountedThreadSafeBase;
template <class T> template <class T>
struct DefaultDeleter { struct DefaultDeleter {
DefaultDeleter() {} DefaultDeleter() {}
template <typename U> DefaultDeleter(const DefaultDeleter<U>& other) { template <typename U>
DefaultDeleter(const DefaultDeleter<U>& other) {
// IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
// if U* is implicitly convertible to T* and U is not an array type. // if U* is implicitly convertible to T* and U is not an array type.
// //
@ -194,7 +195,8 @@ struct DefaultDeleter<T[]> {
// References: // References:
// C++98 [expr.delete]p3 // C++98 [expr.delete]p3
// http://cplusplus.github.com/LWG/lwg-defects.html#938 // http://cplusplus.github.com/LWG/lwg-defects.html#938
template <typename U> void operator()(U* array) const; template <typename U>
void operator()(U* array) const;
}; };
template <class T, int n> template <class T, int n>
@ -209,18 +211,18 @@ struct DefaultDeleter<T[n]> {
// scoped_ptr<int, base::FreeDeleter> foo_ptr( // scoped_ptr<int, base::FreeDeleter> foo_ptr(
// static_cast<int*>(malloc(sizeof(int)))); // static_cast<int*>(malloc(sizeof(int))));
struct FreeDeleter { struct FreeDeleter {
inline void operator()(void* ptr) const { inline void operator()(void* ptr) const { free(ptr); }
free(ptr);
}
}; };
namespace cef_internal { namespace cef_internal {
template <typename T> struct IsNotRefCounted { template <typename T>
struct IsNotRefCounted {
enum { enum {
value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value && value =
!base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>:: !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
value !base::is_convertible<T*,
base::subtle::RefCountedThreadSafeBase*>::value
}; };
}; };
@ -229,7 +231,7 @@ template <typename T> struct IsNotRefCounted {
template <class T, class D> template <class T, class D>
class scoped_ptr_impl { class scoped_ptr_impl {
public: public:
explicit scoped_ptr_impl(T* p) : data_(p) { } explicit scoped_ptr_impl(T* p) : data_(p) {}
// Initializer for deleters that have data parameters. // Initializer for deleters that have data parameters.
scoped_ptr_impl(T* p, const D& d) : data_(p, d) {} scoped_ptr_impl(T* p, const D& d) : data_(p, d) {}
@ -309,7 +311,8 @@ class scoped_ptr_impl {
private: private:
// Needed to allow type-converting constructor. // Needed to allow type-converting constructor.
template <typename U, typename V> friend class scoped_ptr_impl; template <typename U, typename V>
friend class scoped_ptr_impl;
// Use the empty base class optimization to allow us to have a D // Use the empty base class optimization to allow us to have a D
// member, while avoiding any space overhead for it when D is an // member, while avoiding any space overhead for it when D is an
@ -346,7 +349,7 @@ class scoped_ptr_impl {
// unique_ptr<> features. Known deficiencies include not supporting move-only // unique_ptr<> features. Known deficiencies include not supporting move-only
// deleteres, function pointers as deleters, and deleters with reference // deleteres, function pointers as deleters, and deleters with reference
// types. // types.
template <class T, class D = base::DefaultDeleter<T> > template <class T, class D = base::DefaultDeleter<T>>
class scoped_ptr { class scoped_ptr {
MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue) MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
@ -359,13 +362,13 @@ class scoped_ptr {
typedef D deleter_type; typedef D deleter_type;
// Constructor. Defaults to initializing with NULL. // Constructor. Defaults to initializing with NULL.
scoped_ptr() : impl_(NULL) { } scoped_ptr() : impl_(NULL) {}
// Constructor. Takes ownership of p. // Constructor. Takes ownership of p.
explicit scoped_ptr(element_type* p) : impl_(p) { } explicit scoped_ptr(element_type* p) : impl_(p) {}
// Constructor. Allows initialization of a stateful deleter. // Constructor. Allows initialization of a stateful deleter.
scoped_ptr(element_type* p, const D& d) : impl_(p, d) { } scoped_ptr(element_type* p, const D& d) : impl_(p, d) {}
// Constructor. Allows construction from a scoped_ptr rvalue for a // Constructor. Allows construction from a scoped_ptr rvalue for a
// convertible type and deleter. // convertible type and deleter.
@ -383,7 +386,7 @@ class scoped_ptr {
} }
// Constructor. Move constructor for C++03 move emulation of this type. // Constructor. Move constructor for C++03 move emulation of this type.
scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { } scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
// operator=. Allows assignment from a scoped_ptr rvalue for a convertible // operator=. Allows assignment from a scoped_ptr rvalue for a convertible
// type and deleter. // type and deleter.
@ -443,18 +446,14 @@ class scoped_ptr {
bool operator!=(const element_type* p) const { return impl_.get() != p; } bool operator!=(const element_type* p) const { return impl_.get() != p; }
// Swap two scoped pointers. // Swap two scoped pointers.
void swap(scoped_ptr& p2) { void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
impl_.swap(p2.impl_);
}
// Release a pointer. // Release a pointer.
// The return value is the current pointer held by this object. // The return value is the current pointer held by this object.
// If this object holds a NULL pointer, the return value is NULL. // If this object holds a NULL pointer, the return value is NULL.
// After this operation, this object will hold a NULL pointer, // After this operation, this object will hold a NULL pointer,
// and will not own the object any more. // and will not own the object any more.
element_type* release() WARN_UNUSED_RESULT { element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
return impl_.release();
}
// C++98 doesn't support functions templates with default parameters which // C++98 doesn't support functions templates with default parameters which
// makes it hard to write a PassAs() that understands converting the deleter // makes it hard to write a PassAs() that understands converting the deleter
@ -469,7 +468,8 @@ class scoped_ptr {
private: private:
// Needed to reach into |impl_| in the constructor. // Needed to reach into |impl_| in the constructor.
template <typename U, typename V> friend class scoped_ptr; template <typename U, typename V>
friend class scoped_ptr;
base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_; base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
// Forbidden for API compatibility with std::unique_ptr. // Forbidden for API compatibility with std::unique_ptr.
@ -479,8 +479,10 @@ class scoped_ptr {
// doesn't make sense, and if U == T, it still doesn't make sense // doesn't make sense, and if U == T, it still doesn't make sense
// because you should never have the same object owned by two different // because you should never have the same object owned by two different
// scoped_ptrs. // scoped_ptrs.
template <class U> bool operator==(scoped_ptr<U> const& p2) const; template <class U>
template <class U> bool operator!=(scoped_ptr<U> const& p2) const; bool operator==(scoped_ptr<U> const& p2) const;
template <class U>
bool operator!=(scoped_ptr<U> const& p2) const;
}; };
template <class T, class D> template <class T, class D>
@ -493,7 +495,7 @@ class scoped_ptr<T[], D> {
typedef D deleter_type; typedef D deleter_type;
// Constructor. Defaults to initializing with NULL. // Constructor. Defaults to initializing with NULL.
scoped_ptr() : impl_(NULL) { } scoped_ptr() : impl_(NULL) {}
// Constructor. Stores the given array. Note that the argument's type // Constructor. Stores the given array. Note that the argument's type
// must exactly match T*. In particular: // must exactly match T*. In particular:
@ -511,10 +513,10 @@ class scoped_ptr<T[], D> {
// to work around this may use implicit_cast<const T*>(). // to work around this may use implicit_cast<const T*>().
// However, because of the first bullet in this comment, users MUST // However, because of the first bullet in this comment, users MUST
// NOT use implicit_cast<Base*>() to upcast the static type of the array. // NOT use implicit_cast<Base*>() to upcast the static type of the array.
explicit scoped_ptr(element_type* array) : impl_(array) { } explicit scoped_ptr(element_type* array) : impl_(array) {}
// Constructor. Move constructor for C++03 move emulation of this type. // Constructor. Move constructor for C++03 move emulation of this type.
scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { } scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) {}
// operator=. Move operator= for C++03 move emulation of this type. // operator=. Move operator= for C++03 move emulation of this type.
scoped_ptr& operator=(RValue rhs) { scoped_ptr& operator=(RValue rhs) {
@ -553,18 +555,14 @@ class scoped_ptr<T[], D> {
bool operator!=(element_type* array) const { return impl_.get() != array; } bool operator!=(element_type* array) const { return impl_.get() != array; }
// Swap two scoped pointers. // Swap two scoped pointers.
void swap(scoped_ptr& p2) { void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
impl_.swap(p2.impl_);
}
// Release a pointer. // Release a pointer.
// The return value is the current pointer held by this object. // The return value is the current pointer held by this object.
// If this object holds a NULL pointer, the return value is NULL. // If this object holds a NULL pointer, the return value is NULL.
// After this operation, this object will hold a NULL pointer, // After this operation, this object will hold a NULL pointer,
// and will not own the object any more. // and will not own the object any more.
element_type* release() WARN_UNUSED_RESULT { element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
return impl_.release();
}
private: private:
// Force element_type to be a complete type. // Force element_type to be a complete type.
@ -578,20 +576,24 @@ class scoped_ptr<T[], D> {
// private and has no definition. This is disabled because it is not safe to // private and has no definition. This is disabled because it is not safe to
// call delete[] on an array whose static type does not match its dynamic // call delete[] on an array whose static type does not match its dynamic
// type. // type.
template <typename U> explicit scoped_ptr(U* array); template <typename U>
explicit scoped_ptr(U* array);
explicit scoped_ptr(int disallow_construction_from_null); explicit scoped_ptr(int disallow_construction_from_null);
// Disable reset() from any type other than element_type*, for the same // Disable reset() from any type other than element_type*, for the same
// reasons as the constructor above. // reasons as the constructor above.
template <typename U> void reset(U* array); template <typename U>
void reset(U* array);
void reset(int disallow_reset_from_null); void reset(int disallow_reset_from_null);
// Forbid comparison of scoped_ptr types. If U != T, it totally // Forbid comparison of scoped_ptr types. If U != T, it totally
// doesn't make sense, and if U == T, it still doesn't make sense // doesn't make sense, and if U == T, it still doesn't make sense
// because you should never have the same object owned by two different // because you should never have the same object owned by two different
// scoped_ptrs. // scoped_ptrs.
template <class U> bool operator==(scoped_ptr<U> const& p2) const; template <class U>
template <class U> bool operator!=(scoped_ptr<U> const& p2) const; bool operator==(scoped_ptr<U> const& p2) const;
template <class U>
bool operator!=(scoped_ptr<U> const& p2) const;
}; };
// Free functions // Free functions

35
include/base/cef_string16.h
View File

@ -112,26 +112,19 @@ struct string16_char_traits {
typedef mbstate_t state_type; typedef mbstate_t state_type;
typedef std::fpos<state_type> pos_type; typedef std::fpos<state_type> pos_type;
static void assign(char_type& c1, const char_type& c2) { static void assign(char_type& c1, const char_type& c2) { c1 = c2; }
c1 = c2;
}
static bool eq(const char_type& c1, const char_type& c2) { static bool eq(const char_type& c1, const char_type& c2) { return c1 == c2; }
return c1 == c2; static bool lt(const char_type& c1, const char_type& c2) { return c1 < c2; }
}
static bool lt(const char_type& c1, const char_type& c2) {
return c1 < c2;
}
static int compare(const char_type* s1, const char_type* s2, size_t n) { static int compare(const char_type* s1, const char_type* s2, size_t n) {
return c16memcmp(s1, s2, n); return c16memcmp(s1, s2, n);
} }
static size_t length(const char_type* s) { static size_t length(const char_type* s) { return c16len(s); }
return c16len(s);
}
static const char_type* find(const char_type* s, size_t n, static const char_type* find(const char_type* s,
size_t n,
const char_type& a) { const char_type& a) {
return c16memchr(s, a, n); return c16memchr(s, a, n);
} }
@ -152,21 +145,15 @@ struct string16_char_traits {
return eq_int_type(c, eof()) ? 0 : c; return eq_int_type(c, eof()) ? 0 : c;
} }
static char_type to_char_type(const int_type& c) { static char_type to_char_type(const int_type& c) { return char_type(c); }
return char_type(c);
}
static int_type to_int_type(const char_type& c) { static int_type to_int_type(const char_type& c) { return int_type(c); }
return int_type(c);
}
static bool eq_int_type(const int_type& c1, const int_type& c2) { static bool eq_int_type(const int_type& c1, const int_type& c2) {
return c1 == c2; return c1 == c2;
} }
static int_type eof() { static int_type eof() { return static_cast<int_type>(EOF); }
return static_cast<int_type>(EOF);
}
}; };
typedef std::basic_string<char16, base::string16_char_traits> string16; typedef std::basic_string<char16, base::string16_char_traits> string16;
@ -217,8 +204,8 @@ extern void PrintTo(const string16& str, std::ostream* out);
// //
// TODO(mark): File this bug with Apple and update this note with a bug number. // TODO(mark): File this bug with Apple and update this note with a bug number.
extern template extern template class std::basic_string<base::char16,
class std::basic_string<base::char16, base::string16_char_traits>; base::string16_char_traits>;
#endif // WCHAR_T_IS_UTF32 #endif // WCHAR_T_IS_UTF32

98
include/base/cef_template_util.h
View File

@ -53,70 +53,92 @@ namespace base {
// template definitions from tr1 // template definitions from tr1
template<class T, T v> template <class T, T v>
struct integral_constant { struct integral_constant {
static const T value = v; static const T value = v;
typedef T value_type; typedef T value_type;
typedef integral_constant<T, v> type; typedef integral_constant<T, v> type;
}; };
template <class T, T v> const T integral_constant<T, v>::value; template <class T, T v>
const T integral_constant<T, v>::value;
typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type; typedef integral_constant<bool, false> false_type;
template <class T> struct is_pointer : false_type {}; template <class T>
template <class T> struct is_pointer<T*> : true_type {}; struct is_pointer : false_type {};
template <class T>
struct is_pointer<T*> : true_type {};
// Member function pointer detection up to four params. Add more as needed // Member function pointer detection up to four params. Add more as needed
// below. This is built-in to C++ 11, and we can remove this when we switch. // below. This is built-in to C++ 11, and we can remove this when we switch.
template<typename T> template <typename T>
struct is_member_function_pointer : false_type {}; struct is_member_function_pointer : false_type {};
template <typename R, typename Z> template <typename R, typename Z>
struct is_member_function_pointer<R(Z::*)()> : true_type {}; struct is_member_function_pointer<R (Z::*)()> : true_type {};
template <typename R, typename Z> template <typename R, typename Z>
struct is_member_function_pointer<R(Z::*)() const> : true_type {}; struct is_member_function_pointer<R (Z::*)() const> : true_type {};
template <typename R, typename Z, typename A> template <typename R, typename Z, typename A>
struct is_member_function_pointer<R(Z::*)(A)> : true_type {}; struct is_member_function_pointer<R (Z::*)(A)> : true_type {};
template <typename R, typename Z, typename A> template <typename R, typename Z, typename A>
struct is_member_function_pointer<R(Z::*)(A) const> : true_type {}; struct is_member_function_pointer<R (Z::*)(A) const> : true_type {};
template <typename R, typename Z, typename A, typename B> template <typename R, typename Z, typename A, typename B>
struct is_member_function_pointer<R(Z::*)(A, B)> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B)> : true_type {};
template <typename R, typename Z, typename A, typename B> template <typename R, typename Z, typename A, typename B>
struct is_member_function_pointer<R(Z::*)(A, B) const> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B) const> : true_type {};
template <typename R, typename Z, typename A, typename B, typename C> template <typename R, typename Z, typename A, typename B, typename C>
struct is_member_function_pointer<R(Z::*)(A, B, C)> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B, C)> : true_type {};
template <typename R, typename Z, typename A, typename B, typename C> template <typename R, typename Z, typename A, typename B, typename C>
struct is_member_function_pointer<R(Z::*)(A, B, C) const> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B, C) const> : true_type {};
template <typename R, typename Z, typename A, typename B, typename C, template <typename R,
typename Z,
typename A,
typename B,
typename C,
typename D> typename D>
struct is_member_function_pointer<R(Z::*)(A, B, C, D)> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B, C, D)> : true_type {};
template <typename R, typename Z, typename A, typename B, typename C, template <typename R,
typename Z,
typename A,
typename B,
typename C,
typename D> typename D>
struct is_member_function_pointer<R(Z::*)(A, B, C, D) const> : true_type {}; struct is_member_function_pointer<R (Z::*)(A, B, C, D) const> : true_type {};
template <class T, class U>
struct is_same : public false_type {};
template <class T>
struct is_same<T, T> : true_type {};
template <class T, class U> struct is_same : public false_type {}; template <class>
template <class T> struct is_same<T,T> : true_type {}; struct is_array : public false_type {};
template <class T, size_t n>
struct is_array<T[n]> : public true_type {};
template <class T>
struct is_array<T[]> : public true_type {};
template<class> struct is_array : public false_type {}; template <class T>
template<class T, size_t n> struct is_array<T[n]> : public true_type {}; struct is_non_const_reference : false_type {};
template<class T> struct is_array<T[]> : public true_type {}; template <class T>
struct is_non_const_reference<T&> : true_type {};
template <class T>
struct is_non_const_reference<const T&> : false_type {};
template <class T> struct is_non_const_reference : false_type {}; template <class T>
template <class T> struct is_non_const_reference<T&> : true_type {}; struct is_const : false_type {};
template <class T> struct is_non_const_reference<const T&> : false_type {}; template <class T>
struct is_const<const T> : true_type {};
template <class T> struct is_const : false_type {}; template <class T>
template <class T> struct is_const<const T> : true_type {}; struct is_void : false_type {};
template <>
template <class T> struct is_void : false_type {}; struct is_void<void> : true_type {};
template <> struct is_void<void> : true_type {};
namespace cef_internal { namespace cef_internal {
@ -152,7 +174,7 @@ struct ConvertHelper {
// is_class type_trait implementation. // is_class type_trait implementation.
struct IsClassHelper { struct IsClassHelper {
template <typename C> template <typename C>
static YesType Test(void(C::*)(void)); static YesType Test(void (C::*)(void));
template <typename C> template <typename C>
static NoType Test(...); static NoType Test(...);
@ -169,21 +191,21 @@ struct is_convertible
: integral_constant<bool, : integral_constant<bool,
sizeof(cef_internal::ConvertHelper::Test<To>( sizeof(cef_internal::ConvertHelper::Test<To>(
cef_internal::ConvertHelper::Create<From>())) == cef_internal::ConvertHelper::Create<From>())) ==
sizeof(cef_internal::YesType)> { sizeof(cef_internal::YesType)> {};
};
template <typename T> template <typename T>
struct is_class struct is_class
: integral_constant<bool, : integral_constant<bool,
sizeof(cef_internal::IsClassHelper::Test<T>(0)) == sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
sizeof(cef_internal::YesType)> { sizeof(cef_internal::YesType)> {};
};
template<bool B, class T = void> template <bool B, class T = void>
struct enable_if {}; struct enable_if {};
template<class T> template <class T>
struct enable_if<true, T> { typedef T type; }; struct enable_if<true, T> {
typedef T type;
};
} // namespace base } // namespace base

11
include/base/cef_thread_checker.h
View File

@ -58,7 +58,6 @@
#define ENABLE_THREAD_CHECKER 0 #define ENABLE_THREAD_CHECKER 0
#endif #endif
namespace base { namespace base {
namespace cef_internal { namespace cef_internal {
@ -69,9 +68,7 @@ namespace cef_internal {
// right version for your build configuration. // right version for your build configuration.
class ThreadCheckerDoNothing { class ThreadCheckerDoNothing {
public: public:
bool CalledOnValidThread() const { bool CalledOnValidThread() const { return true; }
return true;
}
void DetachFromThread() {} void DetachFromThread() {}
}; };
@ -110,11 +107,9 @@ class ThreadCheckerDoNothing {
// //
// In Release mode, CalledOnValidThread will always return true. // In Release mode, CalledOnValidThread will always return true.
#if ENABLE_THREAD_CHECKER #if ENABLE_THREAD_CHECKER
class ThreadChecker : public cef_internal::ThreadCheckerImpl { class ThreadChecker : public cef_internal::ThreadCheckerImpl {};
};
#else #else
class ThreadChecker : public cef_internal::ThreadCheckerDoNothing { class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {};
};
#endif // ENABLE_THREAD_CHECKER #endif // ENABLE_THREAD_CHECKER
#undef ENABLE_THREAD_CHECKER #undef ENABLE_THREAD_CHECKER

26
include/base/cef_thread_collision_warner.h
View File

@ -139,13 +139,11 @@
// DFAKE_MUTEX(shareable_section_); // DFAKE_MUTEX(shareable_section_);
// }; // };
#if DCHECK_IS_ON() #if DCHECK_IS_ON()
// Defines a class member that acts like a mutex. It is used only as a // Defines a class member that acts like a mutex. It is used only as a
// verification tool. // verification tool.
#define DFAKE_MUTEX(obj) \ #define DFAKE_MUTEX(obj) mutable base::ThreadCollisionWarner obj
mutable base::ThreadCollisionWarner obj
// Asserts the call is never called simultaneously in two threads. Used at // Asserts the call is never called simultaneously in two threads. Used at
// member function scope. // member function scope.
#define DFAKE_SCOPED_LOCK(obj) \ #define DFAKE_SCOPED_LOCK(obj) \
@ -187,13 +185,9 @@ class ThreadCollisionWarner {
public: public:
// The parameter asserter is there only for test purpose // The parameter asserter is there only for test purpose
explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter()) explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
: valid_thread_id_(0), : valid_thread_id_(0), counter_(0), asserter_(asserter) {}
counter_(0),
asserter_(asserter) {}
~ThreadCollisionWarner() { ~ThreadCollisionWarner() { delete asserter_; }
delete asserter_;
}
// This class is meant to be used through the macro // This class is meant to be used through the macro
// DFAKE_SCOPED_LOCK_THREAD_LOCKED // DFAKE_SCOPED_LOCK_THREAD_LOCKED
@ -202,8 +196,7 @@ class ThreadCollisionWarner {
// from one thread // from one thread
class Check { class Check {
public: public:
explicit Check(ThreadCollisionWarner* warner) explicit Check(ThreadCollisionWarner* warner) : warner_(warner) {
: warner_(warner) {
warner_->EnterSelf(); warner_->EnterSelf();
} }
@ -219,14 +212,11 @@ class ThreadCollisionWarner {
// DFAKE_SCOPED_LOCK // DFAKE_SCOPED_LOCK
class ScopedCheck { class ScopedCheck {
public: public:
explicit ScopedCheck(ThreadCollisionWarner* warner) explicit ScopedCheck(ThreadCollisionWarner* warner) : warner_(warner) {
: warner_(warner) {
warner_->Enter(); warner_->Enter();
} }
~ScopedCheck() { ~ScopedCheck() { warner_->Leave(); }
warner_->Leave();
}
private: private:
ThreadCollisionWarner* warner_; ThreadCollisionWarner* warner_;
@ -243,9 +233,7 @@ class ThreadCollisionWarner {
warner_->EnterSelf(); warner_->EnterSelf();
} }
~ScopedRecursiveCheck() { ~ScopedRecursiveCheck() { warner_->Leave(); }
warner_->Leave();
}
private: private:
ThreadCollisionWarner* warner_; ThreadCollisionWarner* warner_;

75
include/base/cef_trace_event.h
View File

@ -166,26 +166,23 @@
#define TRACE_EVENT1(category, name, arg1_name, arg1_val) \ #define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \ cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, \ #define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
arg2_val) \ cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
cef_trace_event_begin(category, name, arg1_name, arg1_val, \ arg2_val, false); \
arg2_name, arg2_val, false); \
CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
// Implementation detail: trace event macros create temporary variable names. // Implementation detail: trace event macros create temporary variable names.
// These macros give each temporary variable a unique name based on the line // These macros give each temporary variable a unique name based on the line
// number to prevent name collisions. // number to prevent name collisions.
#define CEF_INTERNAL_TRACE_EVENT_UID3(a,b) \ #define CEF_INTERNAL_TRACE_EVENT_UID3(a, b) cef_trace_event_unique_##a##b
cef_trace_event_unique_##a##b #define CEF_INTERNAL_TRACE_EVENT_UID2(a, b) CEF_INTERNAL_TRACE_EVENT_UID3(a, b)
#define CEF_INTERNAL_TRACE_EVENT_UID2(a,b) \
CEF_INTERNAL_TRACE_EVENT_UID3(a,b)
#define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \ #define CEF_INTERNAL_TRACE_EVENT_UID(name_prefix) \
CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__) CEF_INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
// Implementation detail: internal macro to end end event when the scope ends. // Implementation detail: internal macro to end end event when the scope ends.
#define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) \ #define CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name) \
cef_trace_event::CefTraceEndOnScopeClose \ cef_trace_event::CefTraceEndOnScopeClose CEF_INTERNAL_TRACE_EVENT_UID( \
CEF_INTERNAL_TRACE_EVENT_UID(profileScope)(category, name) profileScope)(category, name)
// Records a single event called "name" immediately, with 0, 1 or 2 // Records a single event called "name" immediately, with 0, 1 or 2
// associated arguments. If the category is not enabled, then this // associated arguments. If the category is not enabled, then this
@ -196,8 +193,8 @@
cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false) cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \ #define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false) cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \ #define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_name, arg2_val) \ arg2_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \ cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false) arg2_val, false)
#define TRACE_EVENT_COPY_INSTANT0(category, name) \ #define TRACE_EVENT_COPY_INSTANT0(category, name) \
@ -218,8 +215,8 @@
cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false) cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \ #define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false) cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \ #define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_name, arg2_val) \ arg2_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \ cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false) arg2_val, false)
#define TRACE_EVENT_COPY_BEGIN0(category, name) \ #define TRACE_EVENT_COPY_BEGIN0(category, name) \
@ -239,16 +236,16 @@
cef_trace_event_end(category, name, NULL, 0, NULL, 0, false) cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \ #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false) cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \ #define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_name, arg2_val) \ arg2_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \ cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false) arg2_val, false)
#define TRACE_EVENT_COPY_END0(category, name) \ #define TRACE_EVENT_COPY_END0(category, name) \
cef_trace_event_end(category, name, NULL, 0, NULL, 0, true) cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \ #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true) cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \ #define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_name, arg2_val) \ arg2_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \ cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, true) arg2_val, true)
@ -266,8 +263,8 @@
// values as a stacked-bar chart. // values as a stacked-bar chart.
// - category and name strings must have application lifetime (statics or // - category and name strings must have application lifetime (statics or
// literals). They may not include " chars. // literals). They may not include " chars.
#define TRACE_COUNTER2(category, name, value1_name, value1_val, \ #define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
value2_name, value2_val) \ value2_val) \
cef_trace_counter(category, name, value1_name, value1_val, value2_name, \ cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
value2_val, false) value2_val, false)
#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \ #define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
@ -301,12 +298,11 @@
value2_name, value2_val) \ value2_name, value2_val) \
cef_trace_counter_id(category, name, id, value1_name, value1_val, \ cef_trace_counter_id(category, name, id, value1_name, value1_val, \
value2_name, value2_val, false) value2_name, value2_val, false)
#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, \ #define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
value1_val, value2_name, value2_val) \ value2_name, value2_val) \
cef_trace_counter_id(category, name, id, value1_name, value1_val, \ cef_trace_counter_id(category, name, id, value1_name, value1_val, \
value2_name, value2_val, true) value2_name, value2_val, true)
// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2 // Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
// associated arguments. If the category is not enabled, then this // associated arguments. If the category is not enabled, then this
// does nothing. // does nothing.
@ -334,12 +330,11 @@
arg2_name, arg2_val, false) arg2_name, arg2_val, false)
#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \ #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true) cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, \ #define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
arg1_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
0, true) 0, true)
#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, \ #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
arg1_val, arg2_name, arg2_val) \ arg2_name, arg2_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \ cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, true) arg2_name, arg2_val, true)
@ -351,14 +346,14 @@
// ASYNC_STEP_PAST events. // ASYNC_STEP_PAST events.
#define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \ #define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false) cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, \ #define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
arg1_name, arg1_val) \ arg1_val) \
cef_trace_event_async_step_into(category, name, id, step, arg1_name, \ cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
arg1_val, false) arg1_val, false)
#define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \ #define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true) cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, \ #define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
arg1_name, arg1_val) \ arg1_val) \
cef_trace_event_async_step_into(category, name, id, step, arg1_name, \ cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
arg1_val, true) arg1_val, true)
@ -370,14 +365,14 @@
// ASYNC_STEP_INTO events. // ASYNC_STEP_INTO events.
#define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \ #define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false) cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, \ #define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
arg1_name, arg1_val) \ arg1_val) \
cef_trace_event_async_step_past(category, name, id, step, arg1_name, \ cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
arg1_val, false) arg1_val, false)
#define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \ #define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true) cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, \ #define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
arg1_name, arg1_val) \ arg1_val) \
cef_trace_event_async_step_past(category, name, id, step, arg1_name, \ cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
arg1_val, true) arg1_val, true)
@ -394,12 +389,11 @@
arg2_name, arg2_val, false) arg2_name, arg2_val, false)
#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \ #define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true) cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, \ #define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
arg1_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
true) true)
#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, \ #define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
arg1_val, arg2_name, arg2_val) \ arg2_name, arg2_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \ cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, true) arg2_name, arg2_val, true)
@ -409,8 +403,7 @@ namespace cef_trace_event {
class CefTraceEndOnScopeClose { class CefTraceEndOnScopeClose {
public: public:
CefTraceEndOnScopeClose(const char* category, const char* name) CefTraceEndOnScopeClose(const char* category, const char* name)
: category_(category), name_(name) { : category_(category), name_(name) {}
}
~CefTraceEndOnScopeClose() { ~CefTraceEndOnScopeClose() {
cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false); cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
} }

1007
include/base/cef_tuple.h
View File

File diff suppressed because it is too large Load Diff

49
include/base/cef_weak_ptr.h
View File

@ -117,8 +117,10 @@
namespace base { namespace base {
template <typename T> class SupportsWeakPtr; template <typename T>
template <typename T> class WeakPtr; class SupportsWeakPtr;
template <typename T>
class WeakPtr;
namespace cef_internal { namespace cef_internal {
// These classes are part of the WeakPtr implementation. // These classes are part of the WeakPtr implementation.
@ -164,9 +166,7 @@ class WeakReferenceOwner {
WeakReference GetRef() const; WeakReference GetRef() const;
bool HasRefs() const { bool HasRefs() const { return flag_.get() && !flag_->HasOneRef(); }
return flag_.get() && !flag_->HasOneRef();
}
void Invalidate(); void Invalidate();
@ -198,10 +198,10 @@ class SupportsWeakPtrBase {
// conversion will only compile if there is exists a Base which inherits // conversion will only compile if there is exists a Base which inherits
// from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
// function that makes calling this easier. // function that makes calling this easier.
template<typename Derived> template <typename Derived>
static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) { static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
typedef typedef is_convertible<Derived, cef_internal::SupportsWeakPtrBase&>
is_convertible<Derived, cef_internal::SupportsWeakPtrBase&> convertible; convertible;
COMPILE_ASSERT(convertible::value, COMPILE_ASSERT(convertible::value,
AsWeakPtr_argument_inherits_from_SupportsWeakPtr); AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
return AsWeakPtrImpl<Derived>(t, *t); return AsWeakPtrImpl<Derived>(t, *t);
@ -212,8 +212,8 @@ class SupportsWeakPtrBase {
// which is an instance of SupportsWeakPtr<Base>. We can then safely // which is an instance of SupportsWeakPtr<Base>. We can then safely
// static_cast the Base* to a Derived*. // static_cast the Base* to a Derived*.
template <typename Derived, typename Base> template <typename Derived, typename Base>
static WeakPtr<Derived> AsWeakPtrImpl( static WeakPtr<Derived> AsWeakPtrImpl(Derived* t,
Derived* t, const SupportsWeakPtr<Base>&) { const SupportsWeakPtr<Base>&) {
WeakPtr<Base> ptr = t->Base::AsWeakPtr(); WeakPtr<Base> ptr = t->Base::AsWeakPtr();
return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_)); return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));
} }
@ -221,7 +221,8 @@ class SupportsWeakPtrBase {
} // namespace cef_internal } // namespace cef_internal
template <typename T> class WeakPtrFactory; template <typename T>
class WeakPtrFactory;
// The WeakPtr class holds a weak reference to |T*|. // The WeakPtr class holds a weak reference to |T*|.
// //
@ -239,14 +240,12 @@ template <typename T> class WeakPtrFactory;
template <typename T> template <typename T>
class WeakPtr : public cef_internal::WeakPtrBase { class WeakPtr : public cef_internal::WeakPtrBase {
public: public:
WeakPtr() : ptr_(NULL) { WeakPtr() : ptr_(NULL) {}
}
// Allow conversion from U to T provided U "is a" T. Note that this // Allow conversion from U to T provided U "is a" T. Note that this
// is separate from the (implicit) copy constructor. // is separate from the (implicit) copy constructor.
template <typename U> template <typename U>
WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) { WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) {}
}
T* get() const { return ref_.is_valid() ? ptr_ : NULL; } T* get() const { return ref_.is_valid() ? ptr_ : NULL; }
@ -280,18 +279,19 @@ class WeakPtr : public cef_internal::WeakPtrBase {
private: private:
// Explicitly declare comparison operators as required by the bool // Explicitly declare comparison operators as required by the bool
// trick, but keep them private. // trick, but keep them private.
template <class U> bool operator==(WeakPtr<U> const&) const; template <class U>
template <class U> bool operator!=(WeakPtr<U> const&) const; bool operator==(WeakPtr<U> const&) const;
template <class U>
bool operator!=(WeakPtr<U> const&) const;
friend class cef_internal::SupportsWeakPtrBase; friend class cef_internal::SupportsWeakPtrBase;
template <typename U> friend class WeakPtr; template <typename U>
friend class WeakPtr;
friend class SupportsWeakPtr<T>; friend class SupportsWeakPtr<T>;
friend class WeakPtrFactory<T>; friend class WeakPtrFactory<T>;
WeakPtr(const cef_internal::WeakReference& ref, T* ptr) WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
: WeakPtrBase(ref), : WeakPtrBase(ref), ptr_(ptr) {}
ptr_(ptr) {
}
// This pointer is only valid when ref_.is_valid() is true. Otherwise, its // This pointer is only valid when ref_.is_valid() is true. Otherwise, its
// value is undefined (as opposed to NULL). // value is undefined (as opposed to NULL).
@ -306,12 +306,9 @@ class WeakPtr : public cef_internal::WeakPtrBase {
template <class T> template <class T>
class WeakPtrFactory { class WeakPtrFactory {
public: public:
explicit WeakPtrFactory(T* ptr) : ptr_(ptr) { explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {}
}
~WeakPtrFactory() { ~WeakPtrFactory() { ptr_ = NULL; }
ptr_ = NULL;
}
WeakPtr<T> GetWeakPtr() { WeakPtr<T> GetWeakPtr() {
DCHECK(ptr_); DCHECK(ptr_);

15
include/base/internal/cef_atomicops_arm_gcc.h
View File

@ -103,7 +103,8 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
// reloop = 0 // reloop = 0
// if (prev_value != old_value) // if (prev_value != old_value)
// reloop = STREX(ptr, new_value) // reloop = STREX(ptr, new_value)
__asm__ __volatile__(" ldrex %0, [%3]\n" __asm__ __volatile__(
" ldrex %0, [%3]\n"
" mov %1, #0\n" " mov %1, #0\n"
" cmp %0, %4\n" " cmp %0, %4\n"
#ifdef __thumb2__ #ifdef __thumb2__
@ -143,7 +144,8 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
// value += increment // value += increment
// reloop = STREX(ptr, value) // reloop = STREX(ptr, value)
// //
__asm__ __volatile__(" ldrex %0, [%3]\n" __asm__ __volatile__(
" ldrex %0, [%3]\n"
" add %0, %0, %4\n" " add %0, %0, %4\n"
" strex %1, %0, [%3]\n" " strex %1, %0, [%3]\n"
: "=&r"(value), "=&r"(reloop), "+m"(*ptr) : "=&r"(value), "=&r"(reloop), "+m"(*ptr)
@ -171,7 +173,8 @@ inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
do { do {
// old_value = LDREX(ptr) // old_value = LDREX(ptr)
// reloop = STREX(ptr, new_value) // reloop = STREX(ptr, new_value)
__asm__ __volatile__(" ldrex %0, [%3]\n" __asm__ __volatile__(
" ldrex %0, [%3]\n"
" strex %1, %4, [%3]\n" " strex %1, %4, [%3]\n"
: "=&r"(old_value), "=&r"(reloop), "+m"(*ptr) : "=&r"(old_value), "=&r"(reloop), "+m"(*ptr)
: "r"(ptr), "r"(new_value) : "r"(ptr), "r"(new_value)
@ -281,7 +284,7 @@ inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
} }
#else #else
# error "Your CPU's ARM architecture is not supported yet" #error "Your CPU's ARM architecture is not supported yet"
#endif #endif
// NOTE: Atomicity of the following load and store operations is only // NOTE: Atomicity of the following load and store operations is only
@ -301,7 +304,9 @@ inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
*ptr = value; *ptr = value;
} }
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { return *ptr; } inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
return *ptr;
}
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
Atomic32 value = *ptr; Atomic32 value = *ptr;

34
include/base/internal/cef_atomicops_atomicword_compat.h
View File

@ -52,26 +52,26 @@ namespace subtle {
inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr, inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr,
AtomicWord old_value, AtomicWord old_value,
AtomicWord new_value) { AtomicWord new_value) {
return NoBarrier_CompareAndSwap( return NoBarrier_CompareAndSwap(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); old_value, new_value);
} }
inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr, inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr,
AtomicWord new_value) { AtomicWord new_value) {
return NoBarrier_AtomicExchange( return NoBarrier_AtomicExchange(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), new_value); new_value);
} }
inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr, inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr,
AtomicWord increment) { AtomicWord increment) {
return NoBarrier_AtomicIncrement( return NoBarrier_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), increment); increment);
} }
inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr, inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr,
AtomicWord increment) { AtomicWord increment) {
return Barrier_AtomicIncrement( return Barrier_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), increment); increment);
} }
inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr, inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
@ -88,24 +88,22 @@ inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value); reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
} }
inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) { inline void NoBarrier_Store(volatile AtomicWord* ptr, AtomicWord value) {
NoBarrier_Store( NoBarrier_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
reinterpret_cast<volatile Atomic32*>(ptr), value);
} }
inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) {
return base::subtle::Acquire_Store( return base::subtle::Acquire_Store(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), value); value);
} }
inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
return base::subtle::Release_Store( return base::subtle::Release_Store(reinterpret_cast<volatile Atomic32*>(ptr),
reinterpret_cast<volatile Atomic32*>(ptr), value); value);
} }
inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) { inline AtomicWord NoBarrier_Load(volatile const AtomicWord* ptr) {
return NoBarrier_Load( return NoBarrier_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
reinterpret_cast<volatile const Atomic32*>(ptr));
} }
inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {

39
include/base/internal/cef_atomicops_x86_gcc.h
View File

@ -41,8 +41,7 @@ struct AtomicOps_x86CPUFeatureStruct {
bool has_amd_lock_mb_bug; // Processor has AMD memory-barrier bug; do lfence bool has_amd_lock_mb_bug; // Processor has AMD memory-barrier bug; do lfence
// after acquire compare-and-swap. // after acquire compare-and-swap.
}; };
extern struct AtomicOps_x86CPUFeatureStruct extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures;
AtomicOps_Internalx86CPUFeatures;
#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") #define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
@ -56,8 +55,8 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
Atomic32 new_value) { Atomic32 new_value) {
Atomic32 prev; Atomic32 prev;
__asm__ __volatile__("lock; cmpxchgl %1,%2" __asm__ __volatile__("lock; cmpxchgl %1,%2"
: "=a" (prev) : "=a"(prev)
: "q" (new_value), "m" (*ptr), "0" (old_value) : "q"(new_value), "m"(*ptr), "0"(old_value)
: "memory"); : "memory");
return prev; return prev;
} }
@ -65,8 +64,8 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
Atomic32 new_value) { Atomic32 new_value) {
__asm__ __volatile__("xchgl %1,%0" // The lock prefix is implicit for xchg. __asm__ __volatile__("xchgl %1,%0" // The lock prefix is implicit for xchg.
: "=r" (new_value) : "=r"(new_value)
: "m" (*ptr), "0" (new_value) : "m"(*ptr), "0"(new_value)
: "memory"); : "memory");
return new_value; // Now it's the previous value. return new_value; // Now it's the previous value.
} }
@ -75,8 +74,9 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 increment) { Atomic32 increment) {
Atomic32 temp = increment; Atomic32 temp = increment;
__asm__ __volatile__("lock; xaddl %0,%1" __asm__ __volatile__("lock; xaddl %0,%1"
: "+r" (temp), "+m" (*ptr) : "+r"(temp), "+m"(*ptr)
: : "memory"); :
: "memory");
// temp now holds the old value of *ptr // temp now holds the old value of *ptr
return temp + increment; return temp + increment;
} }
@ -85,8 +85,9 @@ inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 increment) { Atomic32 increment) {
Atomic32 temp = increment; Atomic32 temp = increment;
__asm__ __volatile__("lock; xaddl %0,%1" __asm__ __volatile__("lock; xaddl %0,%1"
: "+r" (temp), "+m" (*ptr) : "+r"(temp), "+m"(*ptr)
: : "memory"); :
: "memory");
// temp now holds the old value of *ptr // temp now holds the old value of *ptr
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
__asm__ __volatile__("lfence" : : : "memory"); __asm__ __volatile__("lfence" : : : "memory");
@ -154,8 +155,8 @@ inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
Atomic64 new_value) { Atomic64 new_value) {
Atomic64 prev; Atomic64 prev;
__asm__ __volatile__("lock; cmpxchgq %1,%2" __asm__ __volatile__("lock; cmpxchgq %1,%2"
: "=a" (prev) : "=a"(prev)
: "q" (new_value), "m" (*ptr), "0" (old_value) : "q"(new_value), "m"(*ptr), "0"(old_value)
: "memory"); : "memory");
return prev; return prev;
} }
@ -163,8 +164,8 @@ inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
Atomic64 new_value) { Atomic64 new_value) {
__asm__ __volatile__("xchgq %1,%0" // The lock prefix is implicit for xchg. __asm__ __volatile__("xchgq %1,%0" // The lock prefix is implicit for xchg.
: "=r" (new_value) : "=r"(new_value)
: "m" (*ptr), "0" (new_value) : "m"(*ptr), "0"(new_value)
: "memory"); : "memory");
return new_value; // Now it's the previous value. return new_value; // Now it's the previous value.
} }
@ -173,8 +174,9 @@ inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 increment) { Atomic64 increment) {
Atomic64 temp = increment; Atomic64 temp = increment;
__asm__ __volatile__("lock; xaddq %0,%1" __asm__ __volatile__("lock; xaddq %0,%1"
: "+r" (temp), "+m" (*ptr) : "+r"(temp), "+m"(*ptr)
: : "memory"); :
: "memory");
// temp now contains the previous value of *ptr // temp now contains the previous value of *ptr
return temp + increment; return temp + increment;
} }
@ -183,8 +185,9 @@ inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 increment) { Atomic64 increment) {
Atomic64 temp = increment; Atomic64 temp = increment;
__asm__ __volatile__("lock; xaddq %0,%1" __asm__ __volatile__("lock; xaddq %0,%1"
: "+r" (temp), "+m" (*ptr) : "+r"(temp), "+m"(*ptr)
: : "memory"); :
: "memory");
// temp now contains the previous value of *ptr // temp now contains the previous value of *ptr
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
__asm__ __volatile__("lfence" : : : "memory"); __asm__ __volatile__("lfence" : : : "memory");

23
include/base/internal/cef_atomicops_x86_msvc.h
View File

@ -55,25 +55,23 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
Atomic32 old_value, Atomic32 old_value,
Atomic32 new_value) { Atomic32 new_value) {
LONG result = _InterlockedCompareExchange( LONG result = _InterlockedCompareExchange(
reinterpret_cast<volatile LONG*>(ptr), reinterpret_cast<volatile LONG*>(ptr), static_cast<LONG>(new_value),
static_cast<LONG>(new_value),
static_cast<LONG>(old_value)); static_cast<LONG>(old_value));
return static_cast<Atomic32>(result); return static_cast<Atomic32>(result);
} }
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
Atomic32 new_value) { Atomic32 new_value) {
LONG result = _InterlockedExchange( LONG result = _InterlockedExchange(reinterpret_cast<volatile LONG*>(ptr),
reinterpret_cast<volatile LONG*>(ptr),
static_cast<LONG>(new_value)); static_cast<LONG>(new_value));
return static_cast<Atomic32>(result); return static_cast<Atomic32>(result);
} }
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 increment) { Atomic32 increment) {
return _InterlockedExchangeAdd( return _InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
reinterpret_cast<volatile LONG*>(ptr), static_cast<LONG>(increment)) +
static_cast<LONG>(increment)) + increment; increment;
} }
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
@ -151,17 +149,17 @@ inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
Atomic64 new_value) { Atomic64 new_value) {
PVOID result = InterlockedExchangePointer( PVOID result =
reinterpret_cast<volatile PVOID*>(ptr), InterlockedExchangePointer(reinterpret_cast<volatile PVOID*>(ptr),
reinterpret_cast<PVOID>(new_value)); reinterpret_cast<PVOID>(new_value));
return reinterpret_cast<Atomic64>(result); return reinterpret_cast<Atomic64>(result);
} }
inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 increment) { Atomic64 increment) {
return InterlockedExchangeAdd64( return InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr),
reinterpret_cast<volatile LONGLONG*>(ptr), static_cast<LONGLONG>(increment)) +
static_cast<LONGLONG>(increment)) + increment; increment;
} }
inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
@ -215,7 +213,6 @@ inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
} }
#endif // defined(_WIN64) #endif // defined(_WIN64)
} // namespace base::subtle } // namespace base::subtle

1390
include/base/internal/cef_bind_internal.h
View File

File diff suppressed because it is too large Load Diff

230
include/base/internal/cef_bind_internal_win.h
View File

@ -48,85 +48,72 @@ class RunnableAdapter;
// __stdcall Function: Arity 0. // __stdcall Function: Arity 0.
template <typename R> template <typename R>
class RunnableAdapter<R(__stdcall *)()> { class RunnableAdapter<R(__stdcall*)()> {
public: public:
typedef R (RunType)(); typedef R(RunType)();
explicit RunnableAdapter(R(__stdcall *function)()) explicit RunnableAdapter(R(__stdcall* function)()) : function_(function) {}
: function_(function) {
}
R Run() { R Run() { return function_(); }
return function_();
}
private: private:
R (__stdcall *function_)(); R(__stdcall* function_)();
}; };
// __fastcall Function: Arity 0. // __fastcall Function: Arity 0.
template <typename R> template <typename R>
class RunnableAdapter<R(__fastcall *)()> { class RunnableAdapter<R(__fastcall*)()> {
public: public:
typedef R (RunType)(); typedef R(RunType)();
explicit RunnableAdapter(R(__fastcall *function)()) explicit RunnableAdapter(R(__fastcall* function)()) : function_(function) {}
: function_(function) {
}
R Run() { R Run() { return function_(); }
return function_();
}
private: private:
R (__fastcall *function_)(); R(__fastcall* function_)();
}; };
// __stdcall Function: Arity 1. // __stdcall Function: Arity 1.
template <typename R, typename A1> template <typename R, typename A1>
class RunnableAdapter<R(__stdcall *)(A1)> { class RunnableAdapter<R(__stdcall*)(A1)> {
public: public:
typedef R (RunType)(A1); typedef R(RunType)(A1);
explicit RunnableAdapter(R(__stdcall *function)(A1)) explicit RunnableAdapter(R(__stdcall* function)(A1)) : function_(function) {}
: function_(function) {
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1) { R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
return function_(a1); return function_(a1);
} }
private: private:
R (__stdcall *function_)(A1); R(__stdcall* function_)(A1);
}; };
// __fastcall Function: Arity 1. // __fastcall Function: Arity 1.
template <typename R, typename A1> template <typename R, typename A1>
class RunnableAdapter<R(__fastcall *)(A1)> { class RunnableAdapter<R(__fastcall*)(A1)> {
public: public:
typedef R (RunType)(A1); typedef R(RunType)(A1);
explicit RunnableAdapter(R(__fastcall *function)(A1)) explicit RunnableAdapter(R(__fastcall* function)(A1)) : function_(function) {}
: function_(function) {
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1) { R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
return function_(a1); return function_(a1);
} }
private: private:
R (__fastcall *function_)(A1); R(__fastcall* function_)(A1);
}; };
// __stdcall Function: Arity 2. // __stdcall Function: Arity 2.
template <typename R, typename A1, typename A2> template <typename R, typename A1, typename A2>
class RunnableAdapter<R(__stdcall *)(A1, A2)> { class RunnableAdapter<R(__stdcall*)(A1, A2)> {
public: public:
typedef R (RunType)(A1, A2); typedef R(RunType)(A1, A2);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2) { typename CallbackParamTraits<A2>::ForwardType a2) {
@ -134,18 +121,17 @@ class RunnableAdapter<R(__stdcall *)(A1, A2)> {
} }
private: private:
R (__stdcall *function_)(A1, A2); R(__stdcall* function_)(A1, A2);
}; };
// __fastcall Function: Arity 2. // __fastcall Function: Arity 2.
template <typename R, typename A1, typename A2> template <typename R, typename A1, typename A2>
class RunnableAdapter<R(__fastcall *)(A1, A2)> { class RunnableAdapter<R(__fastcall*)(A1, A2)> {
public: public:
typedef R (RunType)(A1, A2); typedef R(RunType)(A1, A2);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2) { typename CallbackParamTraits<A2>::ForwardType a2) {
@ -153,18 +139,17 @@ class RunnableAdapter<R(__fastcall *)(A1, A2)> {
} }
private: private:
R (__fastcall *function_)(A1, A2); R(__fastcall* function_)(A1, A2);
}; };
// __stdcall Function: Arity 3. // __stdcall Function: Arity 3.
template <typename R, typename A1, typename A2, typename A3> template <typename R, typename A1, typename A2, typename A3>
class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> { class RunnableAdapter<R(__stdcall*)(A1, A2, A3)> {
public: public:
typedef R (RunType)(A1, A2, A3); typedef R(RunType)(A1, A2, A3);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -173,18 +158,17 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
} }
private: private:
R (__stdcall *function_)(A1, A2, A3); R(__stdcall* function_)(A1, A2, A3);
}; };
// __fastcall Function: Arity 3. // __fastcall Function: Arity 3.
template <typename R, typename A1, typename A2, typename A3> template <typename R, typename A1, typename A2, typename A3>
class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> { class RunnableAdapter<R(__fastcall*)(A1, A2, A3)> {
public: public:
typedef R (RunType)(A1, A2, A3); typedef R(RunType)(A1, A2, A3);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -193,18 +177,17 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
} }
private: private:
R (__fastcall *function_)(A1, A2, A3); R(__fastcall* function_)(A1, A2, A3);
}; };
// __stdcall Function: Arity 4. // __stdcall Function: Arity 4.
template <typename R, typename A1, typename A2, typename A3, typename A4> template <typename R, typename A1, typename A2, typename A3, typename A4>
class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> { class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4); typedef R(RunType)(A1, A2, A3, A4);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -214,18 +197,17 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
} }
private: private:
R (__stdcall *function_)(A1, A2, A3, A4); R(__stdcall* function_)(A1, A2, A3, A4);
}; };
// __fastcall Function: Arity 4. // __fastcall Function: Arity 4.
template <typename R, typename A1, typename A2, typename A3, typename A4> template <typename R, typename A1, typename A2, typename A3, typename A4>
class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> { class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4); typedef R(RunType)(A1, A2, A3, A4);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -235,19 +217,22 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
} }
private: private:
R (__fastcall *function_)(A1, A2, A3, A4); R(__fastcall* function_)(A1, A2, A3, A4);
}; };
// __stdcall Function: Arity 5. // __stdcall Function: Arity 5.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5> typename A5>
class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> { class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5); typedef R(RunType)(A1, A2, A3, A4, A5);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -258,19 +243,22 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
} }
private: private:
R (__stdcall *function_)(A1, A2, A3, A4, A5); R(__stdcall* function_)(A1, A2, A3, A4, A5);
}; };
// __fastcall Function: Arity 5. // __fastcall Function: Arity 5.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5> typename A5>
class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> { class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5); typedef R(RunType)(A1, A2, A3, A4, A5);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -281,19 +269,23 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
} }
private: private:
R (__fastcall *function_)(A1, A2, A3, A4, A5); R(__fastcall* function_)(A1, A2, A3, A4, A5);
}; };
// __stdcall Function: Arity 6. // __stdcall Function: Arity 6.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6> typename A1,
class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> { typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5, A6); typedef R(RunType)(A1, A2, A3, A4, A5, A6);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5, A6))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -305,19 +297,23 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
} }
private: private:
R (__stdcall *function_)(A1, A2, A3, A4, A5, A6); R(__stdcall* function_)(A1, A2, A3, A4, A5, A6);
}; };
// __fastcall Function: Arity 6. // __fastcall Function: Arity 6.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6> typename A1,
class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> { typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5, A6); typedef R(RunType)(A1, A2, A3, A4, A5, A6);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5, A6))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -329,19 +325,24 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
} }
private: private:
R (__fastcall *function_)(A1, A2, A3, A4, A5, A6); R(__fastcall* function_)(A1, A2, A3, A4, A5, A6);
}; };
// __stdcall Function: Arity 7. // __stdcall Function: Arity 7.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6, typename A7> typename A1,
class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> { typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6, A7)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
explicit RunnableAdapter(R(__stdcall *function)(A1, A2, A3, A4, A5, A6, A7)) explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4, A5, A6, A7))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -354,19 +355,24 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> {
} }
private: private:
R (__stdcall *function_)(A1, A2, A3, A4, A5, A6, A7); R(__stdcall* function_)(A1, A2, A3, A4, A5, A6, A7);
}; };
// __fastcall Function: Arity 7. // __fastcall Function: Arity 7.
template <typename R, typename A1, typename A2, typename A3, typename A4, template <typename R,
typename A5, typename A6, typename A7> typename A1,
class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> { typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6, A7)> {
public: public:
typedef R (RunType)(A1, A2, A3, A4, A5, A6, A7); typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
explicit RunnableAdapter(R(__fastcall *function)(A1, A2, A3, A4, A5, A6, A7)) explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4, A5, A6, A7))
: function_(function) { : function_(function) {}
}
R Run(typename CallbackParamTraits<A1>::ForwardType a1, R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2, typename CallbackParamTraits<A2>::ForwardType a2,
@ -379,7 +385,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> {
} }
private: private:
R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7); R(__fastcall* function_)(A1, A2, A3, A4, A5, A6, A7);
}; };
} // namespace cef_internal } // namespace cef_internal

9
include/base/internal/cef_callback_internal.h
View File

@ -92,7 +92,7 @@ class CallbackBase {
// another type. It is not okay to use void*. We create a InvokeFuncStorage // another type. It is not okay to use void*. We create a InvokeFuncStorage
// that that can store our function pointer, and then cast it back to // that that can store our function pointer, and then cast it back to
// the original type on usage. // the original type on usage.
typedef void(*InvokeFuncStorage)(void); typedef void (*InvokeFuncStorage)(void);
// Returns true if this callback equals |other|. |other| may be null. // Returns true if this callback equals |other|. |other| may be null.
bool Equals(const CallbackBase& other) const; bool Equals(const CallbackBase& other) const;
@ -115,15 +115,16 @@ class CallbackBase {
// A helper template to determine if given type is non-const move-only-type, // A helper template to determine if given type is non-const move-only-type,
// i.e. if a value of the given type should be passed via .Pass() in a // i.e. if a value of the given type should be passed via .Pass() in a
// destructive way. // destructive way.
template <typename T> struct IsMoveOnlyType { template <typename T>
struct IsMoveOnlyType {
template <typename U> template <typename U>
static YesType Test(const typename U::MoveOnlyTypeForCPP03*); static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
template <typename U> template <typename U>
static NoType Test(...); static NoType Test(...);
static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) && static const bool value =
!is_const<T>::value; sizeof(Test<T>(0)) == sizeof(YesType) && !is_const<T>::value;
}; };
// This is a typetraits object that's used to take an argument type, and // This is a typetraits object that's used to take an argument type, and

87
include/base/internal/cef_raw_scoped_refptr_mismatch_checker.h
View File

@ -51,9 +51,7 @@ namespace cef_internal {
template <typename T> template <typename T>
struct NeedsScopedRefptrButGetsRawPtr { struct NeedsScopedRefptrButGetsRawPtr {
#if defined(OS_WIN) #if defined(OS_WIN)
enum { enum { value = base::false_type::value };
value = base::false_type::value
};
#else #else
enum { enum {
// Human readable translation: you needed to be a scoped_refptr if you are a // Human readable translation: you needed to be a scoped_refptr if you are a
@ -77,74 +75,103 @@ struct ParamsUseScopedRefptrCorrectly<Tuple0> {
}; };
template <typename A> template <typename A>
struct ParamsUseScopedRefptrCorrectly<Tuple1<A> > { struct ParamsUseScopedRefptrCorrectly<Tuple1<A>> {
enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value }; enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value };
}; };
template <typename A, typename B> template <typename A, typename B>
struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B> > { struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B>> {
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || enum {
NeedsScopedRefptrButGetsRawPtr<B>::value) }; value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value)
};
}; };
template <typename A, typename B, typename C> template <typename A, typename B, typename C>
struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C> > { struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C>> {
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value) }; NeedsScopedRefptrButGetsRawPtr<C>::value)
};
}; };
template <typename A, typename B, typename C, typename D> template <typename A, typename B, typename C, typename D>
struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D> > { struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D>> {
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value || NeedsScopedRefptrButGetsRawPtr<C>::value ||
NeedsScopedRefptrButGetsRawPtr<D>::value) }; NeedsScopedRefptrButGetsRawPtr<D>::value)
};
}; };
template <typename A, typename B, typename C, typename D, typename E> template <typename A, typename B, typename C, typename D, typename E>
struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E> > { struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E>> {
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value || NeedsScopedRefptrButGetsRawPtr<C>::value ||
NeedsScopedRefptrButGetsRawPtr<D>::value || NeedsScopedRefptrButGetsRawPtr<D>::value ||
NeedsScopedRefptrButGetsRawPtr<E>::value) }; NeedsScopedRefptrButGetsRawPtr<E>::value)
};
}; };
template <typename A, typename B, typename C, typename D, typename E, template <typename A,
typename B,
typename C,
typename D,
typename E,
typename F> typename F>
struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F> > { struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F>> {
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value || NeedsScopedRefptrButGetsRawPtr<C>::value ||
NeedsScopedRefptrButGetsRawPtr<D>::value || NeedsScopedRefptrButGetsRawPtr<D>::value ||
NeedsScopedRefptrButGetsRawPtr<E>::value || NeedsScopedRefptrButGetsRawPtr<E>::value ||
NeedsScopedRefptrButGetsRawPtr<F>::value) }; NeedsScopedRefptrButGetsRawPtr<F>::value)
};
}; };
template <typename A, typename B, typename C, typename D, typename E, template <typename A,
typename F, typename G> typename B,
struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G> > { typename C,
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || typename D,
typename E,
typename F,
typename G>
struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G>> {
enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value || NeedsScopedRefptrButGetsRawPtr<C>::value ||
NeedsScopedRefptrButGetsRawPtr<D>::value || NeedsScopedRefptrButGetsRawPtr<D>::value ||
NeedsScopedRefptrButGetsRawPtr<E>::value || NeedsScopedRefptrButGetsRawPtr<E>::value ||
NeedsScopedRefptrButGetsRawPtr<F>::value || NeedsScopedRefptrButGetsRawPtr<F>::value ||
NeedsScopedRefptrButGetsRawPtr<G>::value) }; NeedsScopedRefptrButGetsRawPtr<G>::value)
};
}; };
template <typename A, typename B, typename C, typename D, typename E, template <typename A,
typename F, typename G, typename H> typename B,
struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H> > { typename C,
enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value || typename D,
typename E,
typename F,
typename G,
typename H>
struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H>> {
enum {
value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
NeedsScopedRefptrButGetsRawPtr<B>::value || NeedsScopedRefptrButGetsRawPtr<B>::value ||
NeedsScopedRefptrButGetsRawPtr<C>::value || NeedsScopedRefptrButGetsRawPtr<C>::value ||
NeedsScopedRefptrButGetsRawPtr<D>::value || NeedsScopedRefptrButGetsRawPtr<D>::value ||
NeedsScopedRefptrButGetsRawPtr<E>::value || NeedsScopedRefptrButGetsRawPtr<E>::value ||
NeedsScopedRefptrButGetsRawPtr<F>::value || NeedsScopedRefptrButGetsRawPtr<F>::value ||
NeedsScopedRefptrButGetsRawPtr<G>::value || NeedsScopedRefptrButGetsRawPtr<G>::value ||
NeedsScopedRefptrButGetsRawPtr<H>::value) }; NeedsScopedRefptrButGetsRawPtr<H>::value)
};
}; };
} // namespace cef_internal } // namespace cef_internal

14
include/capi/cef_accessibility_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=ade29136d75b33f63cf65db4b91de9cd66114562$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to receive accessibility notification when // Implement this structure to receive accessibility notification when
// accessibility events have been registered. The functions of this structure // accessibility events have been registered. The functions of this structure
@ -60,18 +61,19 @@ typedef struct _cef_accessibility_handler_t {
// Called after renderer process sends accessibility tree changes to the // Called after renderer process sends accessibility tree changes to the
// browser process. // browser process.
/// ///
void (CEF_CALLBACK *on_accessibility_tree_change)( void(CEF_CALLBACK* on_accessibility_tree_change)(
struct _cef_accessibility_handler_t* self, struct _cef_value_t* value); struct _cef_accessibility_handler_t* self,
struct _cef_value_t* value);
/// ///
// Called after renderer process sends accessibility location changes to the // Called after renderer process sends accessibility location changes to the
// browser process. // browser process.
/// ///
void (CEF_CALLBACK *on_accessibility_location_change)( void(CEF_CALLBACK* on_accessibility_location_change)(
struct _cef_accessibility_handler_t* self, struct _cef_value_t* value); struct _cef_accessibility_handler_t* self,
struct _cef_value_t* value);
} cef_accessibility_handler_t; } cef_accessibility_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

29
include/capi/cef_app_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=52ce63b881a6e3d2d13a39b81ad2626f366fc130$
//
#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@ -72,8 +74,9 @@ typedef struct _cef_app_t {
// modify command-line arguments for non-browser processes as this may result // modify command-line arguments for non-browser processes as this may result
// in undefined behavior including crashes. // in undefined behavior including crashes.
/// ///
void (CEF_CALLBACK *on_before_command_line_processing)( void(CEF_CALLBACK* on_before_command_line_processing)(
struct _cef_app_t* self, const cef_string_t* process_type, struct _cef_app_t* self,
const cef_string_t* process_type,
struct _cef_command_line_t* command_line); struct _cef_command_line_t* command_line);
/// ///
@ -82,7 +85,8 @@ typedef struct _cef_app_t {
// each process and the registered schemes should be the same across all // each process and the registered schemes should be the same across all
// processes. // processes.
/// ///
void (CEF_CALLBACK *on_register_custom_schemes)(struct _cef_app_t* self, void(CEF_CALLBACK* on_register_custom_schemes)(
struct _cef_app_t* self,
struct _cef_scheme_registrar_t* registrar); struct _cef_scheme_registrar_t* registrar);
/// ///
@ -91,25 +95,24 @@ typedef struct _cef_app_t {
// If no handler is returned resources will be loaded from pack files. This // If no handler is returned resources will be loaded from pack files. This
// function is called by the browser and render processes on multiple threads. // function is called by the browser and render processes on multiple threads.
/// ///
struct _cef_resource_bundle_handler_t* ( struct _cef_resource_bundle_handler_t*(
CEF_CALLBACK *get_resource_bundle_handler)(struct _cef_app_t* self); CEF_CALLBACK* get_resource_bundle_handler)(struct _cef_app_t* self);
/// ///
// Return the handler for functionality specific to the browser process. This // Return the handler for functionality specific to the browser process. This
// function is called on multiple threads in the browser process. // function is called on multiple threads in the browser process.
/// ///
struct _cef_browser_process_handler_t* ( struct _cef_browser_process_handler_t*(
CEF_CALLBACK *get_browser_process_handler)(struct _cef_app_t* self); CEF_CALLBACK* get_browser_process_handler)(struct _cef_app_t* self);
/// ///
// Return the handler for functionality specific to the render process. This // Return the handler for functionality specific to the render process. This
// function is called on the render process main thread. // function is called on the render process main thread.
/// ///
struct _cef_render_process_handler_t* ( struct _cef_render_process_handler_t*(
CEF_CALLBACK *get_render_process_handler)(struct _cef_app_t* self); CEF_CALLBACK* get_render_process_handler)(struct _cef_app_t* self);
} cef_app_t; } cef_app_t;
/// ///
// This function should be called from the application entry point function to // This function should be called from the application entry point function to
// execute a secondary process. It can be used to run secondary processes from // execute a secondary process. It can be used to run secondary processes from
@ -123,7 +126,8 @@ typedef struct _cef_app_t {
// cef_sandbox_win.h for details). // cef_sandbox_win.h for details).
/// ///
CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args, CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
cef_app_t* application, void* windows_sandbox_info); cef_app_t* application,
void* windows_sandbox_info);
/// ///
// This function should be called on the main application thread to initialize // This function should be called on the main application thread to initialize
@ -133,7 +137,8 @@ CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
// be NULL (see cef_sandbox_win.h for details). // be NULL (see cef_sandbox_win.h for details).
/// ///
CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args, CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
const struct _cef_settings_t* settings, cef_app_t* application, const struct _cef_settings_t* settings,
cef_app_t* application,
void* windows_sandbox_info); void* windows_sandbox_info);
/// ///

11
include/capi/cef_auth_callback_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=639d58245ecd39624d39ee8b49e0e4e056d1c4ed$
//
#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure used for asynchronous continuation of authentication // Callback structure used for asynchronous continuation of authentication
// requests. // requests.
@ -58,16 +59,16 @@ typedef struct _cef_auth_callback_t {
/// ///
// Continue the authentication request. // Continue the authentication request.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_auth_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_auth_callback_t* self,
const cef_string_t* username, const cef_string_t* password); const cef_string_t* username,
const cef_string_t* password);
/// ///
// Cancel the authentication request. // Cancel the authentication request.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_auth_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self);
} cef_auth_callback_t; } cef_auth_callback_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

16
include/capi/cef_base_capi.h
View File

@ -27,7 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
@ -57,22 +56,21 @@ typedef struct _cef_base_ref_counted_t {
// Called to increment the reference count for the object. Should be called // Called to increment the reference count for the object. Should be called
// for every new copy of a pointer to a given object. // for every new copy of a pointer to a given object.
/// ///
void (CEF_CALLBACK *add_ref)(struct _cef_base_ref_counted_t* self); void(CEF_CALLBACK* add_ref)(struct _cef_base_ref_counted_t* self);
/// ///
// Called to decrement the reference count for the object. If the reference // Called to decrement the reference count for the object. If the reference
// count falls to 0 the object should self-delete. Returns true (1) if the // count falls to 0 the object should self-delete. Returns true (1) if the
// resulting reference count is 0. // resulting reference count is 0.
/// ///
int (CEF_CALLBACK *release)(struct _cef_base_ref_counted_t* self); int(CEF_CALLBACK* release)(struct _cef_base_ref_counted_t* self);
/// ///
// Returns true (1) if the current reference count is 1. // Returns true (1) if the current reference count is 1.
/// ///
int (CEF_CALLBACK *has_one_ref)(struct _cef_base_ref_counted_t* self); int(CEF_CALLBACK* has_one_ref)(struct _cef_base_ref_counted_t* self);
} cef_base_ref_counted_t; } cef_base_ref_counted_t;
/// ///
// All scoped framework structures must include this structure first. // All scoped framework structures must include this structure first.
/// ///
@ -85,20 +83,18 @@ typedef struct _cef_base_scoped_t {
/// ///
// Called to delete this object. May be NULL if the object is not owned. // Called to delete this object. May be NULL if the object is not owned.
/// ///
void (CEF_CALLBACK *del)(struct _cef_base_scoped_t* self); void(CEF_CALLBACK* del)(struct _cef_base_scoped_t* self);
} cef_base_scoped_t; } cef_base_scoped_t;
// Check that the structure |s|, which is defined with a size_t member at the // Check that the structure |s|, which is defined with a size_t member at the
// top, is large enough to contain the specified member |f|. // top, is large enough to contain the specified member |f|.
#define CEF_MEMBER_EXISTS(s, f) \ #define CEF_MEMBER_EXISTS(s, f) \
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \ ((intptr_t) & \
*reinterpret_cast<size_t*>(s)) ((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= *reinterpret_cast<size_t*>(s))
#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f)) #define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

260
include/capi/cef_browser_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=b6308ab5e97eb9f7af95f1f4c371fd6e7edbf852$
//
#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@ -69,122 +71,124 @@ typedef struct _cef_browser_t {
// Returns the browser host object. This function can only be called in the // Returns the browser host object. This function can only be called in the
// browser process. // browser process.
/// ///
struct _cef_browser_host_t* (CEF_CALLBACK *get_host)( struct _cef_browser_host_t*(CEF_CALLBACK* get_host)(
struct _cef_browser_t* self); struct _cef_browser_t* self);
/// ///
// Returns true (1) if the browser can navigate backwards. // Returns true (1) if the browser can navigate backwards.
/// ///
int (CEF_CALLBACK *can_go_back)(struct _cef_browser_t* self); int(CEF_CALLBACK* can_go_back)(struct _cef_browser_t* self);
/// ///
// Navigate backwards. // Navigate backwards.
/// ///
void (CEF_CALLBACK *go_back)(struct _cef_browser_t* self); void(CEF_CALLBACK* go_back)(struct _cef_browser_t* self);
/// ///
// Returns true (1) if the browser can navigate forwards. // Returns true (1) if the browser can navigate forwards.
/// ///
int (CEF_CALLBACK *can_go_forward)(struct _cef_browser_t* self); int(CEF_CALLBACK* can_go_forward)(struct _cef_browser_t* self);
/// ///
// Navigate forwards. // Navigate forwards.
/// ///
void (CEF_CALLBACK *go_forward)(struct _cef_browser_t* self); void(CEF_CALLBACK* go_forward)(struct _cef_browser_t* self);
/// ///
// Returns true (1) if the browser is currently loading. // Returns true (1) if the browser is currently loading.
/// ///
int (CEF_CALLBACK *is_loading)(struct _cef_browser_t* self); int(CEF_CALLBACK* is_loading)(struct _cef_browser_t* self);
/// ///
// Reload the current page. // Reload the current page.
/// ///
void (CEF_CALLBACK *reload)(struct _cef_browser_t* self); void(CEF_CALLBACK* reload)(struct _cef_browser_t* self);
/// ///
// Reload the current page ignoring any cached data. // Reload the current page ignoring any cached data.
/// ///
void (CEF_CALLBACK *reload_ignore_cache)(struct _cef_browser_t* self); void(CEF_CALLBACK* reload_ignore_cache)(struct _cef_browser_t* self);
/// ///
// Stop loading the page. // Stop loading the page.
/// ///
void (CEF_CALLBACK *stop_load)(struct _cef_browser_t* self); void(CEF_CALLBACK* stop_load)(struct _cef_browser_t* self);
/// ///
// Returns the globally unique identifier for this browser. // Returns the globally unique identifier for this browser.
/// ///
int (CEF_CALLBACK *get_identifier)(struct _cef_browser_t* self); int(CEF_CALLBACK* get_identifier)(struct _cef_browser_t* self);
/// ///
// Returns true (1) if this object is pointing to the same handle as |that| // Returns true (1) if this object is pointing to the same handle as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_browser_t* self, int(CEF_CALLBACK* is_same)(struct _cef_browser_t* self,
struct _cef_browser_t* that); struct _cef_browser_t* that);
/// ///
// Returns true (1) if the window is a popup window. // Returns true (1) if the window is a popup window.
/// ///
int (CEF_CALLBACK *is_popup)(struct _cef_browser_t* self); int(CEF_CALLBACK* is_popup)(struct _cef_browser_t* self);
/// ///
// Returns true (1) if a document has been loaded in the browser. // Returns true (1) if a document has been loaded in the browser.
/// ///
int (CEF_CALLBACK *has_document)(struct _cef_browser_t* self); int(CEF_CALLBACK* has_document)(struct _cef_browser_t* self);
/// ///
// Returns the main (top-level) frame for the browser window. // Returns the main (top-level) frame for the browser window.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_main_frame)( struct _cef_frame_t*(CEF_CALLBACK* get_main_frame)(
struct _cef_browser_t* self); struct _cef_browser_t* self);
/// ///
// Returns the focused frame for the browser window. // Returns the focused frame for the browser window.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_focused_frame)( struct _cef_frame_t*(CEF_CALLBACK* get_focused_frame)(
struct _cef_browser_t* self); struct _cef_browser_t* self);
/// ///
// Returns the frame with the specified identifier, or NULL if not found. // Returns the frame with the specified identifier, or NULL if not found.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_frame_byident)( struct _cef_frame_t*(CEF_CALLBACK* get_frame_byident)(
struct _cef_browser_t* self, int64 identifier); struct _cef_browser_t* self,
int64 identifier);
/// ///
// Returns the frame with the specified name, or NULL if not found. // Returns the frame with the specified name, or NULL if not found.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_browser_t* self, struct _cef_frame_t*(CEF_CALLBACK* get_frame)(struct _cef_browser_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
// Returns the number of frames that currently exist. // Returns the number of frames that currently exist.
/// ///
size_t (CEF_CALLBACK *get_frame_count)(struct _cef_browser_t* self); size_t(CEF_CALLBACK* get_frame_count)(struct _cef_browser_t* self);
/// ///
// Returns the identifiers of all existing frames. // Returns the identifiers of all existing frames.
/// ///
void (CEF_CALLBACK *get_frame_identifiers)(struct _cef_browser_t* self, void(CEF_CALLBACK* get_frame_identifiers)(struct _cef_browser_t* self,
size_t* identifiersCount, int64* identifiers); size_t* identifiersCount,
int64* identifiers);
/// ///
// Returns the names of all existing frames. // Returns the names of all existing frames.
/// ///
void (CEF_CALLBACK *get_frame_names)(struct _cef_browser_t* self, void(CEF_CALLBACK* get_frame_names)(struct _cef_browser_t* self,
cef_string_list_t names); cef_string_list_t names);
/// ///
// Send a message to the specified |target_process|. Returns true (1) if the // Send a message to the specified |target_process|. Returns true (1) if the
// message was sent successfully. // message was sent successfully.
/// ///
int (CEF_CALLBACK *send_process_message)(struct _cef_browser_t* self, int(CEF_CALLBACK* send_process_message)(
struct _cef_browser_t* self,
cef_process_id_t target_process, cef_process_id_t target_process,
struct _cef_process_message_t* message); struct _cef_process_message_t* message);
} cef_browser_t; } cef_browser_t;
/// ///
// Callback structure for cef_browser_host_t::RunFileDialog. The functions of // Callback structure for cef_browser_host_t::RunFileDialog. The functions of
// this structure will be called on the browser process UI thread. // this structure will be called on the browser process UI thread.
@ -202,12 +206,12 @@ typedef struct _cef_run_file_dialog_callback_t {
// |file_paths| will be a single value or a list of values depending on the // |file_paths| will be a single value or a list of values depending on the
// dialog mode. If the selection was cancelled |file_paths| will be NULL. // dialog mode. If the selection was cancelled |file_paths| will be NULL.
/// ///
void (CEF_CALLBACK *on_file_dialog_dismissed)( void(CEF_CALLBACK* on_file_dialog_dismissed)(
struct _cef_run_file_dialog_callback_t* self, int selected_accept_filter, struct _cef_run_file_dialog_callback_t* self,
int selected_accept_filter,
cef_string_list_t file_paths); cef_string_list_t file_paths);
} cef_run_file_dialog_callback_t; } cef_run_file_dialog_callback_t;
/// ///
// Callback structure for cef_browser_host_t::GetNavigationEntries. The // Callback structure for cef_browser_host_t::GetNavigationEntries. The
// functions of this structure will be called on the browser process UI thread. // functions of this structure will be called on the browser process UI thread.
@ -225,12 +229,13 @@ typedef struct _cef_navigation_entry_visitor_t {
// navigation entry. |index| is the 0-based index of this entry and |total| is // navigation entry. |index| is the 0-based index of this entry and |total| is
// the total number of entries. // the total number of entries.
/// ///
int (CEF_CALLBACK *visit)(struct _cef_navigation_entry_visitor_t* self, int(CEF_CALLBACK* visit)(struct _cef_navigation_entry_visitor_t* self,
struct _cef_navigation_entry_t* entry, int current, int index, struct _cef_navigation_entry_t* entry,
int current,
int index,
int total); int total);
} cef_navigation_entry_visitor_t; } cef_navigation_entry_visitor_t;
/// ///
// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this // Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
// structure will be called on the browser process UI thread. // structure will be called on the browser process UI thread.
@ -246,12 +251,12 @@ typedef struct _cef_pdf_print_callback_t {
// the output path. |ok| will be true (1) if the printing completed // the output path. |ok| will be true (1) if the printing completed
// successfully or false (0) otherwise. // successfully or false (0) otherwise.
/// ///
void (CEF_CALLBACK *on_pdf_print_finished)( void(CEF_CALLBACK* on_pdf_print_finished)(
struct _cef_pdf_print_callback_t* self, const cef_string_t* path, struct _cef_pdf_print_callback_t* self,
const cef_string_t* path,
int ok); int ok);
} cef_pdf_print_callback_t; } cef_pdf_print_callback_t;
/// ///
// Callback structure for cef_browser_host_t::DownloadImage. The functions of // Callback structure for cef_browser_host_t::DownloadImage. The functions of
// this structure will be called on the browser process UI thread. // this structure will be called on the browser process UI thread.
@ -268,13 +273,13 @@ typedef struct _cef_download_image_callback_t {
// resulting HTTP status code. |image| is the resulting image, possibly at // resulting HTTP status code. |image| is the resulting image, possibly at
// multiple scale factors, or NULL if the download failed. // multiple scale factors, or NULL if the download failed.
/// ///
void (CEF_CALLBACK *on_download_image_finished)( void(CEF_CALLBACK* on_download_image_finished)(
struct _cef_download_image_callback_t* self, struct _cef_download_image_callback_t* self,
const cef_string_t* image_url, int http_status_code, const cef_string_t* image_url,
int http_status_code,
struct _cef_image_t* image); struct _cef_image_t* image);
} cef_download_image_callback_t; } cef_download_image_callback_t;
/// ///
// Structure used to represent the browser process aspects of a browser window. // Structure used to represent the browser process aspects of a browser window.
// The functions of this structure can only be called in the browser process. // The functions of this structure can only be called in the browser process.
@ -290,7 +295,7 @@ typedef struct _cef_browser_host_t {
/// ///
// Returns the hosted browser object. // Returns the hosted browser object.
/// ///
struct _cef_browser_t* (CEF_CALLBACK *get_browser)( struct _cef_browser_t*(CEF_CALLBACK* get_browser)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -303,7 +308,7 @@ typedef struct _cef_browser_host_t {
// cef_life_span_handler_t::do_close() documentation for additional usage // cef_life_span_handler_t::do_close() documentation for additional usage
// information. // information.
/// ///
void (CEF_CALLBACK *close_browser)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* close_browser)(struct _cef_browser_host_t* self,
int force_close); int force_close);
/// ///
@ -314,19 +319,19 @@ typedef struct _cef_browser_host_t {
// and cef_life_span_handler_t::do_close() documentation for additional usage // and cef_life_span_handler_t::do_close() documentation for additional usage
// information. This function must be called on the browser process UI thread. // information. This function must be called on the browser process UI thread.
/// ///
int (CEF_CALLBACK *try_close_browser)(struct _cef_browser_host_t* self); int(CEF_CALLBACK* try_close_browser)(struct _cef_browser_host_t* self);
/// ///
// Set whether the browser is focused. // Set whether the browser is focused.
/// ///
void (CEF_CALLBACK *set_focus)(struct _cef_browser_host_t* self, int focus); void(CEF_CALLBACK* set_focus)(struct _cef_browser_host_t* self, int focus);
/// ///
// Retrieve the window handle for this browser. If this browser is wrapped in // Retrieve the window handle for this browser. If this browser is wrapped in
// a cef_browser_view_t this function should be called on the browser process // a cef_browser_view_t this function should be called on the browser process
// UI thread and it will return the handle for the top-level native window. // UI thread and it will return the handle for the top-level native window.
/// ///
cef_window_handle_t (CEF_CALLBACK *get_window_handle)( cef_window_handle_t(CEF_CALLBACK* get_window_handle)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -335,38 +340,38 @@ typedef struct _cef_browser_host_t {
// cef_browser_view_t. This function can be used in combination with custom // cef_browser_view_t. This function can be used in combination with custom
// handling of modal windows. // handling of modal windows.
/// ///
cef_window_handle_t (CEF_CALLBACK *get_opener_window_handle)( cef_window_handle_t(CEF_CALLBACK* get_opener_window_handle)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
// Returns true (1) if this browser is wrapped in a cef_browser_view_t. // Returns true (1) if this browser is wrapped in a cef_browser_view_t.
/// ///
int (CEF_CALLBACK *has_view)(struct _cef_browser_host_t* self); int(CEF_CALLBACK* has_view)(struct _cef_browser_host_t* self);
/// ///
// Returns the client for this browser. // Returns the client for this browser.
/// ///
struct _cef_client_t* (CEF_CALLBACK *get_client)( struct _cef_client_t*(CEF_CALLBACK* get_client)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
// Returns the request context for this browser. // Returns the request context for this browser.
/// ///
struct _cef_request_context_t* (CEF_CALLBACK *get_request_context)( struct _cef_request_context_t*(CEF_CALLBACK* get_request_context)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
// Get the current zoom level. The default zoom level is 0.0. This function // Get the current zoom level. The default zoom level is 0.0. This function
// can only be called on the UI thread. // can only be called on the UI thread.
/// ///
double (CEF_CALLBACK *get_zoom_level)(struct _cef_browser_host_t* self); double(CEF_CALLBACK* get_zoom_level)(struct _cef_browser_host_t* self);
/// ///
// Change the zoom level to the specified value. Specify 0.0 to reset the zoom // Change the zoom level to the specified value. Specify 0.0 to reset the zoom
// level. If called on the UI thread the change will be applied immediately. // level. If called on the UI thread the change will be applied immediately.
// Otherwise, the change will be applied asynchronously on the UI thread. // Otherwise, the change will be applied asynchronously on the UI thread.
/// ///
void (CEF_CALLBACK *set_zoom_level)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* set_zoom_level)(struct _cef_browser_host_t* self,
double zoomLevel); double zoomLevel);
/// ///
@ -385,16 +390,19 @@ typedef struct _cef_browser_host_t {
// dismissed or immediately if another dialog is already pending. The dialog // dismissed or immediately if another dialog is already pending. The dialog
// will be initiated asynchronously on the UI thread. // will be initiated asynchronously on the UI thread.
/// ///
void (CEF_CALLBACK *run_file_dialog)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* run_file_dialog)(
cef_file_dialog_mode_t mode, const cef_string_t* title, struct _cef_browser_host_t* self,
const cef_string_t* default_file_path, cef_string_list_t accept_filters, cef_file_dialog_mode_t mode,
const cef_string_t* title,
const cef_string_t* default_file_path,
cef_string_list_t accept_filters,
int selected_accept_filter, int selected_accept_filter,
struct _cef_run_file_dialog_callback_t* callback); struct _cef_run_file_dialog_callback_t* callback);
/// ///
// Download the file at |url| using cef_download_handler_t. // Download the file at |url| using cef_download_handler_t.
/// ///
void (CEF_CALLBACK *start_download)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* start_download)(struct _cef_browser_host_t* self,
const cef_string_t* url); const cef_string_t* url);
/// ///
@ -409,14 +417,18 @@ typedef struct _cef_browser_host_t {
// unlimited. If |bypass_cache| is true (1) then |image_url| is requested from // unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
// the server even if it is present in the browser cache. // the server even if it is present in the browser cache.
/// ///
void (CEF_CALLBACK *download_image)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* download_image)(
const cef_string_t* image_url, int is_favicon, uint32 max_image_size, struct _cef_browser_host_t* self,
int bypass_cache, struct _cef_download_image_callback_t* callback); const cef_string_t* image_url,
int is_favicon,
uint32 max_image_size,
int bypass_cache,
struct _cef_download_image_callback_t* callback);
/// ///
// Print the current browser contents. // Print the current browser contents.
/// ///
void (CEF_CALLBACK *print)(struct _cef_browser_host_t* self); void(CEF_CALLBACK* print)(struct _cef_browser_host_t* self);
/// ///
// Print the current browser contents to the PDF file specified by |path| and // Print the current browser contents to the PDF file specified by |path| and
@ -424,7 +436,8 @@ typedef struct _cef_browser_host_t {
// |path| when done. For PDF printing to work on Linux you must implement the // |path| when done. For PDF printing to work on Linux you must implement the
// cef_print_handler_t::GetPdfPaperSize function. // cef_print_handler_t::GetPdfPaperSize function.
/// ///
void (CEF_CALLBACK *print_to_pdf)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* print_to_pdf)(
struct _cef_browser_host_t* self,
const cef_string_t* path, const cef_string_t* path,
const struct _cef_pdf_print_settings_t* settings, const struct _cef_pdf_print_settings_t* settings,
struct _cef_pdf_print_callback_t* callback); struct _cef_pdf_print_callback_t* callback);
@ -440,14 +453,17 @@ typedef struct _cef_browser_host_t {
// instance, if any, returned via cef_client_t::GetFindHandler will be called // instance, if any, returned via cef_client_t::GetFindHandler will be called
// to report find results. // to report find results.
/// ///
void (CEF_CALLBACK *find)(struct _cef_browser_host_t* self, int identifier, void(CEF_CALLBACK* find)(struct _cef_browser_host_t* self,
const cef_string_t* searchText, int forward, int matchCase, int identifier,
const cef_string_t* searchText,
int forward,
int matchCase,
int findNext); int findNext);
/// ///
// Cancel all searches that are currently going on. // Cancel all searches that are currently going on.
/// ///
void (CEF_CALLBACK *stop_finding)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* stop_finding)(struct _cef_browser_host_t* self,
int clearSelection); int clearSelection);
/// ///
@ -459,7 +475,8 @@ typedef struct _cef_browser_host_t {
// inspected. The |windowInfo| parameter will be ignored if this browser is // inspected. The |windowInfo| parameter will be ignored if this browser is
// wrapped in a cef_browser_view_t. // wrapped in a cef_browser_view_t.
/// ///
void (CEF_CALLBACK *show_dev_tools)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* show_dev_tools)(
struct _cef_browser_host_t* self,
const struct _cef_window_info_t* windowInfo, const struct _cef_window_info_t* windowInfo,
struct _cef_client_t* client, struct _cef_client_t* client,
const struct _cef_browser_settings_t* settings, const struct _cef_browser_settings_t* settings,
@ -468,13 +485,13 @@ typedef struct _cef_browser_host_t {
/// ///
// Explicitly close the associated DevTools browser, if any. // Explicitly close the associated DevTools browser, if any.
/// ///
void (CEF_CALLBACK *close_dev_tools)(struct _cef_browser_host_t* self); void(CEF_CALLBACK* close_dev_tools)(struct _cef_browser_host_t* self);
/// ///
// Returns true (1) if this browser currently has an associated DevTools // Returns true (1) if this browser currently has an associated DevTools
// browser. Must be called on the browser process UI thread. // browser. Must be called on the browser process UI thread.
/// ///
int (CEF_CALLBACK *has_dev_tools)(struct _cef_browser_host_t* self); int(CEF_CALLBACK* has_dev_tools)(struct _cef_browser_host_t* self);
/// ///
// Retrieve a snapshot of current navigation entries as values sent to the // Retrieve a snapshot of current navigation entries as values sent to the
@ -482,38 +499,41 @@ typedef struct _cef_browser_host_t {
// navigation entry will be sent, otherwise all navigation entries will be // navigation entry will be sent, otherwise all navigation entries will be
// sent. // sent.
/// ///
void (CEF_CALLBACK *get_navigation_entries)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* get_navigation_entries)(
struct _cef_navigation_entry_visitor_t* visitor, int current_only); struct _cef_browser_host_t* self,
struct _cef_navigation_entry_visitor_t* visitor,
int current_only);
/// ///
// Set whether mouse cursor change is disabled. // Set whether mouse cursor change is disabled.
/// ///
void (CEF_CALLBACK *set_mouse_cursor_change_disabled)( void(CEF_CALLBACK* set_mouse_cursor_change_disabled)(
struct _cef_browser_host_t* self, int disabled); struct _cef_browser_host_t* self,
int disabled);
/// ///
// Returns true (1) if mouse cursor change is disabled. // Returns true (1) if mouse cursor change is disabled.
/// ///
int (CEF_CALLBACK *is_mouse_cursor_change_disabled)( int(CEF_CALLBACK* is_mouse_cursor_change_disabled)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
// If a misspelled word is currently selected in an editable node calling this // If a misspelled word is currently selected in an editable node calling this
// function will replace it with the specified |word|. // function will replace it with the specified |word|.
/// ///
void (CEF_CALLBACK *replace_misspelling)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* replace_misspelling)(struct _cef_browser_host_t* self,
const cef_string_t* word); const cef_string_t* word);
/// ///
// Add the specified |word| to the spelling dictionary. // Add the specified |word| to the spelling dictionary.
/// ///
void (CEF_CALLBACK *add_word_to_dictionary)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* add_word_to_dictionary)(struct _cef_browser_host_t* self,
const cef_string_t* word); const cef_string_t* word);
/// ///
// Returns true (1) if window rendering is disabled. // Returns true (1) if window rendering is disabled.
/// ///
int (CEF_CALLBACK *is_window_rendering_disabled)( int(CEF_CALLBACK* is_window_rendering_disabled)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -522,14 +542,14 @@ typedef struct _cef_browser_host_t {
// cef_render_handler_t::OnPaint asynchronously with the updated regions. This // cef_render_handler_t::OnPaint asynchronously with the updated regions. This
// function is only used when window rendering is disabled. // function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *was_resized)(struct _cef_browser_host_t* self); void(CEF_CALLBACK* was_resized)(struct _cef_browser_host_t* self);
/// ///
// Notify the browser that it has been hidden or shown. Layouting and // Notify the browser that it has been hidden or shown. Layouting and
// cef_render_handler_t::OnPaint notification will stop when the browser is // cef_render_handler_t::OnPaint notification will stop when the browser is
// hidden. This function is only used when window rendering is disabled. // hidden. This function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *was_hidden)(struct _cef_browser_host_t* self, int hidden); void(CEF_CALLBACK* was_hidden)(struct _cef_browser_host_t* self, int hidden);
/// ///
// Send a notification to the browser that the screen info has changed. The // Send a notification to the browser that the screen info has changed. The
@ -539,7 +559,7 @@ typedef struct _cef_browser_host_t {
// current display. This function is only used when window rendering is // current display. This function is only used when window rendering is
// disabled. // disabled.
/// ///
void (CEF_CALLBACK *notify_screen_info_changed)( void(CEF_CALLBACK* notify_screen_info_changed)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -547,29 +567,34 @@ typedef struct _cef_browser_host_t {
// asynchronously. This function is only used when window rendering is // asynchronously. This function is only used when window rendering is
// disabled. // disabled.
/// ///
void (CEF_CALLBACK *invalidate)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* invalidate)(struct _cef_browser_host_t* self,
cef_paint_element_type_t type); cef_paint_element_type_t type);
/// ///
// Send a key event to the browser. // Send a key event to the browser.
/// ///
void (CEF_CALLBACK *send_key_event)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* send_key_event)(struct _cef_browser_host_t* self,
const struct _cef_key_event_t* event); const struct _cef_key_event_t* event);
/// ///
// Send a mouse click event to the browser. The |x| and |y| coordinates are // Send a mouse click event to the browser. The |x| and |y| coordinates are
// relative to the upper-left corner of the view. // relative to the upper-left corner of the view.
/// ///
void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* send_mouse_click_event)(
const struct _cef_mouse_event_t* event, cef_mouse_button_type_t type, struct _cef_browser_host_t* self,
int mouseUp, int clickCount); const struct _cef_mouse_event_t* event,
cef_mouse_button_type_t type,
int mouseUp,
int clickCount);
/// ///
// Send a mouse move event to the browser. The |x| and |y| coordinates are // Send a mouse move event to the browser. The |x| and |y| coordinates are
// relative to the upper-left corner of the view. // relative to the upper-left corner of the view.
/// ///
void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* send_mouse_move_event)(
const struct _cef_mouse_event_t* event, int mouseLeave); struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
int mouseLeave);
/// ///
// Send a mouse wheel event to the browser. The |x| and |y| coordinates are // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
@ -578,26 +603,28 @@ typedef struct _cef_browser_host_t {
// In order to scroll inside select popups with window rendering disabled // In order to scroll inside select popups with window rendering disabled
// cef_render_handler_t::GetScreenPoint should be implemented properly. // cef_render_handler_t::GetScreenPoint should be implemented properly.
/// ///
void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* send_mouse_wheel_event)(
const struct _cef_mouse_event_t* event, int deltaX, int deltaY); struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
int deltaX,
int deltaY);
/// ///
// Send a focus event to the browser. // Send a focus event to the browser.
/// ///
void (CEF_CALLBACK *send_focus_event)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* send_focus_event)(struct _cef_browser_host_t* self,
int setFocus); int setFocus);
/// ///
// Send a capture lost event to the browser. // Send a capture lost event to the browser.
/// ///
void (CEF_CALLBACK *send_capture_lost_event)( void(CEF_CALLBACK* send_capture_lost_event)(struct _cef_browser_host_t* self);
struct _cef_browser_host_t* self);
/// ///
// Notify the browser that the window hosting it is about to be moved or // Notify the browser that the window hosting it is about to be moved or
// resized. This function is only used on Windows and Linux. // resized. This function is only used on Windows and Linux.
/// ///
void (CEF_CALLBACK *notify_move_or_resize_started)( void(CEF_CALLBACK* notify_move_or_resize_started)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -607,7 +634,7 @@ typedef struct _cef_browser_host_t {
// requested rate. The minimum value is 1 and the maximum value is 60 (default // requested rate. The minimum value is 1 and the maximum value is 60 (default
// 30). This function can only be called on the UI thread. // 30). This function can only be called on the UI thread.
/// ///
int (CEF_CALLBACK *get_windowless_frame_rate)( int(CEF_CALLBACK* get_windowless_frame_rate)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -617,8 +644,9 @@ typedef struct _cef_browser_host_t {
// minimum value is 1 and the maximum value is 60 (default 30). Can also be // minimum value is 1 and the maximum value is 60 (default 30). Can also be
// set at browser creation via cef_browser_tSettings.windowless_frame_rate. // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
/// ///
void (CEF_CALLBACK *set_windowless_frame_rate)( void(CEF_CALLBACK* set_windowless_frame_rate)(
struct _cef_browser_host_t* self, int frame_rate); struct _cef_browser_host_t* self,
int frame_rate);
/// ///
// Begins a new composition or updates the existing composition. Blink has a // Begins a new composition or updates the existing composition. Blink has a
@ -643,8 +671,10 @@ typedef struct _cef_browser_host_t {
// //
// This function is only used when window rendering is disabled. // This function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *ime_set_composition)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* ime_set_composition)(
const cef_string_t* text, size_t underlinesCount, struct _cef_browser_host_t* self,
const cef_string_t* text,
size_t underlinesCount,
cef_composition_underline_t const* underlines, cef_composition_underline_t const* underlines,
const cef_range_t* replacement_range, const cef_range_t* replacement_range,
const cef_range_t* selection_range); const cef_range_t* selection_range);
@ -658,8 +688,9 @@ typedef struct _cef_browser_host_t {
// |relative_cursor_pos| values are only used on OS X. This function is only // |relative_cursor_pos| values are only used on OS X. This function is only
// used when window rendering is disabled. // used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *ime_commit_text)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* ime_commit_text)(struct _cef_browser_host_t* self,
const cef_string_t* text, const cef_range_t* replacement_range, const cef_string_t* text,
const cef_range_t* replacement_range,
int relative_cursor_pos); int relative_cursor_pos);
/// ///
@ -668,15 +699,16 @@ typedef struct _cef_browser_host_t {
// will be discarded. See comments on ImeSetComposition for usage. This // will be discarded. See comments on ImeSetComposition for usage. This
// function is only used when window rendering is disabled. // function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *ime_finish_composing_text)( void(CEF_CALLBACK* ime_finish_composing_text)(
struct _cef_browser_host_t* self, int keep_selection); struct _cef_browser_host_t* self,
int keep_selection);
/// ///
// Cancels the existing composition and discards the composition node contents // Cancels the existing composition and discards the composition node contents
// without applying them. See comments on ImeSetComposition for usage. This // without applying them. See comments on ImeSetComposition for usage. This
// function is only used when window rendering is disabled. // function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *ime_cancel_composition)(struct _cef_browser_host_t* self); void(CEF_CALLBACK* ime_cancel_composition)(struct _cef_browser_host_t* self);
/// ///
// Call this function when the user drags the mouse into the web view (before // Call this function when the user drags the mouse into the web view (before
@ -687,7 +719,8 @@ typedef struct _cef_browser_host_t {
// cef_render_handler_t::StartDragging). This function is only used when // cef_render_handler_t::StartDragging). This function is only used when
// window rendering is disabled. // window rendering is disabled.
/// ///
void (CEF_CALLBACK *drag_target_drag_enter)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* drag_target_drag_enter)(
struct _cef_browser_host_t* self,
struct _cef_drag_data_t* drag_data, struct _cef_drag_data_t* drag_data,
const struct _cef_mouse_event_t* event, const struct _cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops); cef_drag_operations_mask_t allowed_ops);
@ -698,7 +731,8 @@ typedef struct _cef_browser_host_t {
// DragTargetDragLeave/DragTargetDrop). This function is only used when window // DragTargetDragLeave/DragTargetDrop). This function is only used when window
// rendering is disabled. // rendering is disabled.
/// ///
void (CEF_CALLBACK *drag_target_drag_over)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* drag_target_drag_over)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event, const struct _cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops); cef_drag_operations_mask_t allowed_ops);
@ -707,7 +741,7 @@ typedef struct _cef_browser_host_t {
// calling DragTargetDragEnter). This function is only used when window // calling DragTargetDragEnter). This function is only used when window
// rendering is disabled. // rendering is disabled.
/// ///
void (CEF_CALLBACK *drag_target_drag_leave)(struct _cef_browser_host_t* self); void(CEF_CALLBACK* drag_target_drag_leave)(struct _cef_browser_host_t* self);
/// ///
// Call this function when the user completes the drag operation by dropping // Call this function when the user completes the drag operation by dropping
@ -716,7 +750,7 @@ typedef struct _cef_browser_host_t {
// DragTargetDragEnter call. This function is only used when window rendering // DragTargetDragEnter call. This function is only used when window rendering
// is disabled. // is disabled.
/// ///
void (CEF_CALLBACK *drag_target_drop)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* drag_target_drop)(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event); const struct _cef_mouse_event_t* event);
/// ///
@ -728,8 +762,10 @@ typedef struct _cef_browser_host_t {
// DragSource* mthods. This function is only used when window rendering is // DragSource* mthods. This function is only used when window rendering is
// disabled. // disabled.
/// ///
void (CEF_CALLBACK *drag_source_ended_at)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* drag_source_ended_at)(struct _cef_browser_host_t* self,
int x, int y, cef_drag_operations_mask_t op); int x,
int y,
cef_drag_operations_mask_t op);
/// ///
// Call this function when the drag operation started by a // Call this function when the drag operation started by a
@ -739,14 +775,14 @@ typedef struct _cef_browser_host_t {
// then all DragTarget* functions should be called before DragSource* mthods. // then all DragTarget* functions should be called before DragSource* mthods.
// This function is only used when window rendering is disabled. // This function is only used when window rendering is disabled.
/// ///
void (CEF_CALLBACK *drag_source_system_drag_ended)( void(CEF_CALLBACK* drag_source_system_drag_ended)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
// Returns the current visible navigation entry for this browser. This // Returns the current visible navigation entry for this browser. This
// function can only be called on the UI thread. // function can only be called on the UI thread.
/// ///
struct _cef_navigation_entry_t* (CEF_CALLBACK *get_visible_navigation_entry)( struct _cef_navigation_entry_t*(CEF_CALLBACK* get_visible_navigation_entry)(
struct _cef_browser_host_t* self); struct _cef_browser_host_t* self);
/// ///
@ -774,11 +810,10 @@ typedef struct _cef_browser_host_t {
// objects are not created. The client may implement platform accessibility // objects are not created. The client may implement platform accessibility
// objects using CefAccessibiltyHandler callbacks if desired. // objects using CefAccessibiltyHandler callbacks if desired.
/// ///
void (CEF_CALLBACK *set_accessibility_state)(struct _cef_browser_host_t* self, void(CEF_CALLBACK* set_accessibility_state)(struct _cef_browser_host_t* self,
cef_state_t accessibility_state); cef_state_t accessibility_state);
} cef_browser_host_t; } cef_browser_host_t;
/// ///
// Create a new browser window using the window parameters specified by // Create a new browser window using the window parameters specified by
// |windowInfo|. All values will be copied internally and the actual window will // |windowInfo|. All values will be copied internally and the actual window will
@ -787,8 +822,10 @@ typedef struct _cef_browser_host_t {
// thread and will not block. // thread and will not block.
/// ///
CEF_EXPORT int cef_browser_host_create_browser( CEF_EXPORT int cef_browser_host_create_browser(
const cef_window_info_t* windowInfo, struct _cef_client_t* client, const cef_window_info_t* windowInfo,
const cef_string_t* url, const struct _cef_browser_settings_t* settings, struct _cef_client_t* client,
const cef_string_t* url,
const struct _cef_browser_settings_t* settings,
struct _cef_request_context_t* request_context); struct _cef_request_context_t* request_context);
/// ///
@ -797,11 +834,12 @@ CEF_EXPORT int cef_browser_host_create_browser(
// used. This function can only be called on the browser process UI thread. // used. This function can only be called on the browser process UI thread.
/// ///
CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync( CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
const cef_window_info_t* windowInfo, struct _cef_client_t* client, const cef_window_info_t* windowInfo,
const cef_string_t* url, const struct _cef_browser_settings_t* settings, struct _cef_client_t* client,
const cef_string_t* url,
const struct _cef_browser_settings_t* settings,
struct _cef_request_context_t* request_context); struct _cef_request_context_t* request_context);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

17
include/capi/cef_browser_process_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=0868c7d129e35c38b207b1066fd5eba0c1eef45c$
//
#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
@ -47,7 +49,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to implement browser process callbacks. The functions of this // Structure used to implement browser process callbacks. The functions of this
// structure will be called on the browser process main thread unless otherwise // structure will be called on the browser process main thread unless otherwise
@ -63,7 +64,7 @@ typedef struct _cef_browser_process_handler_t {
// Called on the browser process UI thread immediately after the CEF context // Called on the browser process UI thread immediately after the CEF context
// has been initialized. // has been initialized.
/// ///
void (CEF_CALLBACK *on_context_initialized)( void(CEF_CALLBACK* on_context_initialized)(
struct _cef_browser_process_handler_t* self); struct _cef_browser_process_handler_t* self);
/// ///
@ -73,7 +74,7 @@ typedef struct _cef_browser_process_handler_t {
// opportunity to modify the child process command line. Do not keep a // opportunity to modify the child process command line. Do not keep a
// reference to |command_line| outside of this function. // reference to |command_line| outside of this function.
/// ///
void (CEF_CALLBACK *on_before_child_process_launch)( void(CEF_CALLBACK* on_before_child_process_launch)(
struct _cef_browser_process_handler_t* self, struct _cef_browser_process_handler_t* self,
struct _cef_command_line_t* command_line); struct _cef_command_line_t* command_line);
@ -84,7 +85,7 @@ typedef struct _cef_browser_process_handler_t {
// cef_render_process_handler_t::on_render_thread_created() in the render // cef_render_process_handler_t::on_render_thread_created() in the render
// process. Do not keep a reference to |extra_info| outside of this function. // process. Do not keep a reference to |extra_info| outside of this function.
/// ///
void (CEF_CALLBACK *on_render_process_thread_created)( void(CEF_CALLBACK* on_render_process_thread_created)(
struct _cef_browser_process_handler_t* self, struct _cef_browser_process_handler_t* self,
struct _cef_list_value_t* extra_info); struct _cef_list_value_t* extra_info);
@ -92,7 +93,7 @@ typedef struct _cef_browser_process_handler_t {
// Return the handler for printing on Linux. If a print handler is not // Return the handler for printing on Linux. If a print handler is not
// provided then printing will not be supported on the Linux platform. // provided then printing will not be supported on the Linux platform.
/// ///
struct _cef_print_handler_t* (CEF_CALLBACK *get_print_handler)( struct _cef_print_handler_t*(CEF_CALLBACK* get_print_handler)(
struct _cef_browser_process_handler_t* self); struct _cef_browser_process_handler_t* self);
/// ///
@ -108,11 +109,11 @@ typedef struct _cef_browser_process_handler_t {
// specified delay and any currently pending scheduled call should be // specified delay and any currently pending scheduled call should be
// cancelled. // cancelled.
/// ///
void (CEF_CALLBACK *on_schedule_message_pump_work)( void(CEF_CALLBACK* on_schedule_message_pump_work)(
struct _cef_browser_process_handler_t* self, int64 delay_ms); struct _cef_browser_process_handler_t* self,
int64 delay_ms);
} cef_browser_process_handler_t; } cef_browser_process_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

11
include/capi/cef_callback_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=68de2255fd429696d62115786fc480f1d5f9882b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Generic callback structure used for asynchronous continuation. // Generic callback structure used for asynchronous continuation.
/// ///
@ -57,15 +58,14 @@ typedef struct _cef_callback_t {
/// ///
// Continue processing. // Continue processing.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_callback_t* self); void(CEF_CALLBACK* cont)(struct _cef_callback_t* self);
/// ///
// Cancel processing. // Cancel processing.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self);
} cef_callback_t; } cef_callback_t;
/// ///
// Generic callback structure used for asynchronous completion. // Generic callback structure used for asynchronous completion.
/// ///
@ -78,10 +78,9 @@ typedef struct _cef_completion_callback_t {
/// ///
// Method that will be called once the task is complete. // Method that will be called once the task is complete.
/// ///
void (CEF_CALLBACK *on_complete)(struct _cef_completion_callback_t* self); void(CEF_CALLBACK* on_complete)(struct _cef_completion_callback_t* self);
} cef_completion_callback_t; } cef_completion_callback_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

38
include/capi/cef_client_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=7f554250e73537ece3f8f67310c23e718f91d41b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@ -59,7 +61,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to provide handler implementations. // Implement this structure to provide handler implementations.
/// ///
@ -73,89 +74,89 @@ typedef struct _cef_client_t {
// Return the handler for context menus. If no handler is provided the default // Return the handler for context menus. If no handler is provided the default
// implementation will be used. // implementation will be used.
/// ///
struct _cef_context_menu_handler_t* (CEF_CALLBACK *get_context_menu_handler)( struct _cef_context_menu_handler_t*(CEF_CALLBACK* get_context_menu_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for dialogs. If no handler is provided the default // Return the handler for dialogs. If no handler is provided the default
// implementation will be used. // implementation will be used.
/// ///
struct _cef_dialog_handler_t* (CEF_CALLBACK *get_dialog_handler)( struct _cef_dialog_handler_t*(CEF_CALLBACK* get_dialog_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for browser display state events. // Return the handler for browser display state events.
/// ///
struct _cef_display_handler_t* (CEF_CALLBACK *get_display_handler)( struct _cef_display_handler_t*(CEF_CALLBACK* get_display_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for download events. If no handler is returned downloads // Return the handler for download events. If no handler is returned downloads
// will not be allowed. // will not be allowed.
/// ///
struct _cef_download_handler_t* (CEF_CALLBACK *get_download_handler)( struct _cef_download_handler_t*(CEF_CALLBACK* get_download_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for drag events. // Return the handler for drag events.
/// ///
struct _cef_drag_handler_t* (CEF_CALLBACK *get_drag_handler)( struct _cef_drag_handler_t*(CEF_CALLBACK* get_drag_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for find result events. // Return the handler for find result events.
/// ///
struct _cef_find_handler_t* (CEF_CALLBACK *get_find_handler)( struct _cef_find_handler_t*(CEF_CALLBACK* get_find_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for focus events. // Return the handler for focus events.
/// ///
struct _cef_focus_handler_t* (CEF_CALLBACK *get_focus_handler)( struct _cef_focus_handler_t*(CEF_CALLBACK* get_focus_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for geolocation permissions requests. If no handler is // Return the handler for geolocation permissions requests. If no handler is
// provided geolocation access will be denied by default. // provided geolocation access will be denied by default.
/// ///
struct _cef_geolocation_handler_t* (CEF_CALLBACK *get_geolocation_handler)( struct _cef_geolocation_handler_t*(CEF_CALLBACK* get_geolocation_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for JavaScript dialogs. If no handler is provided the // Return the handler for JavaScript dialogs. If no handler is provided the
// default implementation will be used. // default implementation will be used.
/// ///
struct _cef_jsdialog_handler_t* (CEF_CALLBACK *get_jsdialog_handler)( struct _cef_jsdialog_handler_t*(CEF_CALLBACK* get_jsdialog_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for keyboard events. // Return the handler for keyboard events.
/// ///
struct _cef_keyboard_handler_t* (CEF_CALLBACK *get_keyboard_handler)( struct _cef_keyboard_handler_t*(CEF_CALLBACK* get_keyboard_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for browser life span events. // Return the handler for browser life span events.
/// ///
struct _cef_life_span_handler_t* (CEF_CALLBACK *get_life_span_handler)( struct _cef_life_span_handler_t*(CEF_CALLBACK* get_life_span_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for browser load status events. // Return the handler for browser load status events.
/// ///
struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)( struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for off-screen rendering events. // Return the handler for off-screen rendering events.
/// ///
struct _cef_render_handler_t* (CEF_CALLBACK *get_render_handler)( struct _cef_render_handler_t*(CEF_CALLBACK* get_render_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
// Return the handler for browser request events. // Return the handler for browser request events.
/// ///
struct _cef_request_handler_t* (CEF_CALLBACK *get_request_handler)( struct _cef_request_handler_t*(CEF_CALLBACK* get_request_handler)(
struct _cef_client_t* self); struct _cef_client_t* self);
/// ///
@ -163,12 +164,13 @@ typedef struct _cef_client_t {
// (1) if the message was handled or false (0) otherwise. Do not keep a // (1) if the message was handled or false (0) otherwise. Do not keep a
// reference to or attempt to access the message outside of this callback. // reference to or attempt to access the message outside of this callback.
/// ///
int (CEF_CALLBACK *on_process_message_received)(struct _cef_client_t* self, int(CEF_CALLBACK* on_process_message_received)(
struct _cef_browser_t* browser, cef_process_id_t source_process, struct _cef_client_t* self,
struct _cef_browser_t* browser,
cef_process_id_t source_process,
struct _cef_process_message_t* message); struct _cef_process_message_t* message);
} cef_client_t; } cef_client_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

53
include/capi/cef_command_line_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=b917030321dc11ddfc8d8939239dda7952d2f955$
//
#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to create and/or parse command line arguments. Arguments with // Structure used to create and/or parse command line arguments. Arguments with
// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches // '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
@ -65,18 +66,18 @@ typedef struct _cef_command_line_t {
// Returns true (1) if this object is valid. Do not call any other functions // Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0). // if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_command_line_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_command_line_t* self);
/// ///
// Returns true (1) if the values of this object are read-only. Some APIs may // Returns true (1) if the values of this object are read-only. Some APIs may
// expose read-only objects. // expose read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_command_line_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_command_line_t* self);
/// ///
// Returns a writable copy of this object. // Returns a writable copy of this object.
/// ///
struct _cef_command_line_t* (CEF_CALLBACK *copy)( struct _cef_command_line_t*(CEF_CALLBACK* copy)(
struct _cef_command_line_t* self); struct _cef_command_line_t* self);
/// ///
@ -84,27 +85,28 @@ typedef struct _cef_command_line_t {
// The first argument must be the name of the program. This function is only // The first argument must be the name of the program. This function is only
// supported on non-Windows platforms. // supported on non-Windows platforms.
/// ///
void (CEF_CALLBACK *init_from_argv)(struct _cef_command_line_t* self, void(CEF_CALLBACK* init_from_argv)(struct _cef_command_line_t* self,
int argc, const char* const* argv); int argc,
const char* const* argv);
/// ///
// Initialize the command line with the string returned by calling // Initialize the command line with the string returned by calling
// GetCommandLineW(). This function is only supported on Windows. // GetCommandLineW(). This function is only supported on Windows.
/// ///
void (CEF_CALLBACK *init_from_string)(struct _cef_command_line_t* self, void(CEF_CALLBACK* init_from_string)(struct _cef_command_line_t* self,
const cef_string_t* command_line); const cef_string_t* command_line);
/// ///
// Reset the command-line switches and arguments but leave the program // Reset the command-line switches and arguments but leave the program
// component unchanged. // component unchanged.
/// ///
void (CEF_CALLBACK *reset)(struct _cef_command_line_t* self); void(CEF_CALLBACK* reset)(struct _cef_command_line_t* self);
/// ///
// Retrieve the original command line string as a vector of strings. The argv // Retrieve the original command line string as a vector of strings. The argv
// array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* } // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
/// ///
void (CEF_CALLBACK *get_argv)(struct _cef_command_line_t* self, void(CEF_CALLBACK* get_argv)(struct _cef_command_line_t* self,
cef_string_list_t argv); cef_string_list_t argv);
/// ///
@ -112,31 +114,31 @@ typedef struct _cef_command_line_t {
// function cautiously because quoting behavior is unclear. // function cautiously because quoting behavior is unclear.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_command_line_string)( cef_string_userfree_t(CEF_CALLBACK* get_command_line_string)(
struct _cef_command_line_t* self); struct _cef_command_line_t* self);
/// ///
// Get the program part of the command line string (the first item). // Get the program part of the command line string (the first item).
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_program)( cef_string_userfree_t(CEF_CALLBACK* get_program)(
struct _cef_command_line_t* self); struct _cef_command_line_t* self);
/// ///
// Set the program part of the command line string (the first item). // Set the program part of the command line string (the first item).
/// ///
void (CEF_CALLBACK *set_program)(struct _cef_command_line_t* self, void(CEF_CALLBACK* set_program)(struct _cef_command_line_t* self,
const cef_string_t* program); const cef_string_t* program);
/// ///
// Returns true (1) if the command line has switches. // Returns true (1) if the command line has switches.
/// ///
int (CEF_CALLBACK *has_switches)(struct _cef_command_line_t* self); int(CEF_CALLBACK* has_switches)(struct _cef_command_line_t* self);
/// ///
// Returns true (1) if the command line contains the given switch. // Returns true (1) if the command line contains the given switch.
/// ///
int (CEF_CALLBACK *has_switch)(struct _cef_command_line_t* self, int(CEF_CALLBACK* has_switch)(struct _cef_command_line_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
@ -144,56 +146,56 @@ typedef struct _cef_command_line_t {
// value or isn't present this function returns the NULL string. // value or isn't present this function returns the NULL string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_switch_value)( cef_string_userfree_t(CEF_CALLBACK* get_switch_value)(
struct _cef_command_line_t* self, const cef_string_t* name); struct _cef_command_line_t* self,
const cef_string_t* name);
/// ///
// Returns the map of switch names and values. If a switch has no value an // Returns the map of switch names and values. If a switch has no value an
// NULL string is returned. // NULL string is returned.
/// ///
void (CEF_CALLBACK *get_switches)(struct _cef_command_line_t* self, void(CEF_CALLBACK* get_switches)(struct _cef_command_line_t* self,
cef_string_map_t switches); cef_string_map_t switches);
/// ///
// Add a switch to the end of the command line. If the switch has no value // Add a switch to the end of the command line. If the switch has no value
// pass an NULL value string. // pass an NULL value string.
/// ///
void (CEF_CALLBACK *append_switch)(struct _cef_command_line_t* self, void(CEF_CALLBACK* append_switch)(struct _cef_command_line_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
// Add a switch with the specified value to the end of the command line. // Add a switch with the specified value to the end of the command line.
/// ///
void (CEF_CALLBACK *append_switch_with_value)( void(CEF_CALLBACK* append_switch_with_value)(struct _cef_command_line_t* self,
struct _cef_command_line_t* self, const cef_string_t* name, const cef_string_t* name,
const cef_string_t* value); const cef_string_t* value);
/// ///
// True if there are remaining command line arguments. // True if there are remaining command line arguments.
/// ///
int (CEF_CALLBACK *has_arguments)(struct _cef_command_line_t* self); int(CEF_CALLBACK* has_arguments)(struct _cef_command_line_t* self);
/// ///
// Get the remaining command line arguments. // Get the remaining command line arguments.
/// ///
void (CEF_CALLBACK *get_arguments)(struct _cef_command_line_t* self, void(CEF_CALLBACK* get_arguments)(struct _cef_command_line_t* self,
cef_string_list_t arguments); cef_string_list_t arguments);
/// ///
// Add an argument to the end of the command line. // Add an argument to the end of the command line.
/// ///
void (CEF_CALLBACK *append_argument)(struct _cef_command_line_t* self, void(CEF_CALLBACK* append_argument)(struct _cef_command_line_t* self,
const cef_string_t* argument); const cef_string_t* argument);
/// ///
// Insert a command before the current command. Common for debuggers, like // Insert a command before the current command. Common for debuggers, like
// "valgrind" or "gdb --args". // "valgrind" or "gdb --args".
/// ///
void (CEF_CALLBACK *prepend_wrapper)(struct _cef_command_line_t* self, void(CEF_CALLBACK* prepend_wrapper)(struct _cef_command_line_t* self,
const cef_string_t* wrapper); const cef_string_t* wrapper);
} cef_command_line_t; } cef_command_line_t;
/// ///
// Create a new cef_command_line_t instance. // Create a new cef_command_line_t instance.
/// ///
@ -205,7 +207,6 @@ CEF_EXPORT cef_command_line_t* cef_command_line_create();
/// ///
CEF_EXPORT cef_command_line_t* cef_command_line_get_global(); CEF_EXPORT cef_command_line_t* cef_command_line_get_global();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

87
include/capi/cef_context_menu_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=2e295ba277083061103147a400bc30f78e6a94f5$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@ -62,16 +64,16 @@ typedef struct _cef_run_context_menu_callback_t {
// Complete context menu display by selecting the specified |command_id| and // Complete context menu display by selecting the specified |command_id| and
// |event_flags|. // |event_flags|.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_run_context_menu_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_run_context_menu_callback_t* self,
int command_id, cef_event_flags_t event_flags); int command_id,
cef_event_flags_t event_flags);
/// ///
// Cancel context menu display. // Cancel context menu display.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_run_context_menu_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_run_context_menu_callback_t* self);
} cef_run_context_menu_callback_t; } cef_run_context_menu_callback_t;
/// ///
// Implement this structure to handle context menu events. The functions of this // Implement this structure to handle context menu events. The functions of this
// structure will be called on the UI thread. // structure will be called on the UI thread.
@ -89,9 +91,11 @@ typedef struct _cef_context_menu_handler_t {
// modified to show a custom menu. Do not keep references to |params| or // modified to show a custom menu. Do not keep references to |params| or
// |model| outside of this callback. // |model| outside of this callback.
/// ///
void (CEF_CALLBACK *on_before_context_menu)( void(CEF_CALLBACK* on_before_context_menu)(
struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser, struct _cef_context_menu_handler_t* self,
struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_context_menu_params_t* params,
struct _cef_menu_model_t* model); struct _cef_menu_model_t* model);
/// ///
@ -102,8 +106,10 @@ typedef struct _cef_context_menu_handler_t {
// selected command ID. For default display return false (0). Do not keep // selected command ID. For default display return false (0). Do not keep
// references to |params| or |model| outside of this callback. // references to |params| or |model| outside of this callback.
/// ///
int (CEF_CALLBACK *run_context_menu)(struct _cef_context_menu_handler_t* self, int(CEF_CALLBACK* run_context_menu)(
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_context_menu_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_context_menu_params_t* params, struct _cef_context_menu_params_t* params,
struct _cef_menu_model_t* model, struct _cef_menu_model_t* model,
struct _cef_run_context_menu_callback_t* callback); struct _cef_run_context_menu_callback_t* callback);
@ -117,21 +123,24 @@ typedef struct _cef_context_menu_handler_t {
// on_before_context_menu(). Do not keep a reference to |params| outside of // on_before_context_menu(). Do not keep a reference to |params| outside of
// this callback. // this callback.
/// ///
int (CEF_CALLBACK *on_context_menu_command)( int(CEF_CALLBACK* on_context_menu_command)(
struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser, struct _cef_context_menu_handler_t* self,
struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params, struct _cef_browser_t* browser,
int command_id, cef_event_flags_t event_flags); struct _cef_frame_t* frame,
struct _cef_context_menu_params_t* params,
int command_id,
cef_event_flags_t event_flags);
/// ///
// Called when the context menu is dismissed irregardless of whether the menu // Called when the context menu is dismissed irregardless of whether the menu
// was NULL or a command was selected. // was NULL or a command was selected.
/// ///
void (CEF_CALLBACK *on_context_menu_dismissed)( void(CEF_CALLBACK* on_context_menu_dismissed)(
struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser, struct _cef_context_menu_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame); struct _cef_frame_t* frame);
} cef_context_menu_handler_t; } cef_context_menu_handler_t;
/// ///
// Provides information about the context menu state. The ethods of this // Provides information about the context menu state. The ethods of this
// structure can only be accessed on browser process the UI thread. // structure can only be accessed on browser process the UI thread.
@ -146,19 +155,19 @@ typedef struct _cef_context_menu_params_t {
// Returns the X coordinate of the mouse where the context menu was invoked. // Returns the X coordinate of the mouse where the context menu was invoked.
// Coords are relative to the associated RenderView's origin. // Coords are relative to the associated RenderView's origin.
/// ///
int (CEF_CALLBACK *get_xcoord)(struct _cef_context_menu_params_t* self); int(CEF_CALLBACK* get_xcoord)(struct _cef_context_menu_params_t* self);
/// ///
// Returns the Y coordinate of the mouse where the context menu was invoked. // Returns the Y coordinate of the mouse where the context menu was invoked.
// Coords are relative to the associated RenderView's origin. // Coords are relative to the associated RenderView's origin.
/// ///
int (CEF_CALLBACK *get_ycoord)(struct _cef_context_menu_params_t* self); int(CEF_CALLBACK* get_ycoord)(struct _cef_context_menu_params_t* self);
/// ///
// Returns flags representing the type of node that the context menu was // Returns flags representing the type of node that the context menu was
// invoked on. // invoked on.
/// ///
cef_context_menu_type_flags_t (CEF_CALLBACK *get_type_flags)( cef_context_menu_type_flags_t(CEF_CALLBACK* get_type_flags)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -166,7 +175,7 @@ typedef struct _cef_context_menu_params_t {
// context menu was invoked on. // context menu was invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_link_url)( cef_string_userfree_t(CEF_CALLBACK* get_link_url)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -174,7 +183,7 @@ typedef struct _cef_context_menu_params_t {
// don't validate this field in the frontend process. // don't validate this field in the frontend process.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_unfiltered_link_url)( cef_string_userfree_t(CEF_CALLBACK* get_unfiltered_link_url)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -182,14 +191,14 @@ typedef struct _cef_context_menu_params_t {
// invoked on. Example of elements with source URLs are img, audio, and video. // invoked on. Example of elements with source URLs are img, audio, and video.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_source_url)( cef_string_userfree_t(CEF_CALLBACK* get_source_url)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns true (1) if the context menu was invoked on an image which has non- // Returns true (1) if the context menu was invoked on an image which has non-
// NULL contents. // NULL contents.
/// ///
int (CEF_CALLBACK *has_image_contents)( int(CEF_CALLBACK* has_image_contents)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -197,21 +206,21 @@ typedef struct _cef_context_menu_params_t {
// an image. // an image.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_title_text)( cef_string_userfree_t(CEF_CALLBACK* get_title_text)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns the URL of the top level page that the context menu was invoked on. // Returns the URL of the top level page that the context menu was invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_page_url)( cef_string_userfree_t(CEF_CALLBACK* get_page_url)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns the URL of the subframe that the context menu was invoked on. // Returns the URL of the subframe that the context menu was invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_frame_url)( cef_string_userfree_t(CEF_CALLBACK* get_frame_url)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -219,20 +228,20 @@ typedef struct _cef_context_menu_params_t {
// invoked on. // invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_frame_charset)( cef_string_userfree_t(CEF_CALLBACK* get_frame_charset)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns the type of context node that the context menu was invoked on. // Returns the type of context node that the context menu was invoked on.
/// ///
cef_context_menu_media_type_t (CEF_CALLBACK *get_media_type)( cef_context_menu_media_type_t(CEF_CALLBACK* get_media_type)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns flags representing the actions supported by the media element, if // Returns flags representing the actions supported by the media element, if
// any, that the context menu was invoked on. // any, that the context menu was invoked on.
/// ///
cef_context_menu_media_state_flags_t (CEF_CALLBACK *get_media_state_flags)( cef_context_menu_media_state_flags_t(CEF_CALLBACK* get_media_state_flags)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -240,7 +249,7 @@ typedef struct _cef_context_menu_params_t {
// invoked on. // invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_selection_text)( cef_string_userfree_t(CEF_CALLBACK* get_selection_text)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -248,7 +257,7 @@ typedef struct _cef_context_menu_params_t {
// invoked on. // invoked on.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_misspelled_word)( cef_string_userfree_t(CEF_CALLBACK* get_misspelled_word)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -256,26 +265,27 @@ typedef struct _cef_context_menu_params_t {
// |suggestions| from the spell check service for the misspelled word if there // |suggestions| from the spell check service for the misspelled word if there
// is one. // is one.
/// ///
int (CEF_CALLBACK *get_dictionary_suggestions)( int(CEF_CALLBACK* get_dictionary_suggestions)(
struct _cef_context_menu_params_t* self, cef_string_list_t suggestions); struct _cef_context_menu_params_t* self,
cef_string_list_t suggestions);
/// ///
// Returns true (1) if the context menu was invoked on an editable node. // Returns true (1) if the context menu was invoked on an editable node.
/// ///
int (CEF_CALLBACK *is_editable)(struct _cef_context_menu_params_t* self); int(CEF_CALLBACK* is_editable)(struct _cef_context_menu_params_t* self);
/// ///
// Returns true (1) if the context menu was invoked on an editable node where // Returns true (1) if the context menu was invoked on an editable node where
// spell-check is enabled. // spell-check is enabled.
/// ///
int (CEF_CALLBACK *is_spell_check_enabled)( int(CEF_CALLBACK* is_spell_check_enabled)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
// Returns flags representing the actions supported by the editable node, if // Returns flags representing the actions supported by the editable node, if
// any, that the context menu was invoked on. // any, that the context menu was invoked on.
/// ///
cef_context_menu_edit_state_flags_t (CEF_CALLBACK *get_edit_state_flags)( cef_context_menu_edit_state_flags_t(CEF_CALLBACK* get_edit_state_flags)(
struct _cef_context_menu_params_t* self); struct _cef_context_menu_params_t* self);
/// ///
@ -283,15 +293,14 @@ typedef struct _cef_context_menu_params_t {
// renderer process (for example, plugin placeholder or pepper plugin menu // renderer process (for example, plugin placeholder or pepper plugin menu
// items). // items).
/// ///
int (CEF_CALLBACK *is_custom_menu)(struct _cef_context_menu_params_t* self); int(CEF_CALLBACK* is_custom_menu)(struct _cef_context_menu_params_t* self);
/// ///
// Returns true (1) if the context menu was invoked from a pepper plugin. // Returns true (1) if the context menu was invoked from a pepper plugin.
/// ///
int (CEF_CALLBACK *is_pepper_menu)(struct _cef_context_menu_params_t* self); int(CEF_CALLBACK* is_pepper_menu)(struct _cef_context_menu_params_t* self);
} cef_context_menu_params_t; } cef_context_menu_params_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

52
include/capi/cef_cookie_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=c2bf8084385f3c795ae7494da6970a0a61b96ac6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
@ -65,15 +67,17 @@ typedef struct _cef_cookie_manager_t {
// NULL it will be executed asnychronously on the IO thread after the change // NULL it will be executed asnychronously on the IO thread after the change
// has been applied. Must be called before any cookies are accessed. // has been applied. Must be called before any cookies are accessed.
/// ///
void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self, void(CEF_CALLBACK* set_supported_schemes)(
cef_string_list_t schemes, struct _cef_completion_callback_t* callback); struct _cef_cookie_manager_t* self,
cef_string_list_t schemes,
struct _cef_completion_callback_t* callback);
/// ///
// Visit all cookies on the IO thread. The returned cookies are ordered by // Visit all cookies on the IO thread. The returned cookies are ordered by
// longest path, then by earliest creation date. Returns false (0) if cookies // longest path, then by earliest creation date. Returns false (0) if cookies
// cannot be accessed. // cannot be accessed.
/// ///
int (CEF_CALLBACK *visit_all_cookies)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* visit_all_cookies)(struct _cef_cookie_manager_t* self,
struct _cef_cookie_visitor_t* visitor); struct _cef_cookie_visitor_t* visitor);
/// ///
@ -83,8 +87,9 @@ typedef struct _cef_cookie_manager_t {
// cookies are ordered by longest path, then by earliest creation date. // cookies are ordered by longest path, then by earliest creation date.
// Returns false (0) if cookies cannot be accessed. // Returns false (0) if cookies cannot be accessed.
/// ///
int (CEF_CALLBACK *visit_url_cookies)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* visit_url_cookies)(struct _cef_cookie_manager_t* self,
const cef_string_t* url, int includeHttpOnly, const cef_string_t* url,
int includeHttpOnly,
struct _cef_cookie_visitor_t* visitor); struct _cef_cookie_visitor_t* visitor);
/// ///
@ -96,8 +101,9 @@ typedef struct _cef_cookie_manager_t {
// asnychronously on the IO thread after the cookie has been set. Returns // asnychronously on the IO thread after the cookie has been set. Returns
// false (0) if an invalid URL is specified or if cookies cannot be accessed. // false (0) if an invalid URL is specified or if cookies cannot be accessed.
/// ///
int (CEF_CALLBACK *set_cookie)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* set_cookie)(struct _cef_cookie_manager_t* self,
const cef_string_t* url, const struct _cef_cookie_t* cookie, const cef_string_t* url,
const struct _cef_cookie_t* cookie,
struct _cef_set_cookie_callback_t* callback); struct _cef_set_cookie_callback_t* callback);
/// ///
@ -111,8 +117,10 @@ typedef struct _cef_cookie_manager_t {
// or if cookies cannot be accessed. Cookies can alternately be deleted using // or if cookies cannot be accessed. Cookies can alternately be deleted using
// the Visit*Cookies() functions. // the Visit*Cookies() functions.
/// ///
int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* delete_cookies)(
const cef_string_t* url, const cef_string_t* cookie_name, struct _cef_cookie_manager_t* self,
const cef_string_t* url,
const cef_string_t* cookie_name,
struct _cef_delete_cookies_callback_t* callback); struct _cef_delete_cookies_callback_t* callback);
/// ///
@ -125,8 +133,10 @@ typedef struct _cef_cookie_manager_t {
// asnychronously on the IO thread after the manager's storage has been // asnychronously on the IO thread after the manager's storage has been
// initialized. Returns false (0) if cookies cannot be accessed. // initialized. Returns false (0) if cookies cannot be accessed.
/// ///
int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* set_storage_path)(
const cef_string_t* path, int persist_session_cookies, struct _cef_cookie_manager_t* self,
const cef_string_t* path,
int persist_session_cookies,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
/// ///
@ -134,11 +144,10 @@ typedef struct _cef_cookie_manager_t {
// be executed asnychronously on the IO thread after the flush is complete. // be executed asnychronously on the IO thread after the flush is complete.
// Returns false (0) if cookies cannot be accessed. // Returns false (0) if cookies cannot be accessed.
/// ///
int (CEF_CALLBACK *flush_store)(struct _cef_cookie_manager_t* self, int(CEF_CALLBACK* flush_store)(struct _cef_cookie_manager_t* self,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
} cef_cookie_manager_t; } cef_cookie_manager_t;
/// ///
// Returns the global cookie manager. By default data will be stored at // Returns the global cookie manager. By default data will be stored at
// CefSettings.cache_path if specified or in memory otherwise. If |callback| is // CefSettings.cache_path if specified or in memory otherwise. If |callback| is
@ -160,10 +169,10 @@ CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_get_global_manager(
// manager's storage has been initialized. // manager's storage has been initialized.
/// ///
CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager( CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
const cef_string_t* path, int persist_session_cookies, const cef_string_t* path,
int persist_session_cookies,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
/// ///
// Structure to implement for visiting cookie values. The functions of this // Structure to implement for visiting cookie values. The functions of this
// structure will always be called on the IO thread. // structure will always be called on the IO thread.
@ -181,12 +190,13 @@ typedef struct _cef_cookie_visitor_t {
// Return false (0) to stop visiting cookies. This function may never be // Return false (0) to stop visiting cookies. This function may never be
// called if no cookies are found. // called if no cookies are found.
/// ///
int (CEF_CALLBACK *visit)(struct _cef_cookie_visitor_t* self, int(CEF_CALLBACK* visit)(struct _cef_cookie_visitor_t* self,
const struct _cef_cookie_t* cookie, int count, int total, const struct _cef_cookie_t* cookie,
int count,
int total,
int* deleteCookie); int* deleteCookie);
} cef_cookie_visitor_t; } cef_cookie_visitor_t;
/// ///
// Structure to implement to be notified of asynchronous completion via // Structure to implement to be notified of asynchronous completion via
// cef_cookie_manager_t::set_cookie(). // cef_cookie_manager_t::set_cookie().
@ -201,11 +211,10 @@ typedef struct _cef_set_cookie_callback_t {
// Method that will be called upon completion. |success| will be true (1) if // Method that will be called upon completion. |success| will be true (1) if
// the cookie was set successfully. // the cookie was set successfully.
/// ///
void (CEF_CALLBACK *on_complete)(struct _cef_set_cookie_callback_t* self, void(CEF_CALLBACK* on_complete)(struct _cef_set_cookie_callback_t* self,
int success); int success);
} cef_set_cookie_callback_t; } cef_set_cookie_callback_t;
/// ///
// Structure to implement to be notified of asynchronous completion via // Structure to implement to be notified of asynchronous completion via
// cef_cookie_manager_t::delete_cookies(). // cef_cookie_manager_t::delete_cookies().
@ -220,11 +229,10 @@ typedef struct _cef_delete_cookies_callback_t {
// Method that will be called upon completion. |num_deleted| will be the // Method that will be called upon completion. |num_deleted| will be the
// number of cookies that were deleted or -1 if unknown. // number of cookies that were deleted or -1 if unknown.
/// ///
void (CEF_CALLBACK *on_complete)(struct _cef_delete_cookies_callback_t* self, void(CEF_CALLBACK* on_complete)(struct _cef_delete_cookies_callback_t* self,
int num_deleted); int num_deleted);
} cef_delete_cookies_callback_t; } cef_delete_cookies_callback_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

3
include/capi/cef_crash_util_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=8b7354f5a1ad6b255d77e477c64374b927f4fe28$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Crash reporting is configured using an INI-style config file named // Crash reporting is configured using an INI-style config file named
// "crash_reporter.cfg". On Windows and Linux this file must be placed next to // "crash_reporter.cfg". On Windows and Linux this file must be placed next to

24
include/capi/cef_dialog_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=b8a44f4f624ba51107d06ff3d1a7934e83765786$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure for asynchronous continuation of file dialog requests. // Callback structure for asynchronous continuation of file dialog requests.
/// ///
@ -62,16 +63,16 @@ typedef struct _cef_file_dialog_callback_t {
// or a list of values depending on the dialog mode. An NULL |file_paths| // or a list of values depending on the dialog mode. An NULL |file_paths|
// value is treated the same as calling cancel(). // value is treated the same as calling cancel().
/// ///
void (CEF_CALLBACK *cont)(struct _cef_file_dialog_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_file_dialog_callback_t* self,
int selected_accept_filter, cef_string_list_t file_paths); int selected_accept_filter,
cef_string_list_t file_paths);
/// ///
// Cancel the file selection. // Cancel the file selection.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_file_dialog_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_file_dialog_callback_t* self);
} cef_file_dialog_callback_t; } cef_file_dialog_callback_t;
/// ///
// Implement this structure to handle dialog events. The functions of this // Implement this structure to handle dialog events. The functions of this
// structure will be called on the browser process UI thread. // structure will be called on the browser process UI thread.
@ -97,14 +98,17 @@ typedef struct _cef_dialog_handler_t {
// return true (1) and execute |callback| either inline or at a later time. To // return true (1) and execute |callback| either inline or at a later time. To
// display the default dialog return false (0). // display the default dialog return false (0).
/// ///
int (CEF_CALLBACK *on_file_dialog)(struct _cef_dialog_handler_t* self, int(CEF_CALLBACK* on_file_dialog)(
struct _cef_browser_t* browser, cef_file_dialog_mode_t mode, struct _cef_dialog_handler_t* self,
const cef_string_t* title, const cef_string_t* default_file_path, struct _cef_browser_t* browser,
cef_string_list_t accept_filters, int selected_accept_filter, cef_file_dialog_mode_t mode,
const cef_string_t* title,
const cef_string_t* default_file_path,
cef_string_list_t accept_filters,
int selected_accept_filter,
struct _cef_file_dialog_callback_t* callback); struct _cef_file_dialog_callback_t* callback);
} cef_dialog_handler_t; } cef_dialog_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

42
include/capi/cef_display_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=f0f3fd4cab00c0eb11956e674a111cb30d3af100$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to browser display state. // Implement this structure to handle events related to browser display state.
// The functions of this structure will be called on the UI thread. // The functions of this structure will be called on the UI thread.
@ -60,21 +61,24 @@ typedef struct _cef_display_handler_t {
/// ///
// Called when a frame's address has changed. // Called when a frame's address has changed.
/// ///
void (CEF_CALLBACK *on_address_change)(struct _cef_display_handler_t* self, void(CEF_CALLBACK* on_address_change)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
const cef_string_t* url); const cef_string_t* url);
/// ///
// Called when the page title changes. // Called when the page title changes.
/// ///
void (CEF_CALLBACK *on_title_change)(struct _cef_display_handler_t* self, void(CEF_CALLBACK* on_title_change)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* title); struct _cef_browser_t* browser,
const cef_string_t* title);
/// ///
// Called when the page icon changes. // Called when the page icon changes.
/// ///
void (CEF_CALLBACK *on_favicon_urlchange)(struct _cef_display_handler_t* self, void(CEF_CALLBACK* on_favicon_urlchange)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, cef_string_list_t icon_urls); struct _cef_browser_t* browser,
cef_string_list_t icon_urls);
/// ///
// Called when web content in the page has toggled fullscreen mode. If // Called when web content in the page has toggled fullscreen mode. If
@ -83,8 +87,9 @@ typedef struct _cef_display_handler_t {
// automatically return to its original size and position. The client is // automatically return to its original size and position. The client is
// responsible for resizing the browser if desired. // responsible for resizing the browser if desired.
/// ///
void (CEF_CALLBACK *on_fullscreen_mode_change)( void(CEF_CALLBACK* on_fullscreen_mode_change)(
struct _cef_display_handler_t* self, struct _cef_browser_t* browser, struct _cef_display_handler_t* self,
struct _cef_browser_t* browser,
int fullscreen); int fullscreen);
/// ///
@ -95,26 +100,29 @@ typedef struct _cef_display_handler_t {
// tooltip. When window rendering is disabled the application is responsible // tooltip. When window rendering is disabled the application is responsible
// for drawing tooltips and the return value is ignored. // for drawing tooltips and the return value is ignored.
/// ///
int (CEF_CALLBACK *on_tooltip)(struct _cef_display_handler_t* self, int(CEF_CALLBACK* on_tooltip)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, cef_string_t* text); struct _cef_browser_t* browser,
cef_string_t* text);
/// ///
// Called when the browser receives a status message. |value| contains the // Called when the browser receives a status message. |value| contains the
// text that will be displayed in the status message. // text that will be displayed in the status message.
/// ///
void (CEF_CALLBACK *on_status_message)(struct _cef_display_handler_t* self, void(CEF_CALLBACK* on_status_message)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* value); struct _cef_browser_t* browser,
const cef_string_t* value);
/// ///
// Called to display a console message. Return true (1) to stop the message // Called to display a console message. Return true (1) to stop the message
// from being output to the console. // from being output to the console.
/// ///
int (CEF_CALLBACK *on_console_message)(struct _cef_display_handler_t* self, int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* message, struct _cef_browser_t* browser,
const cef_string_t* source, int line); const cef_string_t* message,
const cef_string_t* source,
int line);
} cef_display_handler_t; } cef_display_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

101
include/capi/cef_dom_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=db82ff508cb1b4a03001b8b30bc5126186ee1bd2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
@ -64,11 +66,10 @@ typedef struct _cef_domvisitor_t {
// keep references to or attempt to access any DOM objects outside the scope // keep references to or attempt to access any DOM objects outside the scope
// of this function. // of this function.
/// ///
void (CEF_CALLBACK *visit)(struct _cef_domvisitor_t* self, void(CEF_CALLBACK* visit)(struct _cef_domvisitor_t* self,
struct _cef_domdocument_t* document); struct _cef_domdocument_t* document);
} cef_domvisitor_t; } cef_domvisitor_t;
/// ///
// Structure used to represent a DOM document. The functions of this structure // Structure used to represent a DOM document. The functions of this structure
// should only be called on the render process main thread thread. // should only be called on the render process main thread thread.
@ -82,81 +83,82 @@ typedef struct _cef_domdocument_t {
/// ///
// Returns the document type. // Returns the document type.
/// ///
cef_dom_document_type_t (CEF_CALLBACK *get_type)( cef_dom_document_type_t(CEF_CALLBACK* get_type)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the root document node. // Returns the root document node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_document)( struct _cef_domnode_t*(CEF_CALLBACK* get_document)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the BODY node of an HTML document. // Returns the BODY node of an HTML document.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_body)( struct _cef_domnode_t*(CEF_CALLBACK* get_body)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the HEAD node of an HTML document. // Returns the HEAD node of an HTML document.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_head)( struct _cef_domnode_t*(CEF_CALLBACK* get_head)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the title of an HTML document. // Returns the title of an HTML document.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_title)( cef_string_userfree_t(CEF_CALLBACK* get_title)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the document element with the specified ID value. // Returns the document element with the specified ID value.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_element_by_id)( struct _cef_domnode_t*(CEF_CALLBACK* get_element_by_id)(
struct _cef_domdocument_t* self, const cef_string_t* id); struct _cef_domdocument_t* self,
const cef_string_t* id);
/// ///
// Returns the node that currently has keyboard focus. // Returns the node that currently has keyboard focus.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_focused_node)( struct _cef_domnode_t*(CEF_CALLBACK* get_focused_node)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns true (1) if a portion of the document is selected. // Returns true (1) if a portion of the document is selected.
/// ///
int (CEF_CALLBACK *has_selection)(struct _cef_domdocument_t* self); int(CEF_CALLBACK* has_selection)(struct _cef_domdocument_t* self);
/// ///
// Returns the selection offset within the start node. // Returns the selection offset within the start node.
/// ///
int (CEF_CALLBACK *get_selection_start_offset)( int(CEF_CALLBACK* get_selection_start_offset)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the selection offset within the end node. // Returns the selection offset within the end node.
/// ///
int (CEF_CALLBACK *get_selection_end_offset)(struct _cef_domdocument_t* self); int(CEF_CALLBACK* get_selection_end_offset)(struct _cef_domdocument_t* self);
/// ///
// Returns the contents of this selection as markup. // Returns the contents of this selection as markup.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_selection_as_markup)( cef_string_userfree_t(CEF_CALLBACK* get_selection_as_markup)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the contents of this selection as text. // Returns the contents of this selection as text.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_selection_as_text)( cef_string_userfree_t(CEF_CALLBACK* get_selection_as_text)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
// Returns the base URL for the document. // Returns the base URL for the document.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_base_url)( cef_string_userfree_t(CEF_CALLBACK* get_base_url)(
struct _cef_domdocument_t* self); struct _cef_domdocument_t* self);
/// ///
@ -164,11 +166,11 @@ typedef struct _cef_domdocument_t {
// partial URL. // partial URL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_complete_url)( cef_string_userfree_t(CEF_CALLBACK* get_complete_url)(
struct _cef_domdocument_t* self, const cef_string_t* partialURL); struct _cef_domdocument_t* self,
const cef_string_t* partialURL);
} cef_domdocument_t; } cef_domdocument_t;
/// ///
// Structure used to represent a DOM node. The functions of this structure // Structure used to represent a DOM node. The functions of this structure
// should only be called on the render process main thread. // should only be called on the render process main thread.
@ -182,163 +184,162 @@ typedef struct _cef_domnode_t {
/// ///
// Returns the type for this node. // Returns the type for this node.
/// ///
cef_dom_node_type_t (CEF_CALLBACK *get_type)(struct _cef_domnode_t* self); cef_dom_node_type_t(CEF_CALLBACK* get_type)(struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this is a text node. // Returns true (1) if this is a text node.
/// ///
int (CEF_CALLBACK *is_text)(struct _cef_domnode_t* self); int(CEF_CALLBACK* is_text)(struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this is an element node. // Returns true (1) if this is an element node.
/// ///
int (CEF_CALLBACK *is_element)(struct _cef_domnode_t* self); int(CEF_CALLBACK* is_element)(struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this is an editable node. // Returns true (1) if this is an editable node.
/// ///
int (CEF_CALLBACK *is_editable)(struct _cef_domnode_t* self); int(CEF_CALLBACK* is_editable)(struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this is a form control element node. // Returns true (1) if this is a form control element node.
/// ///
int (CEF_CALLBACK *is_form_control_element)(struct _cef_domnode_t* self); int(CEF_CALLBACK* is_form_control_element)(struct _cef_domnode_t* self);
/// ///
// Returns the type of this form control element node. // Returns the type of this form control element node.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_form_control_element_type)( cef_string_userfree_t(CEF_CALLBACK* get_form_control_element_type)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this object is pointing to the same handle as |that| // Returns true (1) if this object is pointing to the same handle as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_domnode_t* self, int(CEF_CALLBACK* is_same)(struct _cef_domnode_t* self,
struct _cef_domnode_t* that); struct _cef_domnode_t* that);
/// ///
// Returns the name of this node. // Returns the name of this node.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_domnode_t* self); cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_domnode_t* self);
/// ///
// Returns the value of this node. // Returns the value of this node.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_value)(struct _cef_domnode_t* self); cef_string_userfree_t(CEF_CALLBACK* get_value)(struct _cef_domnode_t* self);
/// ///
// Set the value of this node. Returns true (1) on success. // Set the value of this node. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_value)(struct _cef_domnode_t* self, int(CEF_CALLBACK* set_value)(struct _cef_domnode_t* self,
const cef_string_t* value); const cef_string_t* value);
/// ///
// Returns the contents of this node as markup. // Returns the contents of this node as markup.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_as_markup)( cef_string_userfree_t(CEF_CALLBACK* get_as_markup)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns the document associated with this node. // Returns the document associated with this node.
/// ///
struct _cef_domdocument_t* (CEF_CALLBACK *get_document)( struct _cef_domdocument_t*(CEF_CALLBACK* get_document)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns the parent node. // Returns the parent node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_parent)( struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self);
struct _cef_domnode_t* self);
/// ///
// Returns the previous sibling node. // Returns the previous sibling node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_previous_sibling)( struct _cef_domnode_t*(CEF_CALLBACK* get_previous_sibling)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns the next sibling node. // Returns the next sibling node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_next_sibling)( struct _cef_domnode_t*(CEF_CALLBACK* get_next_sibling)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this node has child nodes. // Returns true (1) if this node has child nodes.
/// ///
int (CEF_CALLBACK *has_children)(struct _cef_domnode_t* self); int(CEF_CALLBACK* has_children)(struct _cef_domnode_t* self);
/// ///
// Return the first child node. // Return the first child node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_first_child)( struct _cef_domnode_t*(CEF_CALLBACK* get_first_child)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns the last child node. // Returns the last child node.
/// ///
struct _cef_domnode_t* (CEF_CALLBACK *get_last_child)( struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
// The following functions are valid only for element nodes. // The following functions are valid only for element nodes.
/// ///
// Returns the tag name of this element. // Returns the tag name of this element.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_element_tag_name)( cef_string_userfree_t(CEF_CALLBACK* get_element_tag_name)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this element has attributes. // Returns true (1) if this element has attributes.
/// ///
int (CEF_CALLBACK *has_element_attributes)(struct _cef_domnode_t* self); int(CEF_CALLBACK* has_element_attributes)(struct _cef_domnode_t* self);
/// ///
// Returns true (1) if this element has an attribute named |attrName|. // Returns true (1) if this element has an attribute named |attrName|.
/// ///
int (CEF_CALLBACK *has_element_attribute)(struct _cef_domnode_t* self, int(CEF_CALLBACK* has_element_attribute)(struct _cef_domnode_t* self,
const cef_string_t* attrName); const cef_string_t* attrName);
/// ///
// Returns the element attribute named |attrName|. // Returns the element attribute named |attrName|.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_element_attribute)( cef_string_userfree_t(CEF_CALLBACK* get_element_attribute)(
struct _cef_domnode_t* self, const cef_string_t* attrName); struct _cef_domnode_t* self,
const cef_string_t* attrName);
/// ///
// Returns a map of all element attributes. // Returns a map of all element attributes.
/// ///
void (CEF_CALLBACK *get_element_attributes)(struct _cef_domnode_t* self, void(CEF_CALLBACK* get_element_attributes)(struct _cef_domnode_t* self,
cef_string_map_t attrMap); cef_string_map_t attrMap);
/// ///
// Set the value for the element attribute named |attrName|. Returns true (1) // Set the value for the element attribute named |attrName|. Returns true (1)
// on success. // on success.
/// ///
int (CEF_CALLBACK *set_element_attribute)(struct _cef_domnode_t* self, int(CEF_CALLBACK* set_element_attribute)(struct _cef_domnode_t* self,
const cef_string_t* attrName, const cef_string_t* value); const cef_string_t* attrName,
const cef_string_t* value);
/// ///
// Returns the inner text of the element. // Returns the inner text of the element.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_element_inner_text)( cef_string_userfree_t(CEF_CALLBACK* get_element_inner_text)(
struct _cef_domnode_t* self); struct _cef_domnode_t* self);
/// ///
// Returns the bounds of the element. // Returns the bounds of the element.
/// ///
cef_rect_t (CEF_CALLBACK *get_element_bounds)(struct _cef_domnode_t* self); cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self);
} cef_domnode_t; } cef_domnode_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

23
include/capi/cef_download_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=4475f7e48898bdef8051c849873fb2528320cd9c$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure used to asynchronously continue a download. // Callback structure used to asynchronously continue a download.
/// ///
@ -62,11 +63,11 @@ typedef struct _cef_before_download_callback_t {
// suggested name and the default temp directory. Set |show_dialog| to true // suggested name and the default temp directory. Set |show_dialog| to true
// (1) if you do wish to show the default "Save As" dialog. // (1) if you do wish to show the default "Save As" dialog.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_before_download_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_before_download_callback_t* self,
const cef_string_t* download_path, int show_dialog); const cef_string_t* download_path,
int show_dialog);
} cef_before_download_callback_t; } cef_before_download_callback_t;
/// ///
// Callback structure used to asynchronously cancel a download. // Callback structure used to asynchronously cancel a download.
/// ///
@ -79,20 +80,19 @@ typedef struct _cef_download_item_callback_t {
/// ///
// Call to cancel the download. // Call to cancel the download.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_download_item_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_download_item_callback_t* self);
/// ///
// Call to pause the download. // Call to pause the download.
/// ///
void (CEF_CALLBACK *pause)(struct _cef_download_item_callback_t* self); void(CEF_CALLBACK* pause)(struct _cef_download_item_callback_t* self);
/// ///
// Call to resume the download. // Call to resume the download.
/// ///
void (CEF_CALLBACK *resume)(struct _cef_download_item_callback_t* self); void(CEF_CALLBACK* resume)(struct _cef_download_item_callback_t* self);
} cef_download_item_callback_t; } cef_download_item_callback_t;
/// ///
// Structure used to handle file downloads. The functions of this structure will // Structure used to handle file downloads. The functions of this structure will
// called on the browser process UI thread. // called on the browser process UI thread.
@ -110,7 +110,8 @@ typedef struct _cef_download_handler_t {
// download if desired. Do not keep a reference to |download_item| outside of // download if desired. Do not keep a reference to |download_item| outside of
// this function. // this function.
/// ///
void (CEF_CALLBACK *on_before_download)(struct _cef_download_handler_t* self, void(CEF_CALLBACK* on_before_download)(
struct _cef_download_handler_t* self,
struct _cef_browser_t* browser, struct _cef_browser_t* browser,
struct _cef_download_item_t* download_item, struct _cef_download_item_t* download_item,
const cef_string_t* suggested_name, const cef_string_t* suggested_name,
@ -123,13 +124,13 @@ typedef struct _cef_download_handler_t {
// download if desired. Do not keep a reference to |download_item| outside of // download if desired. Do not keep a reference to |download_item| outside of
// this function. // this function.
/// ///
void (CEF_CALLBACK *on_download_updated)(struct _cef_download_handler_t* self, void(CEF_CALLBACK* on_download_updated)(
struct _cef_download_handler_t* self,
struct _cef_browser_t* browser, struct _cef_browser_t* browser,
struct _cef_download_item_t* download_item, struct _cef_download_item_t* download_item,
struct _cef_download_item_callback_t* callback); struct _cef_download_item_callback_t* callback);
} cef_download_handler_t; } cef_download_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

38
include/capi/cef_download_item_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=cc669703d613f5a6a5bae95030835dc99f55a6fa$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to represent a download item. // Structure used to represent a download item.
/// ///
@ -58,103 +59,102 @@ typedef struct _cef_download_item_t {
// Returns true (1) if this object is valid. Do not call any other functions // Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0). // if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_download_item_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_download_item_t* self);
/// ///
// Returns true (1) if the download is in progress. // Returns true (1) if the download is in progress.
/// ///
int (CEF_CALLBACK *is_in_progress)(struct _cef_download_item_t* self); int(CEF_CALLBACK* is_in_progress)(struct _cef_download_item_t* self);
/// ///
// Returns true (1) if the download is complete. // Returns true (1) if the download is complete.
/// ///
int (CEF_CALLBACK *is_complete)(struct _cef_download_item_t* self); int(CEF_CALLBACK* is_complete)(struct _cef_download_item_t* self);
/// ///
// Returns true (1) if the download has been canceled or interrupted. // Returns true (1) if the download has been canceled or interrupted.
/// ///
int (CEF_CALLBACK *is_canceled)(struct _cef_download_item_t* self); int(CEF_CALLBACK* is_canceled)(struct _cef_download_item_t* self);
/// ///
// Returns a simple speed estimate in bytes/s. // Returns a simple speed estimate in bytes/s.
/// ///
int64 (CEF_CALLBACK *get_current_speed)(struct _cef_download_item_t* self); int64(CEF_CALLBACK* get_current_speed)(struct _cef_download_item_t* self);
/// ///
// Returns the rough percent complete or -1 if the receive total size is // Returns the rough percent complete or -1 if the receive total size is
// unknown. // unknown.
/// ///
int (CEF_CALLBACK *get_percent_complete)(struct _cef_download_item_t* self); int(CEF_CALLBACK* get_percent_complete)(struct _cef_download_item_t* self);
/// ///
// Returns the total number of bytes. // Returns the total number of bytes.
/// ///
int64 (CEF_CALLBACK *get_total_bytes)(struct _cef_download_item_t* self); int64(CEF_CALLBACK* get_total_bytes)(struct _cef_download_item_t* self);
/// ///
// Returns the number of received bytes. // Returns the number of received bytes.
/// ///
int64 (CEF_CALLBACK *get_received_bytes)(struct _cef_download_item_t* self); int64(CEF_CALLBACK* get_received_bytes)(struct _cef_download_item_t* self);
/// ///
// Returns the time that the download started. // Returns the time that the download started.
/// ///
cef_time_t (CEF_CALLBACK *get_start_time)(struct _cef_download_item_t* self); cef_time_t(CEF_CALLBACK* get_start_time)(struct _cef_download_item_t* self);
/// ///
// Returns the time that the download ended. // Returns the time that the download ended.
/// ///
cef_time_t (CEF_CALLBACK *get_end_time)(struct _cef_download_item_t* self); cef_time_t(CEF_CALLBACK* get_end_time)(struct _cef_download_item_t* self);
/// ///
// Returns the full path to the downloaded or downloading file. // Returns the full path to the downloaded or downloading file.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_full_path)( cef_string_userfree_t(CEF_CALLBACK* get_full_path)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
/// ///
// Returns the unique identifier for this download. // Returns the unique identifier for this download.
/// ///
uint32 (CEF_CALLBACK *get_id)(struct _cef_download_item_t* self); uint32(CEF_CALLBACK* get_id)(struct _cef_download_item_t* self);
/// ///
// Returns the URL. // Returns the URL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_url)( cef_string_userfree_t(CEF_CALLBACK* get_url)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
/// ///
// Returns the original URL before any redirections. // Returns the original URL before any redirections.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_original_url)( cef_string_userfree_t(CEF_CALLBACK* get_original_url)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
/// ///
// Returns the suggested file name. // Returns the suggested file name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_suggested_file_name)( cef_string_userfree_t(CEF_CALLBACK* get_suggested_file_name)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
/// ///
// Returns the content disposition. // Returns the content disposition.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_content_disposition)( cef_string_userfree_t(CEF_CALLBACK* get_content_disposition)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
/// ///
// Returns the mime type. // Returns the mime type.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_mime_type)( cef_string_userfree_t(CEF_CALLBACK* get_mime_type)(
struct _cef_download_item_t* self); struct _cef_download_item_t* self);
} cef_download_item_t; } cef_download_item_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

58
include/capi/cef_drag_data_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=a4b5264c1e685cad86203772631460684ee7820d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to represent drag data. The functions of this structure may be // Structure used to represent drag data. The functions of this structure may be
// called on any thread. // called on any thread.
@ -60,61 +61,61 @@ typedef struct _cef_drag_data_t {
/// ///
// Returns a copy of the current object. // Returns a copy of the current object.
/// ///
struct _cef_drag_data_t* (CEF_CALLBACK *clone)(struct _cef_drag_data_t* self); struct _cef_drag_data_t*(CEF_CALLBACK* clone)(struct _cef_drag_data_t* self);
/// ///
// Returns true (1) if this object is read-only. // Returns true (1) if this object is read-only.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_drag_data_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_drag_data_t* self);
/// ///
// Returns true (1) if the drag data is a link. // Returns true (1) if the drag data is a link.
/// ///
int (CEF_CALLBACK *is_link)(struct _cef_drag_data_t* self); int(CEF_CALLBACK* is_link)(struct _cef_drag_data_t* self);
/// ///
// Returns true (1) if the drag data is a text or html fragment. // Returns true (1) if the drag data is a text or html fragment.
/// ///
int (CEF_CALLBACK *is_fragment)(struct _cef_drag_data_t* self); int(CEF_CALLBACK* is_fragment)(struct _cef_drag_data_t* self);
/// ///
// Returns true (1) if the drag data is a file. // Returns true (1) if the drag data is a file.
/// ///
int (CEF_CALLBACK *is_file)(struct _cef_drag_data_t* self); int(CEF_CALLBACK* is_file)(struct _cef_drag_data_t* self);
/// ///
// Return the link URL that is being dragged. // Return the link URL that is being dragged.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_link_url)( cef_string_userfree_t(CEF_CALLBACK* get_link_url)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
// Return the title associated with the link being dragged. // Return the title associated with the link being dragged.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_link_title)( cef_string_userfree_t(CEF_CALLBACK* get_link_title)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
// Return the metadata, if any, associated with the link being dragged. // Return the metadata, if any, associated with the link being dragged.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_link_metadata)( cef_string_userfree_t(CEF_CALLBACK* get_link_metadata)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
// Return the plain text fragment that is being dragged. // Return the plain text fragment that is being dragged.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_fragment_text)( cef_string_userfree_t(CEF_CALLBACK* get_fragment_text)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
// Return the text/html fragment that is being dragged. // Return the text/html fragment that is being dragged.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_fragment_html)( cef_string_userfree_t(CEF_CALLBACK* get_fragment_html)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
@ -122,14 +123,14 @@ typedef struct _cef_drag_data_t {
// resolving relative URLs and may be NULL. // resolving relative URLs and may be NULL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_fragment_base_url)( cef_string_userfree_t(CEF_CALLBACK* get_fragment_base_url)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
// Return the name of the file being dragged out of the browser window. // Return the name of the file being dragged out of the browser window.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_file_name)( cef_string_userfree_t(CEF_CALLBACK* get_file_name)(
struct _cef_drag_data_t* self); struct _cef_drag_data_t* self);
/// ///
@ -138,50 +139,50 @@ typedef struct _cef_drag_data_t {
// this function will return the size of the file contents in bytes. Call // this function will return the size of the file contents in bytes. Call
// get_file_name() to get a suggested name for the file. // get_file_name() to get a suggested name for the file.
/// ///
size_t (CEF_CALLBACK *get_file_contents)(struct _cef_drag_data_t* self, size_t(CEF_CALLBACK* get_file_contents)(struct _cef_drag_data_t* self,
struct _cef_stream_writer_t* writer); struct _cef_stream_writer_t* writer);
/// ///
// Retrieve the list of file names that are being dragged into the browser // Retrieve the list of file names that are being dragged into the browser
// window. // window.
/// ///
int (CEF_CALLBACK *get_file_names)(struct _cef_drag_data_t* self, int(CEF_CALLBACK* get_file_names)(struct _cef_drag_data_t* self,
cef_string_list_t names); cef_string_list_t names);
/// ///
// Set the link URL that is being dragged. // Set the link URL that is being dragged.
/// ///
void (CEF_CALLBACK *set_link_url)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_link_url)(struct _cef_drag_data_t* self,
const cef_string_t* url); const cef_string_t* url);
/// ///
// Set the title associated with the link being dragged. // Set the title associated with the link being dragged.
/// ///
void (CEF_CALLBACK *set_link_title)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_link_title)(struct _cef_drag_data_t* self,
const cef_string_t* title); const cef_string_t* title);
/// ///
// Set the metadata associated with the link being dragged. // Set the metadata associated with the link being dragged.
/// ///
void (CEF_CALLBACK *set_link_metadata)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_link_metadata)(struct _cef_drag_data_t* self,
const cef_string_t* data); const cef_string_t* data);
/// ///
// Set the plain text fragment that is being dragged. // Set the plain text fragment that is being dragged.
/// ///
void (CEF_CALLBACK *set_fragment_text)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_fragment_text)(struct _cef_drag_data_t* self,
const cef_string_t* text); const cef_string_t* text);
/// ///
// Set the text/html fragment that is being dragged. // Set the text/html fragment that is being dragged.
/// ///
void (CEF_CALLBACK *set_fragment_html)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_fragment_html)(struct _cef_drag_data_t* self,
const cef_string_t* html); const cef_string_t* html);
/// ///
// Set the base URL that the fragment came from. // Set the base URL that the fragment came from.
/// ///
void (CEF_CALLBACK *set_fragment_base_url)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* set_fragment_base_url)(struct _cef_drag_data_t* self,
const cef_string_t* base_url); const cef_string_t* base_url);
/// ///
@ -189,38 +190,37 @@ typedef struct _cef_drag_data_t {
// cef_browser_host_t::DragTargetDragEnter as the web view does not allow us // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
// to drag in this kind of data. // to drag in this kind of data.
/// ///
void (CEF_CALLBACK *reset_file_contents)(struct _cef_drag_data_t* self); void(CEF_CALLBACK* reset_file_contents)(struct _cef_drag_data_t* self);
/// ///
// Add a file that is being dragged into the webview. // Add a file that is being dragged into the webview.
/// ///
void (CEF_CALLBACK *add_file)(struct _cef_drag_data_t* self, void(CEF_CALLBACK* add_file)(struct _cef_drag_data_t* self,
const cef_string_t* path, const cef_string_t* display_name); const cef_string_t* path,
const cef_string_t* display_name);
/// ///
// Get the image representation of drag data. May return NULL if no image // Get the image representation of drag data. May return NULL if no image
// representation is available. // representation is available.
/// ///
struct _cef_image_t* (CEF_CALLBACK *get_image)(struct _cef_drag_data_t* self); struct _cef_image_t*(CEF_CALLBACK* get_image)(struct _cef_drag_data_t* self);
/// ///
// Get the image hotspot (drag start location relative to image dimensions). // Get the image hotspot (drag start location relative to image dimensions).
/// ///
cef_point_t (CEF_CALLBACK *get_image_hotspot)(struct _cef_drag_data_t* self); cef_point_t(CEF_CALLBACK* get_image_hotspot)(struct _cef_drag_data_t* self);
/// ///
// Returns true (1) if an image representation of drag data is available. // Returns true (1) if an image representation of drag data is available.
/// ///
int (CEF_CALLBACK *has_image)(struct _cef_drag_data_t* self); int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self);
} cef_drag_data_t; } cef_drag_data_t;
/// ///
// Create a new cef_drag_data_t object. // Create a new cef_drag_data_t object.
/// ///
CEF_EXPORT cef_drag_data_t* cef_drag_data_create(); CEF_EXPORT cef_drag_data_t* cef_drag_data_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

17
include/capi/cef_drag_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=c557dad9522f4bd4c6b3295d149c6b893fc18d52$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to dragging. The functions // Implement this structure to handle events related to dragging. The functions
// of this structure will be called on the UI thread. // of this structure will be called on the UI thread.
@ -63,8 +64,9 @@ typedef struct _cef_drag_handler_t {
// operation. Return false (0) for default drag handling behavior or true (1) // operation. Return false (0) for default drag handling behavior or true (1)
// to cancel the drag event. // to cancel the drag event.
/// ///
int (CEF_CALLBACK *on_drag_enter)(struct _cef_drag_handler_t* self, int(CEF_CALLBACK* on_drag_enter)(struct _cef_drag_handler_t* self,
struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData, struct _cef_browser_t* browser,
struct _cef_drag_data_t* dragData,
cef_drag_operations_mask_t mask); cef_drag_operations_mask_t mask);
/// ///
@ -74,12 +76,13 @@ typedef struct _cef_drag_handler_t {
// never be called. If the last draggable region is removed from a document // never be called. If the last draggable region is removed from a document
// this function will be called with an NULL vector. // this function will be called with an NULL vector.
/// ///
void (CEF_CALLBACK *on_draggable_regions_changed)( void(CEF_CALLBACK* on_draggable_regions_changed)(
struct _cef_drag_handler_t* self, struct _cef_browser_t* browser, struct _cef_drag_handler_t* self,
size_t regionsCount, cef_draggable_region_t const* regions); struct _cef_browser_t* browser,
size_t regionsCount,
cef_draggable_region_t const* regions);
} cef_drag_handler_t; } cef_drag_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

9
include/capi/cef_file_util_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=4601edefadfafea031f2c5df498262fc2142252b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Creates a directory and all parent directories if they don't already exist. // Creates a directory and all parent directories if they don't already exist.
// Returns true (1) on successful creation or if the directory already exists. // Returns true (1) on successful creation or if the directory already exists.
@ -82,7 +83,8 @@ CEF_EXPORT int cef_create_new_temp_directory(const cef_string_t* prefix,
// or IO threads is not allowed. // or IO threads is not allowed.
/// ///
CEF_EXPORT int cef_create_temp_directory_in_directory( CEF_EXPORT int cef_create_temp_directory_in_directory(
const cef_string_t* base_dir, const cef_string_t* prefix, const cef_string_t* base_dir,
const cef_string_t* prefix,
cef_string_t* new_dir); cef_string_t* new_dir);
/// ///
@ -109,7 +111,8 @@ CEF_EXPORT int cef_delete_file(const cef_string_t* path, int recursive);
// or IO threads is not allowed. // or IO threads is not allowed.
/// ///
CEF_EXPORT int cef_zip_directory(const cef_string_t* src_dir, CEF_EXPORT int cef_zip_directory(const cef_string_t* src_dir,
const cef_string_t* dest_file, int include_hidden_files); const cef_string_t* dest_file,
int include_hidden_files);
#ifdef __cplusplus #ifdef __cplusplus
} }

13
include/capi/cef_find_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=975114b079fa271fecbf31ef160974941faed8a4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to find results. The // Implement this structure to handle events related to find results. The
// functions of this structure will be called on the UI thread. // functions of this structure will be called on the UI thread.
@ -64,13 +65,15 @@ typedef struct _cef_find_handler_t {
// current position in the search results, and |finalUpdate| is true (1) if // current position in the search results, and |finalUpdate| is true (1) if
// this is the last find notification. // this is the last find notification.
/// ///
void (CEF_CALLBACK *on_find_result)(struct _cef_find_handler_t* self, void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
struct _cef_browser_t* browser, int identifier, int count, struct _cef_browser_t* browser,
const cef_rect_t* selectionRect, int activeMatchOrdinal, int identifier,
int count,
const cef_rect_t* selectionRect,
int activeMatchOrdinal,
int finalUpdate); int finalUpdate);
} cef_find_handler_t; } cef_find_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

16
include/capi/cef_focus_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=bed1f7b94e060b83e3f22eb84ce1274f2d10b3e6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
@ -47,7 +49,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to focus. The functions of // Implement this structure to handle events related to focus. The functions of
// this structure will be called on the UI thread. // this structure will be called on the UI thread.
@ -64,25 +65,26 @@ typedef struct _cef_focus_handler_t {
// will be true (1) if the browser is giving focus to the next component and // will be true (1) if the browser is giving focus to the next component and
// false (0) if the browser is giving focus to the previous component. // false (0) if the browser is giving focus to the previous component.
/// ///
void (CEF_CALLBACK *on_take_focus)(struct _cef_focus_handler_t* self, void(CEF_CALLBACK* on_take_focus)(struct _cef_focus_handler_t* self,
struct _cef_browser_t* browser, int next); struct _cef_browser_t* browser,
int next);
/// ///
// Called when the browser component is requesting focus. |source| indicates // Called when the browser component is requesting focus. |source| indicates
// where the focus request is originating from. Return false (0) to allow the // where the focus request is originating from. Return false (0) to allow the
// focus to be set or true (1) to cancel setting the focus. // focus to be set or true (1) to cancel setting the focus.
/// ///
int (CEF_CALLBACK *on_set_focus)(struct _cef_focus_handler_t* self, int(CEF_CALLBACK* on_set_focus)(struct _cef_focus_handler_t* self,
struct _cef_browser_t* browser, cef_focus_source_t source); struct _cef_browser_t* browser,
cef_focus_source_t source);
/// ///
// Called when the browser component has received focus. // Called when the browser component has received focus.
/// ///
void (CEF_CALLBACK *on_got_focus)(struct _cef_focus_handler_t* self, void(CEF_CALLBACK* on_got_focus)(struct _cef_focus_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
} cef_focus_handler_t; } cef_focus_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

57
include/capi/cef_frame_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=c1457ef21c14c40422b19b681121283eae3e9d70$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
@ -66,74 +68,74 @@ typedef struct _cef_frame_t {
/// ///
// True if this object is currently attached to a valid frame. // True if this object is currently attached to a valid frame.
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_frame_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_frame_t* self);
/// ///
// Execute undo in this frame. // Execute undo in this frame.
/// ///
void (CEF_CALLBACK *undo)(struct _cef_frame_t* self); void(CEF_CALLBACK* undo)(struct _cef_frame_t* self);
/// ///
// Execute redo in this frame. // Execute redo in this frame.
/// ///
void (CEF_CALLBACK *redo)(struct _cef_frame_t* self); void(CEF_CALLBACK* redo)(struct _cef_frame_t* self);
/// ///
// Execute cut in this frame. // Execute cut in this frame.
/// ///
void (CEF_CALLBACK *cut)(struct _cef_frame_t* self); void(CEF_CALLBACK* cut)(struct _cef_frame_t* self);
/// ///
// Execute copy in this frame. // Execute copy in this frame.
/// ///
void (CEF_CALLBACK *copy)(struct _cef_frame_t* self); void(CEF_CALLBACK* copy)(struct _cef_frame_t* self);
/// ///
// Execute paste in this frame. // Execute paste in this frame.
/// ///
void (CEF_CALLBACK *paste)(struct _cef_frame_t* self); void(CEF_CALLBACK* paste)(struct _cef_frame_t* self);
/// ///
// Execute delete in this frame. // Execute delete in this frame.
/// ///
void (CEF_CALLBACK *del)(struct _cef_frame_t* self); void(CEF_CALLBACK* del)(struct _cef_frame_t* self);
/// ///
// Execute select all in this frame. // Execute select all in this frame.
/// ///
void (CEF_CALLBACK *select_all)(struct _cef_frame_t* self); void(CEF_CALLBACK* select_all)(struct _cef_frame_t* self);
/// ///
// Save this frame's HTML source to a temporary file and open it in the // Save this frame's HTML source to a temporary file and open it in the
// default text viewing application. This function can only be called from the // default text viewing application. This function can only be called from the
// browser process. // browser process.
/// ///
void (CEF_CALLBACK *view_source)(struct _cef_frame_t* self); void(CEF_CALLBACK* view_source)(struct _cef_frame_t* self);
/// ///
// Retrieve this frame's HTML source as a string sent to the specified // Retrieve this frame's HTML source as a string sent to the specified
// visitor. // visitor.
/// ///
void (CEF_CALLBACK *get_source)(struct _cef_frame_t* self, void(CEF_CALLBACK* get_source)(struct _cef_frame_t* self,
struct _cef_string_visitor_t* visitor); struct _cef_string_visitor_t* visitor);
/// ///
// Retrieve this frame's display text as a string sent to the specified // Retrieve this frame's display text as a string sent to the specified
// visitor. // visitor.
/// ///
void (CEF_CALLBACK *get_text)(struct _cef_frame_t* self, void(CEF_CALLBACK* get_text)(struct _cef_frame_t* self,
struct _cef_string_visitor_t* visitor); struct _cef_string_visitor_t* visitor);
/// ///
// Load the request represented by the |request| object. // Load the request represented by the |request| object.
/// ///
void (CEF_CALLBACK *load_request)(struct _cef_frame_t* self, void(CEF_CALLBACK* load_request)(struct _cef_frame_t* self,
struct _cef_request_t* request); struct _cef_request_t* request);
/// ///
// Load the specified |url|. // Load the specified |url|.
/// ///
void (CEF_CALLBACK *load_url)(struct _cef_frame_t* self, void(CEF_CALLBACK* load_url)(struct _cef_frame_t* self,
const cef_string_t* url); const cef_string_t* url);
/// ///
@ -141,8 +143,9 @@ typedef struct _cef_frame_t {
// should have a standard scheme (for example, http scheme) or behaviors like // should have a standard scheme (for example, http scheme) or behaviors like
// link clicks and web security restrictions may not behave as expected. // link clicks and web security restrictions may not behave as expected.
/// ///
void (CEF_CALLBACK *load_string)(struct _cef_frame_t* self, void(CEF_CALLBACK* load_string)(struct _cef_frame_t* self,
const cef_string_t* string_val, const cef_string_t* url); const cef_string_t* string_val,
const cef_string_t* url);
/// ///
// Execute a string of JavaScript code in this frame. The |script_url| // Execute a string of JavaScript code in this frame. The |script_url|
@ -151,19 +154,20 @@ typedef struct _cef_frame_t {
// error. The |start_line| parameter is the base line number to use for error // error. The |start_line| parameter is the base line number to use for error
// reporting. // reporting.
/// ///
void (CEF_CALLBACK *execute_java_script)(struct _cef_frame_t* self, void(CEF_CALLBACK* execute_java_script)(struct _cef_frame_t* self,
const cef_string_t* code, const cef_string_t* script_url, const cef_string_t* code,
const cef_string_t* script_url,
int start_line); int start_line);
/// ///
// Returns true (1) if this is the main (top-level) frame. // Returns true (1) if this is the main (top-level) frame.
/// ///
int (CEF_CALLBACK *is_main)(struct _cef_frame_t* self); int(CEF_CALLBACK* is_main)(struct _cef_frame_t* self);
/// ///
// Returns true (1) if this is the focused frame. // Returns true (1) if this is the focused frame.
/// ///
int (CEF_CALLBACK *is_focused)(struct _cef_frame_t* self); int(CEF_CALLBACK* is_focused)(struct _cef_frame_t* self);
/// ///
// Returns the name for this frame. If the frame has an assigned name (for // Returns the name for this frame. If the frame has an assigned name (for
@ -173,47 +177,46 @@ typedef struct _cef_frame_t {
// value. // value.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_name)(struct _cef_frame_t* self); cef_string_userfree_t(CEF_CALLBACK* get_name)(struct _cef_frame_t* self);
/// ///
// Returns the globally unique identifier for this frame or < 0 if the // Returns the globally unique identifier for this frame or < 0 if the
// underlying frame does not yet exist. // underlying frame does not yet exist.
/// ///
int64 (CEF_CALLBACK *get_identifier)(struct _cef_frame_t* self); int64(CEF_CALLBACK* get_identifier)(struct _cef_frame_t* self);
/// ///
// Returns the parent of this frame or NULL if this is the main (top-level) // Returns the parent of this frame or NULL if this is the main (top-level)
// frame. // frame.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_parent)(struct _cef_frame_t* self); struct _cef_frame_t*(CEF_CALLBACK* get_parent)(struct _cef_frame_t* self);
/// ///
// Returns the URL currently loaded in this frame. // Returns the URL currently loaded in this frame.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_frame_t* self); cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_frame_t* self);
/// ///
// Returns the browser that this frame belongs to. // Returns the browser that this frame belongs to.
/// ///
struct _cef_browser_t* (CEF_CALLBACK *get_browser)(struct _cef_frame_t* self); struct _cef_browser_t*(CEF_CALLBACK* get_browser)(struct _cef_frame_t* self);
/// ///
// Get the V8 context associated with the frame. This function can only be // Get the V8 context associated with the frame. This function can only be
// called from the render process. // called from the render process.
/// ///
struct _cef_v8context_t* (CEF_CALLBACK *get_v8context)( struct _cef_v8context_t*(CEF_CALLBACK* get_v8context)(
struct _cef_frame_t* self); struct _cef_frame_t* self);
/// ///
// Visit the DOM document. This function can only be called from the render // Visit the DOM document. This function can only be called from the render
// process. // process.
/// ///
void (CEF_CALLBACK *visit_dom)(struct _cef_frame_t* self, void(CEF_CALLBACK* visit_dom)(struct _cef_frame_t* self,
struct _cef_domvisitor_t* visitor); struct _cef_domvisitor_t* visitor);
} cef_frame_t; } cef_frame_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
include/capi/cef_geolocation_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=3ae57ba897d73f3fcccc955c827379746b6203af$
//
#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to receive geolocation updates. The functions of // Implement this structure to receive geolocation updates. The functions of
// this structure will be called on the browser process UI thread. // this structure will be called on the browser process UI thread.
@ -59,12 +60,11 @@ typedef struct _cef_get_geolocation_callback_t {
// Called with the 'best available' location information or, if the location // Called with the 'best available' location information or, if the location
// update failed, with error information. // update failed, with error information.
/// ///
void (CEF_CALLBACK *on_location_update)( void(CEF_CALLBACK* on_location_update)(
struct _cef_get_geolocation_callback_t* self, struct _cef_get_geolocation_callback_t* self,
const struct _cef_geoposition_t* position); const struct _cef_geoposition_t* position);
} cef_get_geolocation_callback_t; } cef_get_geolocation_callback_t;
/// ///
// Request a one-time geolocation update. This function bypasses any user // Request a one-time geolocation update. This function bypasses any user
// permission checks so should only be used by code that is allowed to access // permission checks so should only be used by code that is allowed to access

21
include/capi/cef_geolocation_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=ec60811fcefbe02348f14ecddbe5778ce836bf53$
//
#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure used for asynchronous continuation of geolocation // Callback structure used for asynchronous continuation of geolocation
// permission requests. // permission requests.
@ -59,11 +60,9 @@ typedef struct _cef_geolocation_callback_t {
/// ///
// Call to allow or deny geolocation access. // Call to allow or deny geolocation access.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_geolocation_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_geolocation_callback_t* self, int allow);
int allow);
} cef_geolocation_callback_t; } cef_geolocation_callback_t;
/// ///
// Implement this structure to handle events related to geolocation permission // Implement this structure to handle events related to geolocation permission
// requests. The functions of this structure will be called on the browser // requests. The functions of this structure will be called on the browser
@ -83,21 +82,23 @@ typedef struct _cef_geolocation_handler_t {
// time to continue or cancel the request. Return false (0) to cancel the // time to continue or cancel the request. Return false (0) to cancel the
// request immediately. // request immediately.
/// ///
int (CEF_CALLBACK *on_request_geolocation_permission)( int(CEF_CALLBACK* on_request_geolocation_permission)(
struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser, struct _cef_geolocation_handler_t* self,
const cef_string_t* requesting_url, int request_id, struct _cef_browser_t* browser,
const cef_string_t* requesting_url,
int request_id,
struct _cef_geolocation_callback_t* callback); struct _cef_geolocation_callback_t* callback);
/// ///
// Called when a geolocation access request is canceled. |request_id| is the // Called when a geolocation access request is canceled. |request_id| is the
// unique ID for the permission request. // unique ID for the permission request.
/// ///
void (CEF_CALLBACK *on_cancel_geolocation_permission)( void(CEF_CALLBACK* on_cancel_geolocation_permission)(
struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser, struct _cef_geolocation_handler_t* self,
struct _cef_browser_t* browser,
int request_id); int request_id);
} cef_geolocation_handler_t; } cef_geolocation_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

74
include/capi/cef_image_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=60f904f2f77ce6d89f9fceeeda0050273a3c9e6d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Container for a single image represented at different scale factors. All // Container for a single image represented at different scale factors. All
// image representations should be the same size in density independent pixel // image representations should be the same size in density independent pixel
@ -63,13 +64,13 @@ typedef struct _cef_image_t {
/// ///
// Returns true (1) if this Image is NULL. // Returns true (1) if this Image is NULL.
/// ///
int (CEF_CALLBACK *is_empty)(struct _cef_image_t* self); int(CEF_CALLBACK* is_empty)(struct _cef_image_t* self);
/// ///
// Returns true (1) if this Image and |that| Image share the same underlying // Returns true (1) if this Image and |that| Image share the same underlying
// storage. Will also return true (1) if both images are NULL. // storage. Will also return true (1) if both images are NULL.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_image_t* self, int(CEF_CALLBACK* is_same)(struct _cef_image_t* self,
struct _cef_image_t* that); struct _cef_image_t* that);
/// ///
@ -79,9 +80,13 @@ typedef struct _cef_image_t {
// pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size. // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
// |color_type| and |alpha_type| values specify the pixel format. // |color_type| and |alpha_type| values specify the pixel format.
/// ///
int (CEF_CALLBACK *add_bitmap)(struct _cef_image_t* self, float scale_factor, int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self,
int pixel_width, int pixel_height, cef_color_type_t color_type, float scale_factor,
cef_alpha_type_t alpha_type, const void* pixel_data, int pixel_width,
int pixel_height,
cef_color_type_t color_type,
cef_alpha_type_t alpha_type,
const void* pixel_data,
size_t pixel_data_size); size_t pixel_data_size);
/// ///
@ -89,38 +94,42 @@ typedef struct _cef_image_t {
// data of size |png_data_size|. Any alpha transparency in the PNG data will // data of size |png_data_size|. Any alpha transparency in the PNG data will
// be maintained. // be maintained.
/// ///
int (CEF_CALLBACK *add_png)(struct _cef_image_t* self, float scale_factor, int(CEF_CALLBACK* add_png)(struct _cef_image_t* self,
const void* png_data, size_t png_data_size); float scale_factor,
const void* png_data,
size_t png_data_size);
/// ///
// Create a JPEG image representation for |scale_factor|. |jpeg_data| is the // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
// image data of size |jpeg_data_size|. The JPEG format does not support // image data of size |jpeg_data_size|. The JPEG format does not support
// transparency so the alpha byte will be set to 0xFF for all pixels. // transparency so the alpha byte will be set to 0xFF for all pixels.
/// ///
int (CEF_CALLBACK *add_jpeg)(struct _cef_image_t* self, float scale_factor, int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self,
const void* jpeg_data, size_t jpeg_data_size); float scale_factor,
const void* jpeg_data,
size_t jpeg_data_size);
/// ///
// Returns the image width in density independent pixel (DIP) units. // Returns the image width in density independent pixel (DIP) units.
/// ///
size_t (CEF_CALLBACK *get_width)(struct _cef_image_t* self); size_t(CEF_CALLBACK* get_width)(struct _cef_image_t* self);
/// ///
// Returns the image height in density independent pixel (DIP) units. // Returns the image height in density independent pixel (DIP) units.
/// ///
size_t (CEF_CALLBACK *get_height)(struct _cef_image_t* self); size_t(CEF_CALLBACK* get_height)(struct _cef_image_t* self);
/// ///
// Returns true (1) if this image contains a representation for // Returns true (1) if this image contains a representation for
// |scale_factor|. // |scale_factor|.
/// ///
int (CEF_CALLBACK *has_representation)(struct _cef_image_t* self, int(CEF_CALLBACK* has_representation)(struct _cef_image_t* self,
float scale_factor); float scale_factor);
/// ///
// Removes the representation for |scale_factor|. Returns true (1) on success. // Removes the representation for |scale_factor|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *remove_representation)(struct _cef_image_t* self, int(CEF_CALLBACK* remove_representation)(struct _cef_image_t* self,
float scale_factor); float scale_factor);
/// ///
@ -129,8 +138,10 @@ typedef struct _cef_image_t {
// representation. |pixel_width| and |pixel_height| are the representation // representation. |pixel_width| and |pixel_height| are the representation
// size in pixel coordinates. Returns true (1) on success. // size in pixel coordinates. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *get_representation_info)(struct _cef_image_t* self, int(CEF_CALLBACK* get_representation_info)(struct _cef_image_t* self,
float scale_factor, float* actual_scale_factor, int* pixel_width, float scale_factor,
float* actual_scale_factor,
int* pixel_width,
int* pixel_height); int* pixel_height);
/// ///
@ -141,10 +152,13 @@ typedef struct _cef_image_t {
// Returns a cef_binary_value_t containing the pixel data on success or NULL // Returns a cef_binary_value_t containing the pixel data on success or NULL
// on failure. // on failure.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_as_bitmap)( struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)(
struct _cef_image_t* self, float scale_factor, struct _cef_image_t* self,
cef_color_type_t color_type, cef_alpha_type_t alpha_type, float scale_factor,
int* pixel_width, int* pixel_height); cef_color_type_t color_type,
cef_alpha_type_t alpha_type,
int* pixel_width,
int* pixel_height);
/// ///
// Returns the PNG representation that most closely matches |scale_factor|. If // Returns the PNG representation that most closely matches |scale_factor|. If
@ -154,9 +168,12 @@ typedef struct _cef_image_t {
// cef_binary_value_t containing the PNG image data on success or NULL on // cef_binary_value_t containing the PNG image data on success or NULL on
// failure. // failure.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_as_png)( struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)(
struct _cef_image_t* self, float scale_factor, int with_transparency, struct _cef_image_t* self,
int* pixel_width, int* pixel_height); float scale_factor,
int with_transparency,
int* pixel_width,
int* pixel_height);
/// ///
// Returns the JPEG representation that most closely matches |scale_factor|. // Returns the JPEG representation that most closely matches |scale_factor|.
@ -167,19 +184,20 @@ typedef struct _cef_image_t {
// cef_binary_value_t containing the JPEG image data on success or NULL on // cef_binary_value_t containing the JPEG image data on success or NULL on
// failure. // failure.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_as_jpeg)( struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)(
struct _cef_image_t* self, float scale_factor, int quality, struct _cef_image_t* self,
int* pixel_width, int* pixel_height); float scale_factor,
int quality,
int* pixel_width,
int* pixel_height);
} cef_image_t; } cef_image_t;
/// ///
// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions // Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
// to add representations at different scale factors. // to add representations at different scale factors.
/// ///
CEF_EXPORT cef_image_t* cef_image_create(); CEF_EXPORT cef_image_t* cef_image_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

34
include/capi/cef_jsdialog_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=351cff5a52f29b54d1854d5dfbb1733c8a62797d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure used for asynchronous continuation of JavaScript dialog // Callback structure used for asynchronous continuation of JavaScript dialog
// requests. // requests.
@ -60,11 +61,11 @@ typedef struct _cef_jsdialog_callback_t {
// Continue the JS dialog request. Set |success| to true (1) if the OK button // Continue the JS dialog request. Set |success| to true (1) if the OK button
// was pressed. The |user_input| value should be specified for prompt dialogs. // was pressed. The |user_input| value should be specified for prompt dialogs.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_jsdialog_callback_t* self, int success, void(CEF_CALLBACK* cont)(struct _cef_jsdialog_callback_t* self,
int success,
const cef_string_t* user_input); const cef_string_t* user_input);
} cef_jsdialog_callback_t; } cef_jsdialog_callback_t;
/// ///
// Implement this structure to handle events related to JavaScript dialogs. The // Implement this structure to handle events related to JavaScript dialogs. The
// functions of this structure will be called on the UI thread. // functions of this structure will be called on the UI thread.
@ -92,11 +93,14 @@ typedef struct _cef_jsdialog_handler_t {
// the application must execute |callback| once the custom dialog is // the application must execute |callback| once the custom dialog is
// dismissed. // dismissed.
/// ///
int (CEF_CALLBACK *on_jsdialog)(struct _cef_jsdialog_handler_t* self, int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* origin_url, struct _cef_browser_t* browser,
cef_jsdialog_type_t dialog_type, const cef_string_t* message_text, const cef_string_t* origin_url,
cef_jsdialog_type_t dialog_type,
const cef_string_t* message_text,
const cef_string_t* default_prompt_text, const cef_string_t* default_prompt_text,
struct _cef_jsdialog_callback_t* callback, int* suppress_message); struct _cef_jsdialog_callback_t* callback,
int* suppress_message);
/// ///
// Called to run a dialog asking the user if they want to leave a page. Return // Called to run a dialog asking the user if they want to leave a page. Return
@ -106,9 +110,11 @@ typedef struct _cef_jsdialog_handler_t {
// dialog is used the application must execute |callback| once the custom // dialog is used the application must execute |callback| once the custom
// dialog is dismissed. // dialog is dismissed.
/// ///
int (CEF_CALLBACK *on_before_unload_dialog)( int(CEF_CALLBACK* on_before_unload_dialog)(
struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser, struct _cef_jsdialog_handler_t* self,
const cef_string_t* message_text, int is_reload, struct _cef_browser_t* browser,
const cef_string_t* message_text,
int is_reload,
struct _cef_jsdialog_callback_t* callback); struct _cef_jsdialog_callback_t* callback);
/// ///
@ -116,17 +122,17 @@ typedef struct _cef_jsdialog_handler_t {
// be called due to events like page navigation irregardless of whether any // be called due to events like page navigation irregardless of whether any
// dialogs are currently pending. // dialogs are currently pending.
/// ///
void (CEF_CALLBACK *on_reset_dialog_state)( void(CEF_CALLBACK* on_reset_dialog_state)(
struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser); struct _cef_jsdialog_handler_t* self,
struct _cef_browser_t* browser);
/// ///
// Called when the default implementation dialog is closed. // Called when the default implementation dialog is closed.
/// ///
void (CEF_CALLBACK *on_dialog_closed)(struct _cef_jsdialog_handler_t* self, void(CEF_CALLBACK* on_dialog_closed)(struct _cef_jsdialog_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
} cef_jsdialog_handler_t; } cef_jsdialog_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

17
include/capi/cef_keyboard_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=07c2a01bb9975fa52fdb287712f8f369557ba755$
//
#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to keyboard input. The // Implement this structure to handle events related to keyboard input. The
// functions of this structure will be called on the UI thread. // functions of this structure will be called on the UI thread.
@ -63,9 +64,11 @@ typedef struct _cef_keyboard_handler_t {
// (0) otherwise. If the event will be handled in on_key_event() as a keyboard // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
// shortcut set |is_keyboard_shortcut| to true (1) and return false (0). // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
/// ///
int (CEF_CALLBACK *on_pre_key_event)(struct _cef_keyboard_handler_t* self, int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self,
struct _cef_browser_t* browser, const struct _cef_key_event_t* event, struct _cef_browser_t* browser,
cef_event_handle_t os_event, int* is_keyboard_shortcut); const struct _cef_key_event_t* event,
cef_event_handle_t os_event,
int* is_keyboard_shortcut);
/// ///
// Called after the renderer and JavaScript in the page has had a chance to // Called after the renderer and JavaScript in the page has had a chance to
@ -73,12 +76,12 @@ typedef struct _cef_keyboard_handler_t {
// |os_event| is the operating system event message, if any. Return true (1) // |os_event| is the operating system event message, if any. Return true (1)
// if the keyboard event was handled or false (0) otherwise. // if the keyboard event was handled or false (0) otherwise.
/// ///
int (CEF_CALLBACK *on_key_event)(struct _cef_keyboard_handler_t* self, int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self,
struct _cef_browser_t* browser, const struct _cef_key_event_t* event, struct _cef_browser_t* browser,
const struct _cef_key_event_t* event,
cef_event_handle_t os_event); cef_event_handle_t os_event);
} cef_keyboard_handler_t; } cef_keyboard_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

27
include/capi/cef_life_span_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=7894d507f337ebe5f9296770e10773a4e6458f00$
//
#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@ -80,19 +82,25 @@ typedef struct _cef_life_span_handler_t {
// the parent browser is destroyed before the popup browser creation completes // the parent browser is destroyed before the popup browser creation completes
// (indicated by a call to OnAfterCreated for the popup browser). // (indicated by a call to OnAfterCreated for the popup browser).
/// ///
int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self, int(CEF_CALLBACK* on_before_popup)(
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_life_span_handler_t* self,
const cef_string_t* target_url, const cef_string_t* target_frame_name, struct _cef_browser_t* browser,
cef_window_open_disposition_t target_disposition, int user_gesture, struct _cef_frame_t* frame,
const cef_string_t* target_url,
const cef_string_t* target_frame_name,
cef_window_open_disposition_t target_disposition,
int user_gesture,
const struct _cef_popup_features_t* popupFeatures, const struct _cef_popup_features_t* popupFeatures,
struct _cef_window_info_t* windowInfo, struct _cef_client_t** client, struct _cef_window_info_t* windowInfo,
struct _cef_browser_settings_t* settings, int* no_javascript_access); struct _cef_client_t** client,
struct _cef_browser_settings_t* settings,
int* no_javascript_access);
/// ///
// Called after a new browser is created. This callback will be the first // Called after a new browser is created. This callback will be the first
// notification that references |browser|. // notification that references |browser|.
/// ///
void (CEF_CALLBACK *on_after_created)(struct _cef_life_span_handler_t* self, void(CEF_CALLBACK* on_after_created)(struct _cef_life_span_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
@ -184,7 +192,7 @@ typedef struct _cef_life_span_handler_t {
// browsers // browsers
// exist. // exist.
/// ///
int (CEF_CALLBACK *do_close)(struct _cef_life_span_handler_t* self, int(CEF_CALLBACK* do_close)(struct _cef_life_span_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
@ -194,11 +202,10 @@ typedef struct _cef_life_span_handler_t {
// notification that references |browser|. See do_close() documentation for // notification that references |browser|. See do_close() documentation for
// additional usage information. // additional usage information.
/// ///
void (CEF_CALLBACK *on_before_close)(struct _cef_life_span_handler_t* self, void(CEF_CALLBACK* on_before_close)(struct _cef_life_span_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
} cef_life_span_handler_t; } cef_life_span_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

28
include/capi/cef_load_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=d8fa87bb47ec889cab864fe96f94e07bf1deb0f6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events related to browser load status. The // Implement this structure to handle events related to browser load status. The
// functions of this structure will be called on the browser process UI thread // functions of this structure will be called on the browser process UI thread
@ -65,8 +66,10 @@ typedef struct _cef_load_handler_t {
// of failure. It will be called before any calls to OnLoadStart and after all // of failure. It will be called before any calls to OnLoadStart and after all
// calls to OnLoadError and/or OnLoadEnd. // calls to OnLoadError and/or OnLoadEnd.
/// ///
void (CEF_CALLBACK *on_loading_state_change)(struct _cef_load_handler_t* self, void(CEF_CALLBACK* on_loading_state_change)(struct _cef_load_handler_t* self,
struct _cef_browser_t* browser, int isLoading, int canGoBack, struct _cef_browser_t* browser,
int isLoading,
int canGoBack,
int canGoForward); int canGoForward);
/// ///
@ -81,8 +84,9 @@ typedef struct _cef_load_handler_t {
// navigations that fail or are canceled before commit. For notification of // navigations that fail or are canceled before commit. For notification of
// overall browser load status use OnLoadingStateChange instead. // overall browser load status use OnLoadingStateChange instead.
/// ///
void (CEF_CALLBACK *on_load_start)(struct _cef_load_handler_t* self, void(CEF_CALLBACK* on_load_start)(struct _cef_load_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
cef_transition_type_t transition_type); cef_transition_type_t transition_type);
/// ///
@ -95,8 +99,9 @@ typedef struct _cef_load_handler_t {
// For notification of overall browser load status use OnLoadingStateChange // For notification of overall browser load status use OnLoadingStateChange
// instead. // instead.
/// ///
void (CEF_CALLBACK *on_load_end)(struct _cef_load_handler_t* self, void(CEF_CALLBACK* on_load_end)(struct _cef_load_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
int httpStatusCode); int httpStatusCode);
/// ///
@ -106,13 +111,14 @@ typedef struct _cef_load_handler_t {
// error text and |failedUrl| is the URL that failed to load. See // error text and |failedUrl| is the URL that failed to load. See
// net\base\net_error_list.h for complete descriptions of the error codes. // net\base\net_error_list.h for complete descriptions of the error codes.
/// ///
void (CEF_CALLBACK *on_load_error)(struct _cef_load_handler_t* self, void(CEF_CALLBACK* on_load_error)(struct _cef_load_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
cef_errorcode_t errorCode, const cef_string_t* errorText, struct _cef_frame_t* frame,
cef_errorcode_t errorCode,
const cef_string_t* errorText,
const cef_string_t* failedUrl); const cef_string_t* failedUrl);
} cef_load_handler_t; } cef_load_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

223
include/capi/cef_menu_model_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=295f7f55ebe6d548aba1476e67efb2c88ab10ca5$
//
#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Supports creation and modification of menus. See cef_menu_id_t for the // Supports creation and modification of menus. See cef_menu_id_t for the
// command ids that have default implementations. All user-defined command ids // command ids that have default implementations. All user-defined command ids
@ -61,328 +62,362 @@ typedef struct _cef_menu_model_t {
/// ///
// Returns true (1) if this menu is a submenu. // Returns true (1) if this menu is a submenu.
/// ///
int (CEF_CALLBACK *is_sub_menu)(struct _cef_menu_model_t* self); int(CEF_CALLBACK* is_sub_menu)(struct _cef_menu_model_t* self);
/// ///
// Clears the menu. Returns true (1) on success. // Clears the menu. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *clear)(struct _cef_menu_model_t* self); int(CEF_CALLBACK* clear)(struct _cef_menu_model_t* self);
/// ///
// Returns the number of items in this menu. // Returns the number of items in this menu.
/// ///
int (CEF_CALLBACK *get_count)(struct _cef_menu_model_t* self); int(CEF_CALLBACK* get_count)(struct _cef_menu_model_t* self);
/// ///
// Add a separator to the menu. Returns true (1) on success. // Add a separator to the menu. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *add_separator)(struct _cef_menu_model_t* self); int(CEF_CALLBACK* add_separator)(struct _cef_menu_model_t* self);
/// ///
// Add an item to the menu. Returns true (1) on success. // Add an item to the menu. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *add_item)(struct _cef_menu_model_t* self, int command_id, int(CEF_CALLBACK* add_item)(struct _cef_menu_model_t* self,
int command_id,
const cef_string_t* label); const cef_string_t* label);
/// ///
// Add a check item to the menu. Returns true (1) on success. // Add a check item to the menu. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *add_check_item)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* add_check_item)(struct _cef_menu_model_t* self,
int command_id, const cef_string_t* label); int command_id,
const cef_string_t* label);
/// ///
// Add a radio item to the menu. Only a single item with the specified // Add a radio item to the menu. Only a single item with the specified
// |group_id| can be checked at a time. Returns true (1) on success. // |group_id| can be checked at a time. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *add_radio_item)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* add_radio_item)(struct _cef_menu_model_t* self,
int command_id, const cef_string_t* label, int group_id); int command_id,
const cef_string_t* label,
int group_id);
/// ///
// Add a sub-menu to the menu. The new sub-menu is returned. // Add a sub-menu to the menu. The new sub-menu is returned.
/// ///
struct _cef_menu_model_t* (CEF_CALLBACK *add_sub_menu)( struct _cef_menu_model_t*(CEF_CALLBACK* add_sub_menu)(
struct _cef_menu_model_t* self, int command_id, struct _cef_menu_model_t* self,
int command_id,
const cef_string_t* label); const cef_string_t* label);
/// ///
// Insert a separator in the menu at the specified |index|. Returns true (1) // Insert a separator in the menu at the specified |index|. Returns true (1)
// on success. // on success.
/// ///
int (CEF_CALLBACK *insert_separator_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* insert_separator_at)(struct _cef_menu_model_t* self,
int index); int index);
/// ///
// Insert an item in the menu at the specified |index|. Returns true (1) on // Insert an item in the menu at the specified |index|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *insert_item_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* insert_item_at)(struct _cef_menu_model_t* self,
int command_id, const cef_string_t* label); int index,
int command_id,
const cef_string_t* label);
/// ///
// Insert a check item in the menu at the specified |index|. Returns true (1) // Insert a check item in the menu at the specified |index|. Returns true (1)
// on success. // on success.
/// ///
int (CEF_CALLBACK *insert_check_item_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* insert_check_item_at)(struct _cef_menu_model_t* self,
int index, int command_id, const cef_string_t* label); int index,
int command_id,
const cef_string_t* label);
/// ///
// Insert a radio item in the menu at the specified |index|. Only a single // Insert a radio item in the menu at the specified |index|. Only a single
// item with the specified |group_id| can be checked at a time. Returns true // item with the specified |group_id| can be checked at a time. Returns true
// (1) on success. // (1) on success.
/// ///
int (CEF_CALLBACK *insert_radio_item_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* insert_radio_item_at)(struct _cef_menu_model_t* self,
int index, int command_id, const cef_string_t* label, int group_id); int index,
int command_id,
const cef_string_t* label,
int group_id);
/// ///
// Insert a sub-menu in the menu at the specified |index|. The new sub-menu is // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
// returned. // returned.
/// ///
struct _cef_menu_model_t* (CEF_CALLBACK *insert_sub_menu_at)( struct _cef_menu_model_t*(CEF_CALLBACK* insert_sub_menu_at)(
struct _cef_menu_model_t* self, int index, int command_id, struct _cef_menu_model_t* self,
int index,
int command_id,
const cef_string_t* label); const cef_string_t* label);
/// ///
// Removes the item with the specified |command_id|. Returns true (1) on // Removes the item with the specified |command_id|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *remove)(struct _cef_menu_model_t* self, int command_id); int(CEF_CALLBACK* remove)(struct _cef_menu_model_t* self, int command_id);
/// ///
// Removes the item at the specified |index|. Returns true (1) on success. // Removes the item at the specified |index|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *remove_at)(struct _cef_menu_model_t* self, int index); int(CEF_CALLBACK* remove_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Returns the index associated with the specified |command_id| or -1 if not // Returns the index associated with the specified |command_id| or -1 if not
// found due to the command id not existing in the menu. // found due to the command id not existing in the menu.
/// ///
int (CEF_CALLBACK *get_index_of)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_index_of)(struct _cef_menu_model_t* self,
int command_id); int command_id);
/// ///
// Returns the command id at the specified |index| or -1 if not found due to // Returns the command id at the specified |index| or -1 if not found due to
// invalid range or the index being a separator. // invalid range or the index being a separator.
/// ///
int (CEF_CALLBACK *get_command_id_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_command_id_at)(struct _cef_menu_model_t* self,
int index); int index);
/// ///
// Sets the command id at the specified |index|. Returns true (1) on success. // Sets the command id at the specified |index|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_command_id_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_command_id_at)(struct _cef_menu_model_t* self,
int index, int command_id); int index,
int command_id);
/// ///
// Returns the label for the specified |command_id| or NULL if not found. // Returns the label for the specified |command_id| or NULL if not found.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_label)( cef_string_userfree_t(CEF_CALLBACK* get_label)(struct _cef_menu_model_t* self,
struct _cef_menu_model_t* self, int command_id); int command_id);
/// ///
// Returns the label at the specified |index| or NULL if not found due to // Returns the label at the specified |index| or NULL if not found due to
// invalid range or the index being a separator. // invalid range or the index being a separator.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_label_at)( cef_string_userfree_t(
struct _cef_menu_model_t* self, int index); CEF_CALLBACK* get_label_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Sets the label for the specified |command_id|. Returns true (1) on success. // Sets the label for the specified |command_id|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_label)(struct _cef_menu_model_t* self, int command_id, int(CEF_CALLBACK* set_label)(struct _cef_menu_model_t* self,
int command_id,
const cef_string_t* label); const cef_string_t* label);
/// ///
// Set the label at the specified |index|. Returns true (1) on success. // Set the label at the specified |index|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_label_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_label_at)(struct _cef_menu_model_t* self,
int index,
const cef_string_t* label); const cef_string_t* label);
/// ///
// Returns the item type for the specified |command_id|. // Returns the item type for the specified |command_id|.
/// ///
cef_menu_item_type_t (CEF_CALLBACK *get_type)(struct _cef_menu_model_t* self, cef_menu_item_type_t(CEF_CALLBACK* get_type)(struct _cef_menu_model_t* self,
int command_id); int command_id);
/// ///
// Returns the item type at the specified |index|. // Returns the item type at the specified |index|.
/// ///
cef_menu_item_type_t (CEF_CALLBACK *get_type_at)( cef_menu_item_type_t(
struct _cef_menu_model_t* self, int index); CEF_CALLBACK* get_type_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Returns the group id for the specified |command_id| or -1 if invalid. // Returns the group id for the specified |command_id| or -1 if invalid.
/// ///
int (CEF_CALLBACK *get_group_id)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_group_id)(struct _cef_menu_model_t* self,
int command_id); int command_id);
/// ///
// Returns the group id at the specified |index| or -1 if invalid. // Returns the group id at the specified |index| or -1 if invalid.
/// ///
int (CEF_CALLBACK *get_group_id_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_group_id_at)(struct _cef_menu_model_t* self, int index);
int index);
/// ///
// Sets the group id for the specified |command_id|. Returns true (1) on // Sets the group id for the specified |command_id|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *set_group_id)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_group_id)(struct _cef_menu_model_t* self,
int command_id, int group_id); int command_id,
int group_id);
/// ///
// Sets the group id at the specified |index|. Returns true (1) on success. // Sets the group id at the specified |index|. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_group_id_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_group_id_at)(struct _cef_menu_model_t* self,
int index,
int group_id); int group_id);
/// ///
// Returns the submenu for the specified |command_id| or NULL if invalid. // Returns the submenu for the specified |command_id| or NULL if invalid.
/// ///
struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu)( struct _cef_menu_model_t*(CEF_CALLBACK* get_sub_menu)(
struct _cef_menu_model_t* self, int command_id); struct _cef_menu_model_t* self,
int command_id);
/// ///
// Returns the submenu at the specified |index| or NULL if invalid. // Returns the submenu at the specified |index| or NULL if invalid.
/// ///
struct _cef_menu_model_t* (CEF_CALLBACK *get_sub_menu_at)( struct _cef_menu_model_t*(
struct _cef_menu_model_t* self, int index); CEF_CALLBACK* get_sub_menu_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Returns true (1) if the specified |command_id| is visible. // Returns true (1) if the specified |command_id| is visible.
/// ///
int (CEF_CALLBACK *is_visible)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* is_visible)(struct _cef_menu_model_t* self, int command_id);
int command_id);
/// ///
// Returns true (1) if the specified |index| is visible. // Returns true (1) if the specified |index| is visible.
/// ///
int (CEF_CALLBACK *is_visible_at)(struct _cef_menu_model_t* self, int index); int(CEF_CALLBACK* is_visible_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Change the visibility of the specified |command_id|. Returns true (1) on // Change the visibility of the specified |command_id|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *set_visible)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_visible)(struct _cef_menu_model_t* self,
int command_id, int visible); int command_id,
int visible);
/// ///
// Change the visibility at the specified |index|. Returns true (1) on // Change the visibility at the specified |index|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *set_visible_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_visible_at)(struct _cef_menu_model_t* self,
int index,
int visible); int visible);
/// ///
// Returns true (1) if the specified |command_id| is enabled. // Returns true (1) if the specified |command_id| is enabled.
/// ///
int (CEF_CALLBACK *is_enabled)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* is_enabled)(struct _cef_menu_model_t* self, int command_id);
int command_id);
/// ///
// Returns true (1) if the specified |index| is enabled. // Returns true (1) if the specified |index| is enabled.
/// ///
int (CEF_CALLBACK *is_enabled_at)(struct _cef_menu_model_t* self, int index); int(CEF_CALLBACK* is_enabled_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Change the enabled status of the specified |command_id|. Returns true (1) // Change the enabled status of the specified |command_id|. Returns true (1)
// on success. // on success.
/// ///
int (CEF_CALLBACK *set_enabled)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_enabled)(struct _cef_menu_model_t* self,
int command_id, int enabled); int command_id,
int enabled);
/// ///
// Change the enabled status at the specified |index|. Returns true (1) on // Change the enabled status at the specified |index|. Returns true (1) on
// success. // success.
/// ///
int (CEF_CALLBACK *set_enabled_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_enabled_at)(struct _cef_menu_model_t* self,
int index,
int enabled); int enabled);
/// ///
// Returns true (1) if the specified |command_id| is checked. Only applies to // Returns true (1) if the specified |command_id| is checked. Only applies to
// check and radio items. // check and radio items.
/// ///
int (CEF_CALLBACK *is_checked)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* is_checked)(struct _cef_menu_model_t* self, int command_id);
int command_id);
/// ///
// Returns true (1) if the specified |index| is checked. Only applies to check // Returns true (1) if the specified |index| is checked. Only applies to check
// and radio items. // and radio items.
/// ///
int (CEF_CALLBACK *is_checked_at)(struct _cef_menu_model_t* self, int index); int(CEF_CALLBACK* is_checked_at)(struct _cef_menu_model_t* self, int index);
/// ///
// Check the specified |command_id|. Only applies to check and radio items. // Check the specified |command_id|. Only applies to check and radio items.
// Returns true (1) on success. // Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_checked)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_checked)(struct _cef_menu_model_t* self,
int command_id, int checked); int command_id,
int checked);
/// ///
// Check the specified |index|. Only applies to check and radio items. Returns // Check the specified |index|. Only applies to check and radio items. Returns
// true (1) on success. // true (1) on success.
/// ///
int (CEF_CALLBACK *set_checked_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_checked_at)(struct _cef_menu_model_t* self,
int index,
int checked); int checked);
/// ///
// Returns true (1) if the specified |command_id| has a keyboard accelerator // Returns true (1) if the specified |command_id| has a keyboard accelerator
// assigned. // assigned.
/// ///
int (CEF_CALLBACK *has_accelerator)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* has_accelerator)(struct _cef_menu_model_t* self,
int command_id); int command_id);
/// ///
// Returns true (1) if the specified |index| has a keyboard accelerator // Returns true (1) if the specified |index| has a keyboard accelerator
// assigned. // assigned.
/// ///
int (CEF_CALLBACK *has_accelerator_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* has_accelerator_at)(struct _cef_menu_model_t* self,
int index); int index);
/// ///
// Set the keyboard accelerator for the specified |command_id|. |key_code| can // Set the keyboard accelerator for the specified |command_id|. |key_code| can
// be any virtual key or character value. Returns true (1) on success. // be any virtual key or character value. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_accelerator)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_accelerator)(struct _cef_menu_model_t* self,
int command_id, int key_code, int shift_pressed, int ctrl_pressed, int command_id,
int key_code,
int shift_pressed,
int ctrl_pressed,
int alt_pressed); int alt_pressed);
/// ///
// Set the keyboard accelerator at the specified |index|. |key_code| can be // Set the keyboard accelerator at the specified |index|. |key_code| can be
// any virtual key or character value. Returns true (1) on success. // any virtual key or character value. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_accelerator_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_accelerator_at)(struct _cef_menu_model_t* self,
int index, int key_code, int shift_pressed, int ctrl_pressed, int index,
int key_code,
int shift_pressed,
int ctrl_pressed,
int alt_pressed); int alt_pressed);
/// ///
// Remove the keyboard accelerator for the specified |command_id|. Returns // Remove the keyboard accelerator for the specified |command_id|. Returns
// true (1) on success. // true (1) on success.
/// ///
int (CEF_CALLBACK *remove_accelerator)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* remove_accelerator)(struct _cef_menu_model_t* self,
int command_id); int command_id);
/// ///
// Remove the keyboard accelerator at the specified |index|. Returns true (1) // Remove the keyboard accelerator at the specified |index|. Returns true (1)
// on success. // on success.
/// ///
int (CEF_CALLBACK *remove_accelerator_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* remove_accelerator_at)(struct _cef_menu_model_t* self,
int index); int index);
/// ///
// Retrieves the keyboard accelerator for the specified |command_id|. Returns // Retrieves the keyboard accelerator for the specified |command_id|. Returns
// true (1) on success. // true (1) on success.
/// ///
int (CEF_CALLBACK *get_accelerator)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_accelerator)(struct _cef_menu_model_t* self,
int command_id, int* key_code, int* shift_pressed, int* ctrl_pressed, int command_id,
int* key_code,
int* shift_pressed,
int* ctrl_pressed,
int* alt_pressed); int* alt_pressed);
/// ///
// Retrieves the keyboard accelerator for the specified |index|. Returns true // Retrieves the keyboard accelerator for the specified |index|. Returns true
// (1) on success. // (1) on success.
/// ///
int (CEF_CALLBACK *get_accelerator_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* get_accelerator_at)(struct _cef_menu_model_t* self,
int index, int* key_code, int* shift_pressed, int* ctrl_pressed, int index,
int* key_code,
int* shift_pressed,
int* ctrl_pressed,
int* alt_pressed); int* alt_pressed);
/// ///
@ -391,8 +426,10 @@ typedef struct _cef_menu_model_t {
// color or default color is set for |color_type| then the system color will // color or default color is set for |color_type| then the system color will
// be used. Returns true (1) on success. // be used. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_color)(struct _cef_menu_model_t* self, int command_id, int(CEF_CALLBACK* set_color)(struct _cef_menu_model_t* self,
cef_menu_color_type_t color_type, cef_color_t color); int command_id,
cef_menu_color_type_t color_type,
cef_color_t color);
/// ///
// Set the explicit color for |command_id| and |index| to |color|. Specify a // Set the explicit color for |command_id| and |index| to |color|. Specify a
@ -401,16 +438,20 @@ typedef struct _cef_menu_model_t {
// set. If no explicit color or default color is set for |color_type| then the // set. If no explicit color or default color is set for |color_type| then the
// system color will be used. Returns true (1) on success. // system color will be used. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_color_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* set_color_at)(struct _cef_menu_model_t* self,
cef_menu_color_type_t color_type, cef_color_t color); int index,
cef_menu_color_type_t color_type,
cef_color_t color);
/// ///
// Returns in |color| the color that was explicitly set for |command_id| and // Returns in |color| the color that was explicitly set for |command_id| and
// |color_type|. If a color was not set then 0 will be returned in |color|. // |color_type|. If a color was not set then 0 will be returned in |color|.
// Returns true (1) on success. // Returns true (1) on success.
/// ///
int (CEF_CALLBACK *get_color)(struct _cef_menu_model_t* self, int command_id, int(CEF_CALLBACK* get_color)(struct _cef_menu_model_t* self,
cef_menu_color_type_t color_type, cef_color_t* color); int command_id,
cef_menu_color_type_t color_type,
cef_color_t* color);
/// ///
// Returns in |color| the color that was explicitly set for |command_id| and // Returns in |color| the color that was explicitly set for |command_id| and
@ -418,8 +459,10 @@ typedef struct _cef_menu_model_t {
// |color|. If a color was not set then 0 will be returned in |color|. Returns // |color|. If a color was not set then 0 will be returned in |color|. Returns
// true (1) on success. // true (1) on success.
/// ///
int (CEF_CALLBACK *get_color_at)(struct _cef_menu_model_t* self, int index, int(CEF_CALLBACK* get_color_at)(struct _cef_menu_model_t* self,
cef_menu_color_type_t color_type, cef_color_t* color); int index,
cef_menu_color_type_t color_type,
cef_color_t* color);
/// ///
// Sets the font list for the specified |command_id|. If |font_list| is NULL // Sets the font list for the specified |command_id|. If |font_list| is NULL
@ -433,8 +476,9 @@ typedef struct _cef_menu_model_t {
// Here are examples of valid font description strings: - "Arial, Helvetica, // Here are examples of valid font description strings: - "Arial, Helvetica,
// Bold Italic 14px" - "Arial, 14px" // Bold Italic 14px" - "Arial, 14px"
/// ///
int (CEF_CALLBACK *set_font_list)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_font_list)(struct _cef_menu_model_t* self,
int command_id, const cef_string_t* font_list); int command_id,
const cef_string_t* font_list);
/// ///
// Sets the font list for the specified |index|. Specify an |index| value of // Sets the font list for the specified |index|. Specify an |index| value of
@ -449,18 +493,17 @@ typedef struct _cef_menu_model_t {
// Here are examples of valid font description strings: - "Arial, Helvetica, // Here are examples of valid font description strings: - "Arial, Helvetica,
// Bold Italic 14px" - "Arial, 14px" // Bold Italic 14px" - "Arial, 14px"
/// ///
int (CEF_CALLBACK *set_font_list_at)(struct _cef_menu_model_t* self, int(CEF_CALLBACK* set_font_list_at)(struct _cef_menu_model_t* self,
int index, const cef_string_t* font_list); int index,
const cef_string_t* font_list);
} cef_menu_model_t; } cef_menu_model_t;
/// ///
// Create a new MenuModel with the specified |delegate|. // Create a new MenuModel with the specified |delegate|.
/// ///
CEF_EXPORT cef_menu_model_t* cef_menu_model_create( CEF_EXPORT cef_menu_model_t* cef_menu_model_create(
struct _cef_menu_model_delegate_t* delegate); struct _cef_menu_model_delegate_t* delegate);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

32
include/capi/cef_menu_model_delegate_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=74f40f20f94ce3a6e7f3c879a3834a7108099ed4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
@ -61,55 +63,59 @@ typedef struct _cef_menu_model_delegate_t {
// Perform the action associated with the specified |command_id| and optional // Perform the action associated with the specified |command_id| and optional
// |event_flags|. // |event_flags|.
/// ///
void (CEF_CALLBACK *execute_command)(struct _cef_menu_model_delegate_t* self, void(CEF_CALLBACK* execute_command)(struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model, int command_id, struct _cef_menu_model_t* menu_model,
int command_id,
cef_event_flags_t event_flags); cef_event_flags_t event_flags);
/// ///
// Called when the user moves the mouse outside the menu and over the owning // Called when the user moves the mouse outside the menu and over the owning
// window. // window.
/// ///
void (CEF_CALLBACK *mouse_outside_menu)( void(CEF_CALLBACK* mouse_outside_menu)(
struct _cef_menu_model_delegate_t* self, struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model, const cef_point_t* screen_point); struct _cef_menu_model_t* menu_model,
const cef_point_t* screen_point);
/// ///
// Called on unhandled open submenu keyboard commands. |is_rtl| will be true // Called on unhandled open submenu keyboard commands. |is_rtl| will be true
// (1) if the menu is displaying a right-to-left language. // (1) if the menu is displaying a right-to-left language.
/// ///
void (CEF_CALLBACK *unhandled_open_submenu)( void(CEF_CALLBACK* unhandled_open_submenu)(
struct _cef_menu_model_delegate_t* self, struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model, int is_rtl); struct _cef_menu_model_t* menu_model,
int is_rtl);
/// ///
// Called on unhandled close submenu keyboard commands. |is_rtl| will be true // Called on unhandled close submenu keyboard commands. |is_rtl| will be true
// (1) if the menu is displaying a right-to-left language. // (1) if the menu is displaying a right-to-left language.
/// ///
void (CEF_CALLBACK *unhandled_close_submenu)( void(CEF_CALLBACK* unhandled_close_submenu)(
struct _cef_menu_model_delegate_t* self, struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model, int is_rtl); struct _cef_menu_model_t* menu_model,
int is_rtl);
/// ///
// The menu is about to show. // The menu is about to show.
/// ///
void (CEF_CALLBACK *menu_will_show)(struct _cef_menu_model_delegate_t* self, void(CEF_CALLBACK* menu_will_show)(struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model); struct _cef_menu_model_t* menu_model);
/// ///
// The menu has closed. // The menu has closed.
/// ///
void (CEF_CALLBACK *menu_closed)(struct _cef_menu_model_delegate_t* self, void(CEF_CALLBACK* menu_closed)(struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model); struct _cef_menu_model_t* menu_model);
/// ///
// Optionally modify a menu item label. Return true (1) if |label| was // Optionally modify a menu item label. Return true (1) if |label| was
// modified. // modified.
/// ///
int (CEF_CALLBACK *format_label)(struct _cef_menu_model_delegate_t* self, int(CEF_CALLBACK* format_label)(struct _cef_menu_model_delegate_t* self,
struct _cef_menu_model_t* menu_model, cef_string_t* label); struct _cef_menu_model_t* menu_model,
cef_string_t* label);
} cef_menu_model_delegate_t; } cef_menu_model_delegate_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

25
include/capi/cef_navigation_entry_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=a862d0004de2a1bdf4c214fe87278badd90562a7$
//
#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to represent an entry in navigation history. // Structure used to represent an entry in navigation history.
/// ///
@ -59,55 +60,55 @@ typedef struct _cef_navigation_entry_t {
// Returns true (1) if this object is valid. Do not call any other functions // Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0). // if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_navigation_entry_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_navigation_entry_t* self);
/// ///
// Returns the actual URL of the page. For some pages this may be data: URL or // Returns the actual URL of the page. For some pages this may be data: URL or
// similar. Use get_display_url() to return a display-friendly version. // similar. Use get_display_url() to return a display-friendly version.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_url)( cef_string_userfree_t(CEF_CALLBACK* get_url)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
// Returns a display-friendly version of the URL. // Returns a display-friendly version of the URL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_display_url)( cef_string_userfree_t(CEF_CALLBACK* get_display_url)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
// Returns the original URL that was entered by the user before any redirects. // Returns the original URL that was entered by the user before any redirects.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_original_url)( cef_string_userfree_t(CEF_CALLBACK* get_original_url)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
// Returns the title set by the page. This value may be NULL. // Returns the title set by the page. This value may be NULL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_title)( cef_string_userfree_t(CEF_CALLBACK* get_title)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
// Returns the transition type which indicates what the user did to move to // Returns the transition type which indicates what the user did to move to
// this page from the previous page. // this page from the previous page.
/// ///
cef_transition_type_t (CEF_CALLBACK *get_transition_type)( cef_transition_type_t(CEF_CALLBACK* get_transition_type)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
// Returns true (1) if this navigation includes post data. // Returns true (1) if this navigation includes post data.
/// ///
int (CEF_CALLBACK *has_post_data)(struct _cef_navigation_entry_t* self); int(CEF_CALLBACK* has_post_data)(struct _cef_navigation_entry_t* self);
/// ///
// Returns the time for the last known successful navigation completion. A // Returns the time for the last known successful navigation completion. A
// navigation may be completed more than once if the page is reloaded. May be // navigation may be completed more than once if the page is reloaded. May be
// 0 if the navigation has not yet completed. // 0 if the navigation has not yet completed.
/// ///
cef_time_t (CEF_CALLBACK *get_completion_time)( cef_time_t(CEF_CALLBACK* get_completion_time)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
/// ///
@ -115,17 +116,15 @@ typedef struct _cef_navigation_entry_t {
// response. May be 0 if the response has not yet been received or if the // response. May be 0 if the response has not yet been received or if the
// navigation has not yet completed. // navigation has not yet completed.
/// ///
int (CEF_CALLBACK *get_http_status_code)( int(CEF_CALLBACK* get_http_status_code)(struct _cef_navigation_entry_t* self);
struct _cef_navigation_entry_t* self);
/// ///
// Returns the SSL information for this navigation entry. // Returns the SSL information for this navigation entry.
/// ///
struct _cef_sslstatus_t* (CEF_CALLBACK *get_sslstatus)( struct _cef_sslstatus_t*(CEF_CALLBACK* get_sslstatus)(
struct _cef_navigation_entry_t* self); struct _cef_navigation_entry_t* self);
} cef_navigation_entry_t; } cef_navigation_entry_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

15
include/capi/cef_origin_whitelist_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=2e5afff3277384ea9f3f74ef509c018f6d307dc4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Add an entry to the cross-origin access whitelist. // Add an entry to the cross-origin access whitelist.
// //
@ -82,16 +83,20 @@ extern "C" {
// |source_origin| is invalid or the whitelist cannot be accessed. // |source_origin| is invalid or the whitelist cannot be accessed.
/// ///
CEF_EXPORT int cef_add_cross_origin_whitelist_entry( CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
const cef_string_t* source_origin, const cef_string_t* target_protocol, const cef_string_t* source_origin,
const cef_string_t* target_domain, int allow_target_subdomains); const cef_string_t* target_protocol,
const cef_string_t* target_domain,
int allow_target_subdomains);
/// ///
// Remove an entry from the cross-origin access whitelist. Returns false (0) if // Remove an entry from the cross-origin access whitelist. Returns false (0) if
// |source_origin| is invalid or the whitelist cannot be accessed. // |source_origin| is invalid or the whitelist cannot be accessed.
/// ///
CEF_EXPORT int cef_remove_cross_origin_whitelist_entry( CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
const cef_string_t* source_origin, const cef_string_t* target_protocol, const cef_string_t* source_origin,
const cef_string_t* target_domain, int allow_target_subdomains); const cef_string_t* target_protocol,
const cef_string_t* target_domain,
int allow_target_subdomains);
/// ///
// Remove all entries from the cross-origin access whitelist. Returns false (0) // Remove all entries from the cross-origin access whitelist. Returns false (0)

30
include/capi/cef_parser_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=d2f01fbfc3ae72a86c03399606088054b3a9337f$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Parse the specified |url| into its component parts. Returns false (0) if the // Parse the specified |url| into its component parts. Returns false (0) if the
// URL is NULL or invalid. // URL is NULL or invalid.
@ -71,16 +72,16 @@ CEF_EXPORT int cef_create_url(const struct _cef_urlparts_t* parts,
// for URLs which will be parsed or sent to other applications. // for URLs which will be parsed or sent to other applications.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_format_url_for_security_display( CEF_EXPORT cef_string_userfree_t
const cef_string_t* origin_url); cef_format_url_for_security_display(const cef_string_t* origin_url);
/// ///
// Returns the mime type for the specified file extension or an NULL string if // Returns the mime type for the specified file extension or an NULL string if
// unknown. // unknown.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_get_mime_type( CEF_EXPORT cef_string_userfree_t
const cef_string_t* extension); cef_get_mime_type(const cef_string_t* extension);
/// ///
// Get the extensions associated with the given mime type. This should be passed // Get the extensions associated with the given mime type. This should be passed
@ -126,14 +127,17 @@ CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text,
// supports further customization the decoding process. // supports further customization the decoding process.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text, CEF_EXPORT cef_string_userfree_t
int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule); cef_uridecode(const cef_string_t* text,
int convert_to_utf8,
cef_uri_unescape_rule_t unescape_rule);
/// ///
// Parses the specified |json_string| and returns a dictionary or list // Parses the specified |json_string| and returns a dictionary or list
// representation. If JSON parsing fails this function returns NULL. // representation. If JSON parsing fails this function returns NULL.
/// ///
CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string, CEF_EXPORT struct _cef_value_t* cef_parse_json(
const cef_string_t* json_string,
cef_json_parser_options_t options); cef_json_parser_options_t options);
/// ///
@ -143,8 +147,10 @@ CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
// formatted error message respectively. // formatted error message respectively.
/// ///
CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error( CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
const cef_string_t* json_string, cef_json_parser_options_t options, const cef_string_t* json_string,
cef_json_parser_error_t* error_code_out, cef_string_t* error_msg_out); cef_json_parser_options_t options,
cef_json_parser_error_t* error_code_out,
cef_string_t* error_msg_out);
/// ///
// Generates a JSON string from the specified root |node| which should be a // Generates a JSON string from the specified root |node| which should be a
@ -152,8 +158,8 @@ CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
// requires exclusive access to |node| including any underlying data. // requires exclusive access to |node| including any underlying data.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_write_json(struct _cef_value_t* node, CEF_EXPORT cef_string_userfree_t
cef_json_writer_options_t options); cef_write_json(struct _cef_value_t* node, cef_json_writer_options_t options);
#ifdef __cplusplus #ifdef __cplusplus
} }

3
include/capi/cef_path_util_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=fbb817705137a12b4718950ff696396c30057007$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Retrieve the path associated with the specified |key|. Returns true (1) on // Retrieve the path associated with the specified |key|. Returns true (1) on
// success. Can be called on any thread in the browser process. // success. Can be called on any thread in the browser process.

37
include/capi/cef_print_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=e8f6bdc822cf4f5c32b22ba8b5cacb25823d8971$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure for asynchronous continuation of print dialog requests. // Callback structure for asynchronous continuation of print dialog requests.
/// ///
@ -59,16 +60,15 @@ typedef struct _cef_print_dialog_callback_t {
/// ///
// Continue printing with the specified |settings|. // Continue printing with the specified |settings|.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_print_dialog_callback_t* self, void(CEF_CALLBACK* cont)(struct _cef_print_dialog_callback_t* self,
struct _cef_print_settings_t* settings); struct _cef_print_settings_t* settings);
/// ///
// Cancel the printing. // Cancel the printing.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_print_dialog_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_print_dialog_callback_t* self);
} cef_print_dialog_callback_t; } cef_print_dialog_callback_t;
/// ///
// Callback structure for asynchronous continuation of print job requests. // Callback structure for asynchronous continuation of print job requests.
/// ///
@ -81,10 +81,9 @@ typedef struct _cef_print_job_callback_t {
/// ///
// Indicate completion of the print job. // Indicate completion of the print job.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_print_job_callback_t* self); void(CEF_CALLBACK* cont)(struct _cef_print_job_callback_t* self);
} cef_print_job_callback_t; } cef_print_job_callback_t;
/// ///
// Implement this structure to handle printing on Linux. The functions of this // Implement this structure to handle printing on Linux. The functions of this
// structure will be called on the browser process UI thread. // structure will be called on the browser process UI thread.
@ -101,7 +100,7 @@ typedef struct _cef_print_handler_t {
// how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript // how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript
// window.print() or PDF extension print button). // window.print() or PDF extension print button).
/// ///
void (CEF_CALLBACK *on_print_start)(struct _cef_print_handler_t* self, void(CEF_CALLBACK* on_print_start)(struct _cef_print_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
@ -109,40 +108,44 @@ typedef struct _cef_print_handler_t {
// then populate |settings| with the default print settings. Do not keep a // then populate |settings| with the default print settings. Do not keep a
// reference to |settings| outside of this callback. // reference to |settings| outside of this callback.
/// ///
void (CEF_CALLBACK *on_print_settings)(struct _cef_print_handler_t* self, void(CEF_CALLBACK* on_print_settings)(struct _cef_print_handler_t* self,
struct _cef_print_settings_t* settings, int get_defaults); struct _cef_print_settings_t* settings,
int get_defaults);
/// ///
// Show the print dialog. Execute |callback| once the dialog is dismissed. // Show the print dialog. Execute |callback| once the dialog is dismissed.
// Return true (1) if the dialog will be displayed or false (0) to cancel the // Return true (1) if the dialog will be displayed or false (0) to cancel the
// printing immediately. // printing immediately.
/// ///
int (CEF_CALLBACK *on_print_dialog)(struct _cef_print_handler_t* self, int(CEF_CALLBACK* on_print_dialog)(
int has_selection, struct _cef_print_dialog_callback_t* callback); struct _cef_print_handler_t* self,
int has_selection,
struct _cef_print_dialog_callback_t* callback);
/// ///
// Send the print job to the printer. Execute |callback| once the job is // Send the print job to the printer. Execute |callback| once the job is
// completed. Return true (1) if the job will proceed or false (0) to cancel // completed. Return true (1) if the job will proceed or false (0) to cancel
// the job immediately. // the job immediately.
/// ///
int (CEF_CALLBACK *on_print_job)(struct _cef_print_handler_t* self, int(CEF_CALLBACK* on_print_job)(struct _cef_print_handler_t* self,
const cef_string_t* document_name, const cef_string_t* pdf_file_path, const cef_string_t* document_name,
const cef_string_t* pdf_file_path,
struct _cef_print_job_callback_t* callback); struct _cef_print_job_callback_t* callback);
/// ///
// Reset client state related to printing. // Reset client state related to printing.
/// ///
void (CEF_CALLBACK *on_print_reset)(struct _cef_print_handler_t* self); void(CEF_CALLBACK* on_print_reset)(struct _cef_print_handler_t* self);
/// ///
// Return the PDF paper size in device units. Used in combination with // Return the PDF paper size in device units. Used in combination with
// cef_browser_host_t::print_to_pdf(). // cef_browser_host_t::print_to_pdf().
/// ///
cef_size_t (CEF_CALLBACK *get_pdf_paper_size)( cef_size_t(CEF_CALLBACK* get_pdf_paper_size)(
struct _cef_print_handler_t* self, int device_units_per_inch); struct _cef_print_handler_t* self,
int device_units_per_inch);
} cef_print_handler_t; } cef_print_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

57
include/capi/cef_print_settings_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=5b26ebd2d8e1e65a25fa0c08317b8994887c0498$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure representing print settings. // Structure representing print settings.
/// ///
@ -58,37 +59,37 @@ typedef struct _cef_print_settings_t {
// Returns true (1) if this object is valid. Do not call any other functions // Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0). // if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_print_settings_t* self);
/// ///
// Returns true (1) if the values of this object are read-only. Some APIs may // Returns true (1) if the values of this object are read-only. Some APIs may
// expose read-only objects. // expose read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_print_settings_t* self);
/// ///
// Returns a writable copy of this object. // Returns a writable copy of this object.
/// ///
struct _cef_print_settings_t* (CEF_CALLBACK *copy)( struct _cef_print_settings_t*(CEF_CALLBACK* copy)(
struct _cef_print_settings_t* self); struct _cef_print_settings_t* self);
/// ///
// Set the page orientation. // Set the page orientation.
/// ///
void (CEF_CALLBACK *set_orientation)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_orientation)(struct _cef_print_settings_t* self,
int landscape); int landscape);
/// ///
// Returns true (1) if the orientation is landscape. // Returns true (1) if the orientation is landscape.
/// ///
int (CEF_CALLBACK *is_landscape)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* is_landscape)(struct _cef_print_settings_t* self);
/// ///
// Set the printer printable area in device units. Some platforms already // Set the printer printable area in device units. Some platforms already
// provide flipped area. Set |landscape_needs_flip| to false (0) on those // provide flipped area. Set |landscape_needs_flip| to false (0) on those
// platforms to avoid double flipping. // platforms to avoid double flipping.
/// ///
void (CEF_CALLBACK *set_printer_printable_area)( void(CEF_CALLBACK* set_printer_printable_area)(
struct _cef_print_settings_t* self, struct _cef_print_settings_t* self,
const cef_size_t* physical_size_device_units, const cef_size_t* physical_size_device_units,
const cef_rect_t* printable_area_device_units, const cef_rect_t* printable_area_device_units,
@ -97,109 +98,109 @@ typedef struct _cef_print_settings_t {
/// ///
// Set the device name. // Set the device name.
/// ///
void (CEF_CALLBACK *set_device_name)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_device_name)(struct _cef_print_settings_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
// Get the device name. // Get the device name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_device_name)( cef_string_userfree_t(CEF_CALLBACK* get_device_name)(
struct _cef_print_settings_t* self); struct _cef_print_settings_t* self);
/// ///
// Set the DPI (dots per inch). // Set the DPI (dots per inch).
/// ///
void (CEF_CALLBACK *set_dpi)(struct _cef_print_settings_t* self, int dpi); void(CEF_CALLBACK* set_dpi)(struct _cef_print_settings_t* self, int dpi);
/// ///
// Get the DPI (dots per inch). // Get the DPI (dots per inch).
/// ///
int (CEF_CALLBACK *get_dpi)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* get_dpi)(struct _cef_print_settings_t* self);
/// ///
// Set the page ranges. // Set the page ranges.
/// ///
void (CEF_CALLBACK *set_page_ranges)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_page_ranges)(struct _cef_print_settings_t* self,
size_t rangesCount, cef_range_t const* ranges); size_t rangesCount,
cef_range_t const* ranges);
/// ///
// Returns the number of page ranges that currently exist. // Returns the number of page ranges that currently exist.
/// ///
size_t (CEF_CALLBACK *get_page_ranges_count)( size_t(CEF_CALLBACK* get_page_ranges_count)(
struct _cef_print_settings_t* self); struct _cef_print_settings_t* self);
/// ///
// Retrieve the page ranges. // Retrieve the page ranges.
/// ///
void (CEF_CALLBACK *get_page_ranges)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* get_page_ranges)(struct _cef_print_settings_t* self,
size_t* rangesCount, cef_range_t* ranges); size_t* rangesCount,
cef_range_t* ranges);
/// ///
// Set whether only the selection will be printed. // Set whether only the selection will be printed.
/// ///
void (CEF_CALLBACK *set_selection_only)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_selection_only)(struct _cef_print_settings_t* self,
int selection_only); int selection_only);
/// ///
// Returns true (1) if only the selection will be printed. // Returns true (1) if only the selection will be printed.
/// ///
int (CEF_CALLBACK *is_selection_only)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* is_selection_only)(struct _cef_print_settings_t* self);
/// ///
// Set whether pages will be collated. // Set whether pages will be collated.
/// ///
void (CEF_CALLBACK *set_collate)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_collate)(struct _cef_print_settings_t* self,
int collate); int collate);
/// ///
// Returns true (1) if pages will be collated. // Returns true (1) if pages will be collated.
/// ///
int (CEF_CALLBACK *will_collate)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* will_collate)(struct _cef_print_settings_t* self);
/// ///
// Set the color model. // Set the color model.
/// ///
void (CEF_CALLBACK *set_color_model)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_color_model)(struct _cef_print_settings_t* self,
cef_color_model_t model); cef_color_model_t model);
/// ///
// Get the color model. // Get the color model.
/// ///
cef_color_model_t (CEF_CALLBACK *get_color_model)( cef_color_model_t(CEF_CALLBACK* get_color_model)(
struct _cef_print_settings_t* self); struct _cef_print_settings_t* self);
/// ///
// Set the number of copies. // Set the number of copies.
/// ///
void (CEF_CALLBACK *set_copies)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_copies)(struct _cef_print_settings_t* self,
int copies); int copies);
/// ///
// Get the number of copies. // Get the number of copies.
/// ///
int (CEF_CALLBACK *get_copies)(struct _cef_print_settings_t* self); int(CEF_CALLBACK* get_copies)(struct _cef_print_settings_t* self);
/// ///
// Set the duplex mode. // Set the duplex mode.
/// ///
void (CEF_CALLBACK *set_duplex_mode)(struct _cef_print_settings_t* self, void(CEF_CALLBACK* set_duplex_mode)(struct _cef_print_settings_t* self,
cef_duplex_mode_t mode); cef_duplex_mode_t mode);
/// ///
// Get the duplex mode. // Get the duplex mode.
/// ///
cef_duplex_mode_t (CEF_CALLBACK *get_duplex_mode)( cef_duplex_mode_t(CEF_CALLBACK* get_duplex_mode)(
struct _cef_print_settings_t* self); struct _cef_print_settings_t* self);
} cef_print_settings_t; } cef_print_settings_t;
/// ///
// Create a new cef_print_settings_t object. // Create a new cef_print_settings_t object.
/// ///
CEF_EXPORT cef_print_settings_t* cef_print_settings_create(); CEF_EXPORT cef_print_settings_t* cef_print_settings_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

15
include/capi/cef_process_message_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=c2ee22474637f9aed7673670fb10c960ae621535$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure representing a message. Can be used on any process and thread. // Structure representing a message. Can be used on any process and thread.
/// ///
@ -59,42 +60,40 @@ typedef struct _cef_process_message_t {
// Returns true (1) if this object is valid. Do not call any other functions // Returns true (1) if this object is valid. Do not call any other functions
// if this function returns false (0). // if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_process_message_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_process_message_t* self);
/// ///
// Returns true (1) if the values of this object are read-only. Some APIs may // Returns true (1) if the values of this object are read-only. Some APIs may
// expose read-only objects. // expose read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_process_message_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_process_message_t* self);
/// ///
// Returns a writable copy of this object. // Returns a writable copy of this object.
/// ///
struct _cef_process_message_t* (CEF_CALLBACK *copy)( struct _cef_process_message_t*(CEF_CALLBACK* copy)(
struct _cef_process_message_t* self); struct _cef_process_message_t* self);
/// ///
// Returns the message name. // Returns the message name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_name)( cef_string_userfree_t(CEF_CALLBACK* get_name)(
struct _cef_process_message_t* self); struct _cef_process_message_t* self);
/// ///
// Returns the list of arguments. // Returns the list of arguments.
/// ///
struct _cef_list_value_t* (CEF_CALLBACK *get_argument_list)( struct _cef_list_value_t*(CEF_CALLBACK* get_argument_list)(
struct _cef_process_message_t* self); struct _cef_process_message_t* self);
} cef_process_message_t; } cef_process_message_t;
/// ///
// Create a new cef_process_message_t object with the specified name. // Create a new cef_process_message_t object with the specified name.
/// ///
CEF_EXPORT cef_process_message_t* cef_process_message_create( CEF_EXPORT cef_process_message_t* cef_process_message_create(
const cef_string_t* name); const cef_string_t* name);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

3
include/capi/cef_process_util_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=aad07da2d500b8d31e02a75331bdb68f16d4c662$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Launches the process specified via |command_line|. Returns true (1) upon // Launches the process specified via |command_line|. Returns true (1) upon
// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread. // success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.

87
include/capi/cef_render_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=5d20fc88dea8dad8691f05bfb7e8c1ce5cf2bbc1$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
@ -47,7 +49,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to handle events when window rendering is disabled. // Implement this structure to handle events when window rendering is disabled.
// The functions of this structure will be called on the UI thread. // The functions of this structure will be called on the UI thread.
@ -62,30 +63,34 @@ typedef struct _cef_render_handler_t {
// Return the handler for accessibility notifications. If no handler is // Return the handler for accessibility notifications. If no handler is
// provided the default implementation will be used. // provided the default implementation will be used.
/// ///
struct _cef_accessibility_handler_t* ( struct _cef_accessibility_handler_t*(CEF_CALLBACK* get_accessibility_handler)(
CEF_CALLBACK *get_accessibility_handler)(
struct _cef_render_handler_t* self); struct _cef_render_handler_t* self);
/// ///
// Called to retrieve the root window rectangle in screen coordinates. Return // Called to retrieve the root window rectangle in screen coordinates. Return
// true (1) if the rectangle was provided. // true (1) if the rectangle was provided.
/// ///
int (CEF_CALLBACK *get_root_screen_rect)(struct _cef_render_handler_t* self, int(CEF_CALLBACK* get_root_screen_rect)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_rect_t* rect); struct _cef_browser_t* browser,
cef_rect_t* rect);
/// ///
// Called to retrieve the view rectangle which is relative to screen // Called to retrieve the view rectangle which is relative to screen
// coordinates. Return true (1) if the rectangle was provided. // coordinates. Return true (1) if the rectangle was provided.
/// ///
int (CEF_CALLBACK *get_view_rect)(struct _cef_render_handler_t* self, int(CEF_CALLBACK* get_view_rect)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_rect_t* rect); struct _cef_browser_t* browser,
cef_rect_t* rect);
/// ///
// Called to retrieve the translation from view coordinates to actual screen // Called to retrieve the translation from view coordinates to actual screen
// coordinates. Return true (1) if the screen coordinates were provided. // coordinates. Return true (1) if the screen coordinates were provided.
/// ///
int (CEF_CALLBACK *get_screen_point)(struct _cef_render_handler_t* self, int(CEF_CALLBACK* get_screen_point)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, int viewX, int viewY, int* screenX, struct _cef_browser_t* browser,
int viewX,
int viewY,
int* screenX,
int* screenY); int* screenY);
/// ///
@ -97,22 +102,25 @@ typedef struct _cef_render_handler_t {
// will be used. If the rectangle is still NULL or invalid popups may not be // will be used. If the rectangle is still NULL or invalid popups may not be
// drawn correctly. // drawn correctly.
/// ///
int (CEF_CALLBACK *get_screen_info)(struct _cef_render_handler_t* self, int(CEF_CALLBACK* get_screen_info)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, struct _cef_screen_info_t* screen_info); struct _cef_browser_t* browser,
struct _cef_screen_info_t* screen_info);
/// ///
// Called when the browser wants to show or hide the popup widget. The popup // Called when the browser wants to show or hide the popup widget. The popup
// should be shown if |show| is true (1) and hidden if |show| is false (0). // should be shown if |show| is true (1) and hidden if |show| is false (0).
/// ///
void (CEF_CALLBACK *on_popup_show)(struct _cef_render_handler_t* self, void(CEF_CALLBACK* on_popup_show)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, int show); struct _cef_browser_t* browser,
int show);
/// ///
// Called when the browser wants to move or resize the popup widget. |rect| // Called when the browser wants to move or resize the popup widget. |rect|
// contains the new location and size in view coordinates. // contains the new location and size in view coordinates.
/// ///
void (CEF_CALLBACK *on_popup_size)(struct _cef_render_handler_t* self, void(CEF_CALLBACK* on_popup_size)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, const cef_rect_t* rect); struct _cef_browser_t* browser,
const cef_rect_t* rect);
/// ///
// Called when an element should be painted. Pixel values passed to this // Called when an element should be painted. Pixel values passed to this
@ -124,17 +132,23 @@ typedef struct _cef_render_handler_t {
// be |width|*|height|*4 bytes in size and represents a BGRA image with an // be |width|*|height|*4 bytes in size and represents a BGRA image with an
// upper-left origin. // upper-left origin.
/// ///
void (CEF_CALLBACK *on_paint)(struct _cef_render_handler_t* self, void(CEF_CALLBACK* on_paint)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_paint_element_type_t type, struct _cef_browser_t* browser,
size_t dirtyRectsCount, cef_rect_t const* dirtyRects, const void* buffer, cef_paint_element_type_t type,
int width, int height); size_t dirtyRectsCount,
cef_rect_t const* dirtyRects,
const void* buffer,
int width,
int height);
/// ///
// Called when the browser's cursor has changed. If |type| is CT_CUSTOM then // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
// |custom_cursor_info| will be populated with the custom cursor information. // |custom_cursor_info| will be populated with the custom cursor information.
/// ///
void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self, void(CEF_CALLBACK* on_cursor_change)(
struct _cef_browser_t* browser, cef_cursor_handle_t cursor, struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
cef_cursor_handle_t cursor,
cef_cursor_type_t type, cef_cursor_type_t type,
const struct _cef_cursor_info_t* custom_cursor_info); const struct _cef_cursor_info_t* custom_cursor_info);
@ -152,37 +166,44 @@ typedef struct _cef_render_handler_t {
// synchronously or asynchronously to inform the web view that the drag // synchronously or asynchronously to inform the web view that the drag
// operation has ended. // operation has ended.
/// ///
int (CEF_CALLBACK *start_dragging)(struct _cef_render_handler_t* self, int(CEF_CALLBACK* start_dragging)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, struct _cef_drag_data_t* drag_data, struct _cef_browser_t* browser,
cef_drag_operations_mask_t allowed_ops, int x, int y); struct _cef_drag_data_t* drag_data,
cef_drag_operations_mask_t allowed_ops,
int x,
int y);
/// ///
// Called when the web view wants to update the mouse cursor during a drag & // Called when the web view wants to update the mouse cursor during a drag &
// drop operation. |operation| describes the allowed operation (none, move, // drop operation. |operation| describes the allowed operation (none, move,
// copy, link). // copy, link).
/// ///
void (CEF_CALLBACK *update_drag_cursor)(struct _cef_render_handler_t* self, void(CEF_CALLBACK* update_drag_cursor)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_drag_operations_mask_t operation); struct _cef_browser_t* browser,
cef_drag_operations_mask_t operation);
/// ///
// Called when the scroll offset has changed. // Called when the scroll offset has changed.
/// ///
void (CEF_CALLBACK *on_scroll_offset_changed)( void(CEF_CALLBACK* on_scroll_offset_changed)(
struct _cef_render_handler_t* self, struct _cef_browser_t* browser, struct _cef_render_handler_t* self,
double x, double y); struct _cef_browser_t* browser,
double x,
double y);
/// ///
// Called when the IME composition range has changed. |selected_range| is the // Called when the IME composition range has changed. |selected_range| is the
// range of characters that have been selected. |character_bounds| is the // range of characters that have been selected. |character_bounds| is the
// bounds of each character in view coordinates. // bounds of each character in view coordinates.
/// ///
void (CEF_CALLBACK *on_ime_composition_range_changed)( void(CEF_CALLBACK* on_ime_composition_range_changed)(
struct _cef_render_handler_t* self, struct _cef_browser_t* browser, struct _cef_render_handler_t* self,
const cef_range_t* selected_range, size_t character_boundsCount, struct _cef_browser_t* browser,
const cef_range_t* selected_range,
size_t character_boundsCount,
cef_rect_t const* character_bounds); cef_rect_t const* character_bounds);
} cef_render_handler_t; } cef_render_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

50
include/capi/cef_render_process_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=04ddf8c8cc5e09610a6cd6dbee96194eb6567b41$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
@ -51,7 +53,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to implement render process callbacks. The functions of this // Structure used to implement render process callbacks. The functions of this
// structure will be called on the render process main thread (TID_RENDERER) // structure will be called on the render process main thread (TID_RENDERER)
@ -69,14 +70,14 @@ typedef struct _cef_render_process_handler_t {
// cef_browser_process_handler_t::on_render_process_thread_created(). Do not // cef_browser_process_handler_t::on_render_process_thread_created(). Do not
// keep a reference to |extra_info| outside of this function. // keep a reference to |extra_info| outside of this function.
/// ///
void (CEF_CALLBACK *on_render_thread_created)( void(CEF_CALLBACK* on_render_thread_created)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_list_value_t* extra_info); struct _cef_list_value_t* extra_info);
/// ///
// Called after WebKit has been initialized. // Called after WebKit has been initialized.
/// ///
void (CEF_CALLBACK *on_web_kit_initialized)( void(CEF_CALLBACK* on_web_kit_initialized)(
struct _cef_render_process_handler_t* self); struct _cef_render_process_handler_t* self);
/// ///
@ -84,21 +85,21 @@ typedef struct _cef_render_process_handler_t {
// browser will be created before the old browser with the same identifier is // browser will be created before the old browser with the same identifier is
// destroyed. // destroyed.
/// ///
void (CEF_CALLBACK *on_browser_created)( void(CEF_CALLBACK* on_browser_created)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
// Called before a browser is destroyed. // Called before a browser is destroyed.
/// ///
void (CEF_CALLBACK *on_browser_destroyed)( void(CEF_CALLBACK* on_browser_destroyed)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
// Return the handler for browser load status events. // Return the handler for browser load status events.
/// ///
struct _cef_load_handler_t* (CEF_CALLBACK *get_load_handler)( struct _cef_load_handler_t*(CEF_CALLBACK* get_load_handler)(
struct _cef_render_process_handler_t* self); struct _cef_render_process_handler_t* self);
/// ///
@ -106,10 +107,12 @@ typedef struct _cef_render_process_handler_t {
// or false (0) to allow the navigation to proceed. The |request| object // or false (0) to allow the navigation to proceed. The |request| object
// cannot be modified in this callback. // cannot be modified in this callback.
/// ///
int (CEF_CALLBACK *on_before_navigation)( int(CEF_CALLBACK* on_before_navigation)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_request_t* request, cef_navigation_type_t navigation_type, struct _cef_frame_t* frame,
struct _cef_request_t* request,
cef_navigation_type_t navigation_type,
int is_redirect); int is_redirect);
/// ///
@ -120,18 +123,20 @@ typedef struct _cef_render_process_handler_t {
// on the associated thread can be retrieved via the // on the associated thread can be retrieved via the
// cef_v8context_t::get_task_runner() function. // cef_v8context_t::get_task_runner() function.
/// ///
void (CEF_CALLBACK *on_context_created)( void(CEF_CALLBACK* on_context_created)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_v8context_t* context); struct _cef_v8context_t* context);
/// ///
// Called immediately before the V8 context for a frame is released. No // Called immediately before the V8 context for a frame is released. No
// references to the context should be kept after this function is called. // references to the context should be kept after this function is called.
/// ///
void (CEF_CALLBACK *on_context_released)( void(CEF_CALLBACK* on_context_released)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_v8context_t* context); struct _cef_v8context_t* context);
/// ///
@ -139,10 +144,12 @@ typedef struct _cef_render_process_handler_t {
// callback is disabled by default. To enable set // callback is disabled by default. To enable set
// CefSettings.uncaught_exception_stack_size > 0. // CefSettings.uncaught_exception_stack_size > 0.
/// ///
void (CEF_CALLBACK *on_uncaught_exception)( void(CEF_CALLBACK* on_uncaught_exception)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_v8context_t* context, struct _cef_v8exception_t* exception, struct _cef_frame_t* frame,
struct _cef_v8context_t* context,
struct _cef_v8exception_t* exception,
struct _cef_v8stack_trace_t* stackTrace); struct _cef_v8stack_trace_t* stackTrace);
/// ///
@ -153,9 +160,10 @@ typedef struct _cef_render_process_handler_t {
// keep references to or attempt to access any DOM objects outside the scope // keep references to or attempt to access any DOM objects outside the scope
// of this function. // of this function.
/// ///
void (CEF_CALLBACK *on_focused_node_changed)( void(CEF_CALLBACK* on_focused_node_changed)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_domnode_t* node); struct _cef_domnode_t* node);
/// ///
@ -163,13 +171,13 @@ typedef struct _cef_render_process_handler_t {
// (1) if the message was handled or false (0) otherwise. Do not keep a // (1) if the message was handled or false (0) otherwise. Do not keep a
// reference to or attempt to access the message outside of this callback. // reference to or attempt to access the message outside of this callback.
/// ///
int (CEF_CALLBACK *on_process_message_received)( int(CEF_CALLBACK* on_process_message_received)(
struct _cef_render_process_handler_t* self, struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, cef_process_id_t source_process, struct _cef_browser_t* browser,
cef_process_id_t source_process,
struct _cef_process_message_t* message); struct _cef_process_message_t* message);
} cef_render_process_handler_t; } cef_render_process_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

94
include/capi/cef_request_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=e4d28f171862beea61f00e46d7acb8ee4154b077$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
@ -60,18 +62,18 @@ typedef struct _cef_request_t {
/// ///
// Returns true (1) if this object is read-only. // Returns true (1) if this object is read-only.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_request_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_request_t* self);
/// ///
// Get the fully qualified URL. // Get the fully qualified URL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_url)(struct _cef_request_t* self); cef_string_userfree_t(CEF_CALLBACK* get_url)(struct _cef_request_t* self);
/// ///
// Set the fully qualified URL. // Set the fully qualified URL.
/// ///
void (CEF_CALLBACK *set_url)(struct _cef_request_t* self, void(CEF_CALLBACK* set_url)(struct _cef_request_t* self,
const cef_string_t* url); const cef_string_t* url);
/// ///
@ -79,12 +81,12 @@ typedef struct _cef_request_t {
// is provided and GET otherwise. // is provided and GET otherwise.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_method)(struct _cef_request_t* self); cef_string_userfree_t(CEF_CALLBACK* get_method)(struct _cef_request_t* self);
/// ///
// Set the request function type. // Set the request function type.
/// ///
void (CEF_CALLBACK *set_method)(struct _cef_request_t* self, void(CEF_CALLBACK* set_method)(struct _cef_request_t* self,
const cef_string_t* method); const cef_string_t* method);
/// ///
@ -92,86 +94,89 @@ typedef struct _cef_request_t {
// qualified with an HTTP or HTTPS scheme component. Any username, password or // qualified with an HTTP or HTTPS scheme component. Any username, password or
// ref component will be removed. // ref component will be removed.
/// ///
void (CEF_CALLBACK *set_referrer)(struct _cef_request_t* self, void(CEF_CALLBACK* set_referrer)(struct _cef_request_t* self,
const cef_string_t* referrer_url, cef_referrer_policy_t policy); const cef_string_t* referrer_url,
cef_referrer_policy_t policy);
/// ///
// Get the referrer URL. // Get the referrer URL.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_referrer_url)( cef_string_userfree_t(CEF_CALLBACK* get_referrer_url)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
// Get the referrer policy. // Get the referrer policy.
/// ///
cef_referrer_policy_t (CEF_CALLBACK *get_referrer_policy)( cef_referrer_policy_t(CEF_CALLBACK* get_referrer_policy)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
// Get the post data. // Get the post data.
/// ///
struct _cef_post_data_t* (CEF_CALLBACK *get_post_data)( struct _cef_post_data_t*(CEF_CALLBACK* get_post_data)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
// Set the post data. // Set the post data.
/// ///
void (CEF_CALLBACK *set_post_data)(struct _cef_request_t* self, void(CEF_CALLBACK* set_post_data)(struct _cef_request_t* self,
struct _cef_post_data_t* postData); struct _cef_post_data_t* postData);
/// ///
// Get the header values. Will not include the Referer value if any. // Get the header values. Will not include the Referer value if any.
/// ///
void (CEF_CALLBACK *get_header_map)(struct _cef_request_t* self, void(CEF_CALLBACK* get_header_map)(struct _cef_request_t* self,
cef_string_multimap_t headerMap); cef_string_multimap_t headerMap);
/// ///
// Set the header values. If a Referer value exists in the header map it will // Set the header values. If a Referer value exists in the header map it will
// be removed and ignored. // be removed and ignored.
/// ///
void (CEF_CALLBACK *set_header_map)(struct _cef_request_t* self, void(CEF_CALLBACK* set_header_map)(struct _cef_request_t* self,
cef_string_multimap_t headerMap); cef_string_multimap_t headerMap);
/// ///
// Set all values at one time. // Set all values at one time.
/// ///
void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url, void(CEF_CALLBACK* set)(struct _cef_request_t* self,
const cef_string_t* method, struct _cef_post_data_t* postData, const cef_string_t* url,
const cef_string_t* method,
struct _cef_post_data_t* postData,
cef_string_multimap_t headerMap); cef_string_multimap_t headerMap);
/// ///
// Get the flags used in combination with cef_urlrequest_t. See // Get the flags used in combination with cef_urlrequest_t. See
// cef_urlrequest_flags_t for supported values. // cef_urlrequest_flags_t for supported values.
/// ///
int (CEF_CALLBACK *get_flags)(struct _cef_request_t* self); int(CEF_CALLBACK* get_flags)(struct _cef_request_t* self);
/// ///
// Set the flags used in combination with cef_urlrequest_t. See // Set the flags used in combination with cef_urlrequest_t. See
// cef_urlrequest_flags_t for supported values. // cef_urlrequest_flags_t for supported values.
/// ///
void (CEF_CALLBACK *set_flags)(struct _cef_request_t* self, int flags); void(CEF_CALLBACK* set_flags)(struct _cef_request_t* self, int flags);
/// ///
// Set the URL to the first party for cookies used in combination with // Set the URL to the first party for cookies used in combination with
// cef_urlrequest_t. // cef_urlrequest_t.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_first_party_for_cookies)( cef_string_userfree_t(CEF_CALLBACK* get_first_party_for_cookies)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
// Get the URL to the first party for cookies used in combination with // Get the URL to the first party for cookies used in combination with
// cef_urlrequest_t. // cef_urlrequest_t.
/// ///
void (CEF_CALLBACK *set_first_party_for_cookies)(struct _cef_request_t* self, void(CEF_CALLBACK* set_first_party_for_cookies)(struct _cef_request_t* self,
const cef_string_t* url); const cef_string_t* url);
/// ///
// Get the resource type for this request. Only available in the browser // Get the resource type for this request. Only available in the browser
// process. // process.
/// ///
cef_resource_type_t (CEF_CALLBACK *get_resource_type)( cef_resource_type_t(CEF_CALLBACK* get_resource_type)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
@ -179,7 +184,7 @@ typedef struct _cef_request_t {
// process and only applies to requests that represent a main frame or sub- // process and only applies to requests that represent a main frame or sub-
// frame navigation. // frame navigation.
/// ///
cef_transition_type_t (CEF_CALLBACK *get_transition_type)( cef_transition_type_t(CEF_CALLBACK* get_transition_type)(
struct _cef_request_t* self); struct _cef_request_t* self);
/// ///
@ -187,16 +192,14 @@ typedef struct _cef_request_t {
// specified. Can be used by cef_request_tHandler implementations in the // specified. Can be used by cef_request_tHandler implementations in the
// browser process to track a single request across multiple callbacks. // browser process to track a single request across multiple callbacks.
/// ///
uint64 (CEF_CALLBACK *get_identifier)(struct _cef_request_t* self); uint64(CEF_CALLBACK* get_identifier)(struct _cef_request_t* self);
} cef_request_t; } cef_request_t;
/// ///
// Create a new cef_request_t object. // Create a new cef_request_t object.
/// ///
CEF_EXPORT cef_request_t* cef_request_create(); CEF_EXPORT cef_request_t* cef_request_create();
/// ///
// Structure used to represent post data for a web request. The functions of // Structure used to represent post data for a web request. The functions of
// this structure may be called on any thread. // this structure may be called on any thread.
@ -210,7 +213,7 @@ typedef struct _cef_post_data_t {
/// ///
// Returns true (1) if this object is read-only. // Returns true (1) if this object is read-only.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_t* self);
/// ///
// Returns true (1) if the underlying POST data includes elements that are not // Returns true (1) if the underlying POST data includes elements that are not
@ -218,45 +221,44 @@ typedef struct _cef_post_data_t {
// upload data). Modifying cef_post_data_t objects with excluded elements may // upload data). Modifying cef_post_data_t objects with excluded elements may
// result in the request failing. // result in the request failing.
/// ///
int (CEF_CALLBACK *has_excluded_elements)(struct _cef_post_data_t* self); int(CEF_CALLBACK* has_excluded_elements)(struct _cef_post_data_t* self);
/// ///
// Returns the number of existing post data elements. // Returns the number of existing post data elements.
/// ///
size_t (CEF_CALLBACK *get_element_count)(struct _cef_post_data_t* self); size_t(CEF_CALLBACK* get_element_count)(struct _cef_post_data_t* self);
/// ///
// Retrieve the post data elements. // Retrieve the post data elements.
/// ///
void (CEF_CALLBACK *get_elements)(struct _cef_post_data_t* self, void(CEF_CALLBACK* get_elements)(struct _cef_post_data_t* self,
size_t* elementsCount, struct _cef_post_data_element_t** elements); size_t* elementsCount,
struct _cef_post_data_element_t** elements);
/// ///
// Remove the specified post data element. Returns true (1) if the removal // Remove the specified post data element. Returns true (1) if the removal
// succeeds. // succeeds.
/// ///
int (CEF_CALLBACK *remove_element)(struct _cef_post_data_t* self, int(CEF_CALLBACK* remove_element)(struct _cef_post_data_t* self,
struct _cef_post_data_element_t* element); struct _cef_post_data_element_t* element);
/// ///
// Add the specified post data element. Returns true (1) if the add succeeds. // Add the specified post data element. Returns true (1) if the add succeeds.
/// ///
int (CEF_CALLBACK *add_element)(struct _cef_post_data_t* self, int(CEF_CALLBACK* add_element)(struct _cef_post_data_t* self,
struct _cef_post_data_element_t* element); struct _cef_post_data_element_t* element);
/// ///
// Remove all existing post data elements. // Remove all existing post data elements.
/// ///
void (CEF_CALLBACK *remove_elements)(struct _cef_post_data_t* self); void(CEF_CALLBACK* remove_elements)(struct _cef_post_data_t* self);
} cef_post_data_t; } cef_post_data_t;
/// ///
// Create a new cef_post_data_t object. // Create a new cef_post_data_t object.
/// ///
CEF_EXPORT cef_post_data_t* cef_post_data_create(); CEF_EXPORT cef_post_data_t* cef_post_data_create();
/// ///
// Structure used to represent a single element in the request post data. The // Structure used to represent a single element in the request post data. The
// functions of this structure may be called on any thread. // functions of this structure may be called on any thread.
@ -270,59 +272,59 @@ typedef struct _cef_post_data_element_t {
/// ///
// Returns true (1) if this object is read-only. // Returns true (1) if this object is read-only.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_post_data_element_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_post_data_element_t* self);
/// ///
// Remove all contents from the post data element. // Remove all contents from the post data element.
/// ///
void (CEF_CALLBACK *set_to_empty)(struct _cef_post_data_element_t* self); void(CEF_CALLBACK* set_to_empty)(struct _cef_post_data_element_t* self);
/// ///
// The post data element will represent a file. // The post data element will represent a file.
/// ///
void (CEF_CALLBACK *set_to_file)(struct _cef_post_data_element_t* self, void(CEF_CALLBACK* set_to_file)(struct _cef_post_data_element_t* self,
const cef_string_t* fileName); const cef_string_t* fileName);
/// ///
// The post data element will represent bytes. The bytes passed in will be // The post data element will represent bytes. The bytes passed in will be
// copied. // copied.
/// ///
void (CEF_CALLBACK *set_to_bytes)(struct _cef_post_data_element_t* self, void(CEF_CALLBACK* set_to_bytes)(struct _cef_post_data_element_t* self,
size_t size, const void* bytes); size_t size,
const void* bytes);
/// ///
// Return the type of this post data element. // Return the type of this post data element.
/// ///
cef_postdataelement_type_t (CEF_CALLBACK *get_type)( cef_postdataelement_type_t(CEF_CALLBACK* get_type)(
struct _cef_post_data_element_t* self); struct _cef_post_data_element_t* self);
/// ///
// Return the file name. // Return the file name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_file)( cef_string_userfree_t(CEF_CALLBACK* get_file)(
struct _cef_post_data_element_t* self); struct _cef_post_data_element_t* self);
/// ///
// Return the number of bytes. // Return the number of bytes.
/// ///
size_t (CEF_CALLBACK *get_bytes_count)(struct _cef_post_data_element_t* self); size_t(CEF_CALLBACK* get_bytes_count)(struct _cef_post_data_element_t* self);
/// ///
// Read up to |size| bytes into |bytes| and return the number of bytes // Read up to |size| bytes into |bytes| and return the number of bytes
// actually read. // actually read.
/// ///
size_t (CEF_CALLBACK *get_bytes)(struct _cef_post_data_element_t* self, size_t(CEF_CALLBACK* get_bytes)(struct _cef_post_data_element_t* self,
size_t size, void* bytes); size_t size,
void* bytes);
} cef_post_data_element_t; } cef_post_data_element_t;
/// ///
// Create a new cef_post_data_element_t object. // Create a new cef_post_data_element_t object.
/// ///
CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create(); CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

66
include/capi/cef_request_context_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=791231acc78a2b601257fb0b86d904eace796d63$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
@ -63,12 +65,11 @@ typedef struct _cef_resolve_callback_t {
// result code. |resolved_ips| will be the list of resolved IP addresses or // result code. |resolved_ips| will be the list of resolved IP addresses or
// NULL if the resolution failed. // NULL if the resolution failed.
/// ///
void (CEF_CALLBACK *on_resolve_completed)( void(CEF_CALLBACK* on_resolve_completed)(struct _cef_resolve_callback_t* self,
struct _cef_resolve_callback_t* self, cef_errorcode_t result, cef_errorcode_t result,
cef_string_list_t resolved_ips); cef_string_list_t resolved_ips);
} cef_resolve_callback_t; } cef_resolve_callback_t;
/// ///
// A request context provides request handling for a set of related browser or // A request context provides request handling for a set of related browser or
// URL request objects. A request context can be specified when creating a new // URL request objects. A request context can be specified when creating a new
@ -95,14 +96,14 @@ typedef struct _cef_request_context_t {
// Returns true (1) if this object is pointing to the same context as |that| // Returns true (1) if this object is pointing to the same context as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_request_context_t* self, int(CEF_CALLBACK* is_same)(struct _cef_request_context_t* self,
struct _cef_request_context_t* other); struct _cef_request_context_t* other);
/// ///
// Returns true (1) if this object is sharing the same storage as |that| // Returns true (1) if this object is sharing the same storage as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_sharing_with)(struct _cef_request_context_t* self, int(CEF_CALLBACK* is_sharing_with)(struct _cef_request_context_t* self,
struct _cef_request_context_t* other); struct _cef_request_context_t* other);
/// ///
@ -110,12 +111,12 @@ typedef struct _cef_request_context_t {
// is used by default when creating a browser or URL request with a NULL // is used by default when creating a browser or URL request with a NULL
// context argument. // context argument.
/// ///
int (CEF_CALLBACK *is_global)(struct _cef_request_context_t* self); int(CEF_CALLBACK* is_global)(struct _cef_request_context_t* self);
/// ///
// Returns the handler for this context if any. // Returns the handler for this context if any.
/// ///
struct _cef_request_context_handler_t* (CEF_CALLBACK *get_handler)( struct _cef_request_context_handler_t*(CEF_CALLBACK* get_handler)(
struct _cef_request_context_t* self); struct _cef_request_context_t* self);
/// ///
@ -123,7 +124,7 @@ typedef struct _cef_request_context_t {
// memory cache is being used. // memory cache is being used.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_cache_path)( cef_string_userfree_t(CEF_CALLBACK* get_cache_path)(
struct _cef_request_context_t* self); struct _cef_request_context_t* self);
/// ///
@ -134,7 +135,7 @@ typedef struct _cef_request_context_t {
// If |callback| is non-NULL it will be executed asnychronously on the IO // If |callback| is non-NULL it will be executed asnychronously on the IO
// thread after the manager's storage has been initialized. // thread after the manager's storage has been initialized.
/// ///
struct _cef_cookie_manager_t* (CEF_CALLBACK *get_default_cookie_manager)( struct _cef_cookie_manager_t*(CEF_CALLBACK* get_default_cookie_manager)(
struct _cef_request_context_t* self, struct _cef_request_context_t* self,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
@ -151,8 +152,9 @@ typedef struct _cef_request_context_t {
// optional |domain_name|. Returns false (0) if an error occurs. This function // optional |domain_name|. Returns false (0) if an error occurs. This function
// may be called on any thread in the browser process. // may be called on any thread in the browser process.
/// ///
int (CEF_CALLBACK *register_scheme_handler_factory)( int(CEF_CALLBACK* register_scheme_handler_factory)(
struct _cef_request_context_t* self, const cef_string_t* scheme_name, struct _cef_request_context_t* self,
const cef_string_t* scheme_name,
const cef_string_t* domain_name, const cef_string_t* domain_name,
struct _cef_scheme_handler_factory_t* factory); struct _cef_scheme_handler_factory_t* factory);
@ -160,7 +162,7 @@ typedef struct _cef_request_context_t {
// Clear all registered scheme handler factories. Returns false (0) on error. // Clear all registered scheme handler factories. Returns false (0) on error.
// This function may be called on any thread in the browser process. // This function may be called on any thread in the browser process.
/// ///
int (CEF_CALLBACK *clear_scheme_handler_factories)( int(CEF_CALLBACK* clear_scheme_handler_factories)(
struct _cef_request_context_t* self); struct _cef_request_context_t* self);
/// ///
@ -170,14 +172,15 @@ typedef struct _cef_request_context_t {
// cef_request_tContextHandler::OnBeforePluginLoad may be called to rebuild // cef_request_tContextHandler::OnBeforePluginLoad may be called to rebuild
// the plugin list cache. // the plugin list cache.
/// ///
void (CEF_CALLBACK *purge_plugin_list_cache)( void(CEF_CALLBACK* purge_plugin_list_cache)(
struct _cef_request_context_t* self, int reload_pages); struct _cef_request_context_t* self,
int reload_pages);
/// ///
// Returns true (1) if a preference with the specified |name| exists. This // Returns true (1) if a preference with the specified |name| exists. This
// function must be called on the browser process UI thread. // function must be called on the browser process UI thread.
/// ///
int (CEF_CALLBACK *has_preference)(struct _cef_request_context_t* self, int(CEF_CALLBACK* has_preference)(struct _cef_request_context_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
@ -187,8 +190,9 @@ typedef struct _cef_request_context_t {
// will not modify the underlying preference value. This function must be // will not modify the underlying preference value. This function must be
// called on the browser process UI thread. // called on the browser process UI thread.
/// ///
struct _cef_value_t* (CEF_CALLBACK *get_preference)( struct _cef_value_t*(CEF_CALLBACK* get_preference)(
struct _cef_request_context_t* self, const cef_string_t* name); struct _cef_request_context_t* self,
const cef_string_t* name);
/// ///
// Returns all preferences as a dictionary. If |include_defaults| is true (1) // Returns all preferences as a dictionary. If |include_defaults| is true (1)
@ -198,8 +202,9 @@ typedef struct _cef_request_context_t {
// preference values. This function must be called on the browser process UI // preference values. This function must be called on the browser process UI
// thread. // thread.
/// ///
struct _cef_dictionary_value_t* (CEF_CALLBACK *get_all_preferences)( struct _cef_dictionary_value_t*(CEF_CALLBACK* get_all_preferences)(
struct _cef_request_context_t* self, int include_defaults); struct _cef_request_context_t* self,
int include_defaults);
/// ///
// Returns true (1) if the preference with the specified |name| can be // Returns true (1) if the preference with the specified |name| can be
@ -207,7 +212,7 @@ typedef struct _cef_request_context_t {
// command-line usually cannot be modified. This function must be called on // command-line usually cannot be modified. This function must be called on
// the browser process UI thread. // the browser process UI thread.
/// ///
int (CEF_CALLBACK *can_set_preference)(struct _cef_request_context_t* self, int(CEF_CALLBACK* can_set_preference)(struct _cef_request_context_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
@ -217,8 +222,9 @@ typedef struct _cef_request_context_t {
// fails then |error| will be populated with a detailed description of the // fails then |error| will be populated with a detailed description of the
// problem. This function must be called on the browser process UI thread. // problem. This function must be called on the browser process UI thread.
/// ///
int (CEF_CALLBACK *set_preference)(struct _cef_request_context_t* self, int(CEF_CALLBACK* set_preference)(struct _cef_request_context_t* self,
const cef_string_t* name, struct _cef_value_t* value, const cef_string_t* name,
struct _cef_value_t* value,
cef_string_t* error); cef_string_t* error);
/// ///
@ -229,7 +235,7 @@ typedef struct _cef_request_context_t {
// |callback| is non-NULL it will be executed on the UI thread after // |callback| is non-NULL it will be executed on the UI thread after
// completion. // completion.
/// ///
void (CEF_CALLBACK *clear_certificate_exceptions)( void(CEF_CALLBACK* clear_certificate_exceptions)(
struct _cef_request_context_t* self, struct _cef_request_context_t* self,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
@ -239,7 +245,7 @@ typedef struct _cef_request_context_t {
// want to call cef_shutdown(). If |callback| is non-NULL it will be executed // want to call cef_shutdown(). If |callback| is non-NULL it will be executed
// on the UI thread after completion. // on the UI thread after completion.
/// ///
void (CEF_CALLBACK *close_all_connections)( void(CEF_CALLBACK* close_all_connections)(
struct _cef_request_context_t* self, struct _cef_request_context_t* self,
struct _cef_completion_callback_t* callback); struct _cef_completion_callback_t* callback);
@ -247,8 +253,9 @@ typedef struct _cef_request_context_t {
// Attempts to resolve |origin| to a list of associated IP addresses. // Attempts to resolve |origin| to a list of associated IP addresses.
// |callback| will be executed on the UI thread after completion. // |callback| will be executed on the UI thread after completion.
/// ///
void (CEF_CALLBACK *resolve_host)(struct _cef_request_context_t* self, void(CEF_CALLBACK* resolve_host)(struct _cef_request_context_t* self,
const cef_string_t* origin, struct _cef_resolve_callback_t* callback); const cef_string_t* origin,
struct _cef_resolve_callback_t* callback);
/// ///
// Attempts to resolve |origin| to a list of associated IP addresses using // Attempts to resolve |origin| to a list of associated IP addresses using
@ -256,12 +263,12 @@ typedef struct _cef_request_context_t {
// addresses or NULL if no cached data is available. Returns ERR_NONE on // addresses or NULL if no cached data is available. Returns ERR_NONE on
// success. This function must be called on the browser process IO thread. // success. This function must be called on the browser process IO thread.
/// ///
cef_errorcode_t (CEF_CALLBACK *resolve_host_cached)( cef_errorcode_t(CEF_CALLBACK* resolve_host_cached)(
struct _cef_request_context_t* self, const cef_string_t* origin, struct _cef_request_context_t* self,
const cef_string_t* origin,
cef_string_list_t resolved_ips); cef_string_list_t resolved_ips);
} cef_request_context_t; } cef_request_context_t;
/// ///
// Returns the global context object. // Returns the global context object.
/// ///
@ -283,7 +290,6 @@ CEF_EXPORT cef_request_context_t* cef_create_context_shared(
cef_request_context_t* other, cef_request_context_t* other,
struct _cef_request_context_handler_t* handler); struct _cef_request_context_handler_t* handler);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

14
include/capi/cef_request_context_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=9359e227c9d534c9c612d2ede790136461836501$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to provide handler implementations. The handler // Implement this structure to provide handler implementations. The handler
// instance will not be released until all objects related to the context have // instance will not be released until all objects related to the context have
@ -63,7 +64,7 @@ typedef struct _cef_request_context_handler_t {
// this function returns NULL the default cookie manager retrievable via // this function returns NULL the default cookie manager retrievable via
// cef_request_tContext::get_default_cookie_manager() will be used. // cef_request_tContext::get_default_cookie_manager() will be used.
/// ///
struct _cef_cookie_manager_t* (CEF_CALLBACK *get_cookie_manager)( struct _cef_cookie_manager_t*(CEF_CALLBACK* get_cookie_manager)(
struct _cef_request_context_handler_t* self); struct _cef_request_context_handler_t* self);
/// ///
@ -85,15 +86,16 @@ typedef struct _cef_request_context_handler_t {
// trigger new calls to this function call // trigger new calls to this function call
// cef_request_tContext::PurgePluginListCache. // cef_request_tContext::PurgePluginListCache.
/// ///
int (CEF_CALLBACK *on_before_plugin_load)( int(CEF_CALLBACK* on_before_plugin_load)(
struct _cef_request_context_handler_t* self, struct _cef_request_context_handler_t* self,
const cef_string_t* mime_type, const cef_string_t* plugin_url, const cef_string_t* mime_type,
int is_main_frame, const cef_string_t* top_origin_url, const cef_string_t* plugin_url,
int is_main_frame,
const cef_string_t* top_origin_url,
struct _cef_web_plugin_info_t* plugin_info, struct _cef_web_plugin_info_t* plugin_info,
cef_plugin_policy_t* plugin_policy); cef_plugin_policy_t* plugin_policy);
} cef_request_context_handler_t; } cef_request_context_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

139
include/capi/cef_request_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=b6cbe39a8124a961036205864e7e6b2e1eb0bf6b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
@ -53,7 +55,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Callback structure used for asynchronous continuation of url requests. // Callback structure used for asynchronous continuation of url requests.
/// ///
@ -67,15 +68,14 @@ typedef struct _cef_request_callback_t {
// Continue the url request. If |allow| is true (1) the request will be // Continue the url request. If |allow| is true (1) the request will be
// continued. Otherwise, the request will be canceled. // continued. Otherwise, the request will be canceled.
/// ///
void (CEF_CALLBACK *cont)(struct _cef_request_callback_t* self, int allow); void(CEF_CALLBACK* cont)(struct _cef_request_callback_t* self, int allow);
/// ///
// Cancel the url request. // Cancel the url request.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_request_callback_t* self); void(CEF_CALLBACK* cancel)(struct _cef_request_callback_t* self);
} cef_request_callback_t; } cef_request_callback_t;
/// ///
// Callback structure used to select a client certificate for authentication. // Callback structure used to select a client certificate for authentication.
/// ///
@ -89,12 +89,11 @@ typedef struct _cef_select_client_certificate_callback_t {
// Chooses the specified certificate for client certificate authentication. // Chooses the specified certificate for client certificate authentication.
// NULL value means that no client certificate should be used. // NULL value means that no client certificate should be used.
/// ///
void (CEF_CALLBACK *select)( void(CEF_CALLBACK* select)(
struct _cef_select_client_certificate_callback_t* self, struct _cef_select_client_certificate_callback_t* self,
struct _cef_x509certificate_t* cert); struct _cef_x509certificate_t* cert);
} cef_select_client_certificate_callback_t; } cef_select_client_certificate_callback_t;
/// ///
// Implement this structure to handle events related to browser requests. The // Implement this structure to handle events related to browser requests. The
// functions of this structure will be called on the thread indicated. // functions of this structure will be called on the thread indicated.
@ -115,9 +114,11 @@ typedef struct _cef_request_handler_t {
// cef_load_handler_t::OnLoadError will be called with an |errorCode| value of // cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
// ERR_ABORTED. // ERR_ABORTED.
/// ///
int (CEF_CALLBACK *on_before_browse)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* on_before_browse)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_request_t* request, int is_redirect); struct _cef_frame_t* frame,
struct _cef_request_t* request,
int is_redirect);
/// ///
// Called on the UI thread before OnBeforeBrowse in certain limited cases // Called on the UI thread before OnBeforeBrowse in certain limited cases
@ -135,10 +136,13 @@ typedef struct _cef_request_handler_t {
// true (1) to cancel the navigation or false (0) to allow the navigation to // true (1) to cancel the navigation or false (0) to allow the navigation to
// proceed in the source browser's top-level frame. // proceed in the source browser's top-level frame.
/// ///
int (CEF_CALLBACK *on_open_urlfrom_tab)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* on_open_urlfrom_tab)(
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
const cef_string_t* target_url, const cef_string_t* target_url,
cef_window_open_disposition_t target_disposition, int user_gesture); cef_window_open_disposition_t target_disposition,
int user_gesture);
/// ///
// Called on the IO thread before a resource request is loaded. The |request| // Called on the IO thread before a resource request is loaded. The |request|
@ -148,9 +152,11 @@ typedef struct _cef_request_handler_t {
// Return RV_CANCEL to cancel the request immediately. // Return RV_CANCEL to cancel the request immediately.
// //
/// ///
cef_return_value_t (CEF_CALLBACK *on_before_resource_load)( cef_return_value_t(CEF_CALLBACK* on_before_resource_load)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
struct _cef_frame_t* frame, struct _cef_request_t* request, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_request_callback_t* callback); struct _cef_request_callback_t* callback);
/// ///
@ -159,9 +165,11 @@ typedef struct _cef_request_handler_t {
// a cef_resource_handler_t object. The |request| object should not be // a cef_resource_handler_t object. The |request| object should not be
// modified in this callback. // modified in this callback.
/// ///
struct _cef_resource_handler_t* (CEF_CALLBACK *get_resource_handler)( struct _cef_resource_handler_t*(CEF_CALLBACK* get_resource_handler)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
struct _cef_frame_t* frame, struct _cef_request_t* request); struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request);
/// ///
// Called on the IO thread when a resource load is redirected. The |request| // Called on the IO thread when a resource load is redirected. The |request|
@ -171,9 +179,11 @@ typedef struct _cef_request_handler_t {
// changed if desired. The |request| object cannot be modified in this // changed if desired. The |request| object cannot be modified in this
// callback. // callback.
/// ///
void (CEF_CALLBACK *on_resource_redirect)(struct _cef_request_handler_t* self, void(CEF_CALLBACK* on_resource_redirect)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_request_t* request, struct _cef_response_t* response, struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response,
cef_string_t* new_url); cef_string_t* new_url);
/// ///
@ -182,18 +192,22 @@ typedef struct _cef_request_handler_t {
// resource modify |request| (url, headers or post body) and return true (1). // resource modify |request| (url, headers or post body) and return true (1).
// The |response| object cannot be modified in this callback. // The |response| object cannot be modified in this callback.
/// ///
int (CEF_CALLBACK *on_resource_response)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* on_resource_response)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
struct _cef_request_t* request, struct _cef_response_t* response); struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response);
/// ///
// Called on the IO thread to optionally filter resource response content. // Called on the IO thread to optionally filter resource response content.
// |request| and |response| represent the request and response respectively // |request| and |response| represent the request and response respectively
// and cannot be modified in this callback. // and cannot be modified in this callback.
/// ///
struct _cef_response_filter_t* (CEF_CALLBACK *get_resource_response_filter)( struct _cef_response_filter_t*(CEF_CALLBACK* get_resource_response_filter)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
struct _cef_frame_t* frame, struct _cef_request_t* request, struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response); struct _cef_response_t* response);
/// ///
@ -202,10 +216,13 @@ typedef struct _cef_request_handler_t {
// modified in this callback. |status| indicates the load completion status. // modified in this callback. |status| indicates the load completion status.
// |received_content_length| is the number of response bytes actually read. // |received_content_length| is the number of response bytes actually read.
/// ///
void (CEF_CALLBACK *on_resource_load_complete)( void(CEF_CALLBACK* on_resource_load_complete)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
struct _cef_frame_t* frame, struct _cef_request_t* request, struct _cef_browser_t* browser,
struct _cef_response_t* response, cef_urlrequest_status_t status, struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response,
cef_urlrequest_status_t status,
int64 received_content_length); int64 received_content_length);
/// ///
@ -219,10 +236,16 @@ typedef struct _cef_request_handler_t {
// the authentication information is available. Return false (0) to cancel the // the authentication information is available. Return false (0) to cancel the
// request immediately. // request immediately.
/// ///
int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* get_auth_credentials)(
struct _cef_browser_t* browser, struct _cef_frame_t* frame, int isProxy, struct _cef_request_handler_t* self,
const cef_string_t* host, int port, const cef_string_t* realm, struct _cef_browser_t* browser,
const cef_string_t* scheme, struct _cef_auth_callback_t* callback); struct _cef_frame_t* frame,
int isProxy,
const cef_string_t* host,
int port,
const cef_string_t* realm,
const cef_string_t* scheme,
struct _cef_auth_callback_t* callback);
/// ///
// Called on the IO thread when JavaScript requests a specific storage quota // Called on the IO thread when JavaScript requests a specific storage quota
@ -233,9 +256,11 @@ typedef struct _cef_request_handler_t {
// grant or deny the request. Return false (0) to cancel the request // grant or deny the request. Return false (0) to cancel the request
// immediately. // immediately.
/// ///
int (CEF_CALLBACK *on_quota_request)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* on_quota_request)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* origin_url, struct _cef_browser_t* browser,
int64 new_size, struct _cef_request_callback_t* callback); const cef_string_t* origin_url,
int64 new_size,
struct _cef_request_callback_t* callback);
/// ///
// Called on the UI thread to handle requests for URLs with an unknown // Called on the UI thread to handle requests for URLs with an unknown
@ -244,9 +269,10 @@ typedef struct _cef_request_handler_t {
// YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR // YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR
// OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION. // OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
/// ///
void (CEF_CALLBACK *on_protocol_execution)( void(CEF_CALLBACK* on_protocol_execution)(struct _cef_request_handler_t* self,
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_browser_t* browser,
const cef_string_t* url, int* allow_os_execution); const cef_string_t* url,
int* allow_os_execution);
/// ///
// Called on the UI thread to handle requests for URLs with an invalid SSL // Called on the UI thread to handle requests for URLs with an invalid SSL
@ -256,9 +282,12 @@ typedef struct _cef_request_handler_t {
// CefSettings.ignore_certificate_errors is set all invalid certificates will // CefSettings.ignore_certificate_errors is set all invalid certificates will
// be accepted without calling this function. // be accepted without calling this function.
/// ///
int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self, int(CEF_CALLBACK* on_certificate_error)(
struct _cef_browser_t* browser, cef_errorcode_t cert_error, struct _cef_request_handler_t* self,
const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info, struct _cef_browser_t* browser,
cef_errorcode_t cert_error,
const cef_string_t* request_url,
struct _cef_sslinfo_t* ssl_info,
struct _cef_request_callback_t* callback); struct _cef_request_callback_t* callback);
/// ///
@ -274,9 +303,12 @@ typedef struct _cef_request_handler_t {
// pruned by Chromium so that it only contains certificates from issuers that // pruned by Chromium so that it only contains certificates from issuers that
// the server trusts. // the server trusts.
/// ///
int (CEF_CALLBACK *on_select_client_certificate)( int(CEF_CALLBACK* on_select_client_certificate)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
int isProxy, const cef_string_t* host, int port, struct _cef_browser_t* browser,
int isProxy,
const cef_string_t* host,
int port,
size_t certificatesCount, size_t certificatesCount,
struct _cef_x509certificate_t* const* certificates, struct _cef_x509certificate_t* const* certificates,
struct _cef_select_client_certificate_callback_t* callback); struct _cef_select_client_certificate_callback_t* callback);
@ -285,27 +317,28 @@ typedef struct _cef_request_handler_t {
// Called on the browser process UI thread when a plugin has crashed. // Called on the browser process UI thread when a plugin has crashed.
// |plugin_path| is the path of the plugin that crashed. // |plugin_path| is the path of the plugin that crashed.
/// ///
void (CEF_CALLBACK *on_plugin_crashed)(struct _cef_request_handler_t* self, void(CEF_CALLBACK* on_plugin_crashed)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* plugin_path); struct _cef_browser_t* browser,
const cef_string_t* plugin_path);
/// ///
// Called on the browser process UI thread when the render view associated // Called on the browser process UI thread when the render view associated
// with |browser| is ready to receive/handle IPC messages in the render // with |browser| is ready to receive/handle IPC messages in the render
// process. // process.
/// ///
void (CEF_CALLBACK *on_render_view_ready)(struct _cef_request_handler_t* self, void(CEF_CALLBACK* on_render_view_ready)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser); struct _cef_browser_t* browser);
/// ///
// Called on the browser process UI thread when the render process terminates // Called on the browser process UI thread when the render process terminates
// unexpectedly. |status| indicates how the process terminated. // unexpectedly. |status| indicates how the process terminated.
/// ///
void (CEF_CALLBACK *on_render_process_terminated)( void(CEF_CALLBACK* on_render_process_terminated)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser, struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
cef_termination_status_t status); cef_termination_status_t status);
} cef_request_handler_t; } cef_request_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

25
include/capi/cef_resource_bundle_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=82f2ce6f2ea3a8268ac69e33d304ace1a0e192b2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used for retrieving resources from the resource bundle (*.pak) // Structure used for retrieving resources from the resource bundle (*.pak)
// files loaded by CEF during startup or via the cef_resource_bundle_tHandler // files loaded by CEF during startup or via the cef_resource_bundle_tHandler
@ -64,8 +65,9 @@ typedef struct _cef_resource_bundle_t {
// of valid string ID values. // of valid string ID values.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_localized_string)( cef_string_userfree_t(CEF_CALLBACK* get_localized_string)(
struct _cef_resource_bundle_t* self, int string_id); struct _cef_resource_bundle_t* self,
int string_id);
/// ///
// Retrieves the contents of the specified scale independent |resource_id|. If // Retrieves the contents of the specified scale independent |resource_id|. If
@ -75,8 +77,10 @@ typedef struct _cef_resource_bundle_t {
// memory and should not be freed. Include cef_pack_resources.h for a listing // memory and should not be freed. Include cef_pack_resources.h for a listing
// of valid resource ID values. // of valid resource ID values.
/// ///
int (CEF_CALLBACK *get_data_resource)(struct _cef_resource_bundle_t* self, int(CEF_CALLBACK* get_data_resource)(struct _cef_resource_bundle_t* self,
int resource_id, void** data, size_t* data_size); int resource_id,
void** data,
size_t* data_size);
/// ///
// Retrieves the contents of the specified |resource_id| nearest the scale // Retrieves the contents of the specified |resource_id| nearest the scale
@ -88,18 +92,19 @@ typedef struct _cef_resource_bundle_t {
// memory and should not be freed. Include cef_pack_resources.h for a listing // memory and should not be freed. Include cef_pack_resources.h for a listing
// of valid resource ID values. // of valid resource ID values.
/// ///
int (CEF_CALLBACK *get_data_resource_for_scale)( int(CEF_CALLBACK* get_data_resource_for_scale)(
struct _cef_resource_bundle_t* self, int resource_id, struct _cef_resource_bundle_t* self,
cef_scale_factor_t scale_factor, void** data, size_t* data_size); int resource_id,
cef_scale_factor_t scale_factor,
void** data,
size_t* data_size);
} cef_resource_bundle_t; } cef_resource_bundle_t;
/// ///
// Returns the global resource bundle instance. // Returns the global resource bundle instance.
/// ///
CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global(); CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

24
include/capi/cef_resource_bundle_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=cd94d8670c26bf17082629e5297407a716f01503$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to implement a custom resource bundle structure. See // Structure used to implement a custom resource bundle structure. See
// CefSettings for additional options related to resource bundle loading. The // CefSettings for additional options related to resource bundle loading. The
@ -62,8 +63,9 @@ typedef struct _cef_resource_bundle_handler_t {
// return true (1). To use the default translation return false (0). Include // return true (1). To use the default translation return false (0). Include
// cef_pack_strings.h for a listing of valid string ID values. // cef_pack_strings.h for a listing of valid string ID values.
/// ///
int (CEF_CALLBACK *get_localized_string)( int(CEF_CALLBACK* get_localized_string)(
struct _cef_resource_bundle_handler_t* self, int string_id, struct _cef_resource_bundle_handler_t* self,
int string_id,
cef_string_t* string); cef_string_t* string);
/// ///
@ -74,8 +76,10 @@ typedef struct _cef_resource_bundle_handler_t {
// resident in memory. Include cef_pack_resources.h for a listing of valid // resident in memory. Include cef_pack_resources.h for a listing of valid
// resource ID values. // resource ID values.
/// ///
int (CEF_CALLBACK *get_data_resource)( int(CEF_CALLBACK* get_data_resource)(
struct _cef_resource_bundle_handler_t* self, int resource_id, void** data, struct _cef_resource_bundle_handler_t* self,
int resource_id,
void** data,
size_t* data_size); size_t* data_size);
/// ///
@ -86,12 +90,14 @@ typedef struct _cef_resource_bundle_handler_t {
// not be copied and must remain resident in memory. Include // not be copied and must remain resident in memory. Include
// cef_pack_resources.h for a listing of valid resource ID values. // cef_pack_resources.h for a listing of valid resource ID values.
/// ///
int (CEF_CALLBACK *get_data_resource_for_scale)( int(CEF_CALLBACK* get_data_resource_for_scale)(
struct _cef_resource_bundle_handler_t* self, int resource_id, struct _cef_resource_bundle_handler_t* self,
cef_scale_factor_t scale_factor, void** data, size_t* data_size); int resource_id,
cef_scale_factor_t scale_factor,
void** data,
size_t* data_size);
} cef_resource_bundle_handler_t; } cef_resource_bundle_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

28
include/capi/cef_resource_handler_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=cd9c4ed153ad4425ff43d640a81693e3c83817d2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
@ -49,7 +51,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to implement a custom request handler structure. The functions // Structure used to implement a custom request handler structure. The functions
// of this structure will always be called on the IO thread. // of this structure will always be called on the IO thread.
@ -67,8 +68,9 @@ typedef struct _cef_resource_handler_t {
// function if header information is available immediately). To cancel the // function if header information is available immediately). To cancel the
// request return false (0). // request return false (0).
/// ///
int (CEF_CALLBACK *process_request)(struct _cef_resource_handler_t* self, int(CEF_CALLBACK* process_request)(struct _cef_resource_handler_t* self,
struct _cef_request_t* request, struct _cef_callback_t* callback); struct _cef_request_t* request,
struct _cef_callback_t* callback);
/// ///
// Retrieve response header information. If the response length is not known // Retrieve response header information. If the response length is not known
@ -81,9 +83,10 @@ typedef struct _cef_resource_handler_t {
// URL. If an error occured while setting up the request you can call // URL. If an error occured while setting up the request you can call
// set_error() on |response| to indicate the error condition. // set_error() on |response| to indicate the error condition.
/// ///
void (CEF_CALLBACK *get_response_headers)( void(CEF_CALLBACK* get_response_headers)(struct _cef_resource_handler_t* self,
struct _cef_resource_handler_t* self, struct _cef_response_t* response, struct _cef_response_t* response,
int64* response_length, cef_string_t* redirectUrl); int64* response_length,
cef_string_t* redirectUrl);
/// ///
// Read response data. If data is available immediately copy up to // Read response data. If data is available immediately copy up to
@ -92,8 +95,10 @@ typedef struct _cef_resource_handler_t {
// |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the // |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the
// data is available. To indicate response completion return false (0). // data is available. To indicate response completion return false (0).
/// ///
int (CEF_CALLBACK *read_response)(struct _cef_resource_handler_t* self, int(CEF_CALLBACK* read_response)(struct _cef_resource_handler_t* self,
void* data_out, int bytes_to_read, int* bytes_read, void* data_out,
int bytes_to_read,
int* bytes_read,
struct _cef_callback_t* callback); struct _cef_callback_t* callback);
/// ///
@ -101,23 +106,22 @@ typedef struct _cef_resource_handler_t {
// false (0) otherwise. If false (0) is returned for any cookie then no // false (0) otherwise. If false (0) is returned for any cookie then no
// cookies will be sent with the request. // cookies will be sent with the request.
/// ///
int (CEF_CALLBACK *can_get_cookie)(struct _cef_resource_handler_t* self, int(CEF_CALLBACK* can_get_cookie)(struct _cef_resource_handler_t* self,
const struct _cef_cookie_t* cookie); const struct _cef_cookie_t* cookie);
/// ///
// Return true (1) if the specified cookie returned with the response can be // Return true (1) if the specified cookie returned with the response can be
// set or false (0) otherwise. // set or false (0) otherwise.
/// ///
int (CEF_CALLBACK *can_set_cookie)(struct _cef_resource_handler_t* self, int(CEF_CALLBACK* can_set_cookie)(struct _cef_resource_handler_t* self,
const struct _cef_cookie_t* cookie); const struct _cef_cookie_t* cookie);
/// ///
// Request processing has been canceled. // Request processing has been canceled.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_resource_handler_t* self); void(CEF_CALLBACK* cancel)(struct _cef_resource_handler_t* self);
} cef_resource_handler_t; } cef_resource_handler_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

29
include/capi/cef_response_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=3f0ed89d2320677780c2fd526be7fe6312580cd8$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure used to represent a web response. The functions of this structure // Structure used to represent a web response. The functions of this structure
// may be called on any thread. // may be called on any thread.
@ -58,83 +59,81 @@ typedef struct _cef_response_t {
/// ///
// Returns true (1) if this object is read-only. // Returns true (1) if this object is read-only.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_response_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_response_t* self);
/// ///
// Get the response error code. Returns ERR_NONE if there was no error. // Get the response error code. Returns ERR_NONE if there was no error.
/// ///
cef_errorcode_t (CEF_CALLBACK *get_error)(struct _cef_response_t* self); cef_errorcode_t(CEF_CALLBACK* get_error)(struct _cef_response_t* self);
/// ///
// Set the response error code. This can be used by custom scheme handlers to // Set the response error code. This can be used by custom scheme handlers to
// return errors during initial request processing. // return errors during initial request processing.
/// ///
void (CEF_CALLBACK *set_error)(struct _cef_response_t* self, void(CEF_CALLBACK* set_error)(struct _cef_response_t* self,
cef_errorcode_t error); cef_errorcode_t error);
/// ///
// Get the response status code. // Get the response status code.
/// ///
int (CEF_CALLBACK *get_status)(struct _cef_response_t* self); int(CEF_CALLBACK* get_status)(struct _cef_response_t* self);
/// ///
// Set the response status code. // Set the response status code.
/// ///
void (CEF_CALLBACK *set_status)(struct _cef_response_t* self, int status); void(CEF_CALLBACK* set_status)(struct _cef_response_t* self, int status);
/// ///
// Get the response status text. // Get the response status text.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_status_text)( cef_string_userfree_t(CEF_CALLBACK* get_status_text)(
struct _cef_response_t* self); struct _cef_response_t* self);
/// ///
// Set the response status text. // Set the response status text.
/// ///
void (CEF_CALLBACK *set_status_text)(struct _cef_response_t* self, void(CEF_CALLBACK* set_status_text)(struct _cef_response_t* self,
const cef_string_t* statusText); const cef_string_t* statusText);
/// ///
// Get the response mime type. // Get the response mime type.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_mime_type)( cef_string_userfree_t(CEF_CALLBACK* get_mime_type)(
struct _cef_response_t* self); struct _cef_response_t* self);
/// ///
// Set the response mime type. // Set the response mime type.
/// ///
void (CEF_CALLBACK *set_mime_type)(struct _cef_response_t* self, void(CEF_CALLBACK* set_mime_type)(struct _cef_response_t* self,
const cef_string_t* mimeType); const cef_string_t* mimeType);
/// ///
// Get the value for the specified response header field. // Get the value for the specified response header field.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_header)(struct _cef_response_t* self, cef_string_userfree_t(CEF_CALLBACK* get_header)(struct _cef_response_t* self,
const cef_string_t* name); const cef_string_t* name);
/// ///
// Get all response header fields. // Get all response header fields.
/// ///
void (CEF_CALLBACK *get_header_map)(struct _cef_response_t* self, void(CEF_CALLBACK* get_header_map)(struct _cef_response_t* self,
cef_string_multimap_t headerMap); cef_string_multimap_t headerMap);
/// ///
// Set all response header fields. // Set all response header fields.
/// ///
void (CEF_CALLBACK *set_header_map)(struct _cef_response_t* self, void(CEF_CALLBACK* set_header_map)(struct _cef_response_t* self,
cef_string_multimap_t headerMap); cef_string_multimap_t headerMap);
} cef_response_t; } cef_response_t;
/// ///
// Create a new cef_response_t object. // Create a new cef_response_t object.
/// ///
CEF_EXPORT cef_response_t* cef_response_create(); CEF_EXPORT cef_response_t* cef_response_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

16
include/capi/cef_response_filter_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=c7126418fc448f9f75e770fda8434613eed0930d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to filter resource response content. The functions // Implement this structure to filter resource response content. The functions
// of this structure will be called on the browser process IO thread. // of this structure will be called on the browser process IO thread.
@ -59,7 +60,7 @@ typedef struct _cef_response_filter_t {
// Initialize the response filter. Will only be called a single time. The // Initialize the response filter. Will only be called a single time. The
// filter will not be installed if this function returns false (0). // filter will not be installed if this function returns false (0).
/// ///
int (CEF_CALLBACK *init_filter)(struct _cef_response_filter_t* self); int(CEF_CALLBACK* init_filter)(struct _cef_response_filter_t* self);
/// ///
// Called to filter a chunk of data. Expected usage is as follows: // Called to filter a chunk of data. Expected usage is as follows:
@ -92,13 +93,16 @@ typedef struct _cef_response_filter_t {
// //
// Do not keep a reference to the buffers passed to this function. // Do not keep a reference to the buffers passed to this function.
/// ///
cef_response_filter_status_t (CEF_CALLBACK *filter)( cef_response_filter_status_t(CEF_CALLBACK* filter)(
struct _cef_response_filter_t* self, void* data_in, size_t data_in_size, struct _cef_response_filter_t* self,
size_t* data_in_read, void* data_out, size_t data_out_size, void* data_in,
size_t data_in_size,
size_t* data_in_read,
void* data_out,
size_t data_out_size,
size_t* data_out_written); size_t* data_out_written);
} cef_response_filter_t; } cef_response_filter_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

25
include/capi/cef_scheme_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=a920e25c5ca348dcc45965d53389c16a8a29b0ed$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
@ -119,13 +121,16 @@ typedef struct _cef_scheme_registrar_t {
// per unique |scheme_name| value. If |scheme_name| is already registered or // per unique |scheme_name| value. If |scheme_name| is already registered or
// if an error occurs this function will return false (0). // if an error occurs this function will return false (0).
/// ///
int (CEF_CALLBACK *add_custom_scheme)(struct _cef_scheme_registrar_t* self, int(CEF_CALLBACK* add_custom_scheme)(struct _cef_scheme_registrar_t* self,
const cef_string_t* scheme_name, int is_standard, int is_local, const cef_string_t* scheme_name,
int is_display_isolated, int is_secure, int is_cors_enabled, int is_standard,
int is_local,
int is_display_isolated,
int is_secure,
int is_cors_enabled,
int is_csp_bypassing); int is_csp_bypassing);
} cef_scheme_registrar_t; } cef_scheme_registrar_t;
/// ///
// Structure that creates cef_resource_handler_t instances for handling scheme // Structure that creates cef_resource_handler_t instances for handling scheme
// requests. The functions of this structure will always be called on the IO // requests. The functions of this structure will always be called on the IO
@ -145,13 +150,14 @@ typedef struct _cef_scheme_handler_factory_t {
// example, if the request came from cef_urlrequest_t). The |request| object // example, if the request came from cef_urlrequest_t). The |request| object
// passed to this function will not contain cookie data. // passed to this function will not contain cookie data.
/// ///
struct _cef_resource_handler_t* (CEF_CALLBACK *create)( struct _cef_resource_handler_t*(CEF_CALLBACK* create)(
struct _cef_scheme_handler_factory_t* self, struct _cef_scheme_handler_factory_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame, struct _cef_browser_t* browser,
const cef_string_t* scheme_name, struct _cef_request_t* request); struct _cef_frame_t* frame,
const cef_string_t* scheme_name,
struct _cef_request_t* request);
} cef_scheme_handler_factory_t; } cef_scheme_handler_factory_t;
/// ///
// Register a scheme handler factory with the global request context. An NULL // Register a scheme handler factory with the global request context. An NULL
// |domain_name| value for a standard scheme will cause the factory to match all // |domain_name| value for a standard scheme will cause the factory to match all
@ -168,7 +174,8 @@ typedef struct _cef_scheme_handler_factory_t {
// ory(). // ory().
/// ///
CEF_EXPORT int cef_register_scheme_handler_factory( CEF_EXPORT int cef_register_scheme_handler_factory(
const cef_string_t* scheme_name, const cef_string_t* domain_name, const cef_string_t* scheme_name,
const cef_string_t* domain_name,
cef_scheme_handler_factory_t* factory); cef_scheme_handler_factory_t* factory);
/// ///

9
include/capi/cef_ssl_info_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=7489f3078e15407c3984f0b2393df3b0ddc045b0$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure representing SSL information. // Structure representing SSL information.
/// ///
@ -60,17 +61,15 @@ typedef struct _cef_sslinfo_t {
// Returns a bitmask containing any and all problems verifying the server // Returns a bitmask containing any and all problems verifying the server
// certificate. // certificate.
/// ///
cef_cert_status_t (CEF_CALLBACK *get_cert_status)( cef_cert_status_t(CEF_CALLBACK* get_cert_status)(struct _cef_sslinfo_t* self);
struct _cef_sslinfo_t* self);
/// ///
// Returns the X.509 certificate. // Returns the X.509 certificate.
/// ///
struct _cef_x509certificate_t* (CEF_CALLBACK *get_x509certificate)( struct _cef_x509certificate_t*(CEF_CALLBACK* get_x509certificate)(
struct _cef_sslinfo_t* self); struct _cef_sslinfo_t* self);
} cef_sslinfo_t; } cef_sslinfo_t;
/// ///
// Returns true (1) if the certificate status has any error, major or minor. // Returns true (1) if the certificate status has any error, major or minor.
/// ///

14
include/capi/cef_ssl_status_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=2aa604a0520a802ae3b10f5922d4a7ca48078785$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
@ -46,7 +48,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure representing the SSL information for a navigation entry. // Structure representing the SSL information for a navigation entry.
/// ///
@ -59,35 +60,34 @@ typedef struct _cef_sslstatus_t {
/// ///
// Returns true (1) if the status is related to a secure SSL/TLS connection. // Returns true (1) if the status is related to a secure SSL/TLS connection.
/// ///
int (CEF_CALLBACK *is_secure_connection)(struct _cef_sslstatus_t* self); int(CEF_CALLBACK* is_secure_connection)(struct _cef_sslstatus_t* self);
/// ///
// Returns a bitmask containing any and all problems verifying the server // Returns a bitmask containing any and all problems verifying the server
// certificate. // certificate.
/// ///
cef_cert_status_t (CEF_CALLBACK *get_cert_status)( cef_cert_status_t(CEF_CALLBACK* get_cert_status)(
struct _cef_sslstatus_t* self); struct _cef_sslstatus_t* self);
/// ///
// Returns the SSL version used for the SSL connection. // Returns the SSL version used for the SSL connection.
/// ///
cef_ssl_version_t (CEF_CALLBACK *get_sslversion)( cef_ssl_version_t(CEF_CALLBACK* get_sslversion)(
struct _cef_sslstatus_t* self); struct _cef_sslstatus_t* self);
/// ///
// Returns a bitmask containing the page security content status. // Returns a bitmask containing the page security content status.
/// ///
cef_ssl_content_status_t (CEF_CALLBACK *get_content_status)( cef_ssl_content_status_t(CEF_CALLBACK* get_content_status)(
struct _cef_sslstatus_t* self); struct _cef_sslstatus_t* self);
/// ///
// Returns the X.509 certificate. // Returns the X.509 certificate.
/// ///
struct _cef_x509certificate_t* (CEF_CALLBACK *get_x509certificate)( struct _cef_x509certificate_t*(CEF_CALLBACK* get_x509certificate)(
struct _cef_sslstatus_t* self); struct _cef_sslstatus_t* self);
} cef_sslstatus_t; } cef_sslstatus_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

69
include/capi/cef_stream_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=4e127106e9b5fada6bf05ea6e29bc502bb2a1e0d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure the client can implement to provide a custom stream reader. The // Structure the client can implement to provide a custom stream reader. The
// functions of this structure may be called on any thread. // functions of this structure may be called on any thread.
@ -58,35 +59,37 @@ typedef struct _cef_read_handler_t {
/// ///
// Read raw binary data. // Read raw binary data.
/// ///
size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr, size_t(CEF_CALLBACK* read)(struct _cef_read_handler_t* self,
size_t size, size_t n); void* ptr,
size_t size,
size_t n);
/// ///
// Seek to the specified offset position. |whence| may be any one of SEEK_CUR, // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
// SEEK_END or SEEK_SET. Return zero on success and non-zero on failure. // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
/// ///
int (CEF_CALLBACK *seek)(struct _cef_read_handler_t* self, int64 offset, int(CEF_CALLBACK* seek)(struct _cef_read_handler_t* self,
int64 offset,
int whence); int whence);
/// ///
// Return the current offset position. // Return the current offset position.
/// ///
int64 (CEF_CALLBACK *tell)(struct _cef_read_handler_t* self); int64(CEF_CALLBACK* tell)(struct _cef_read_handler_t* self);
/// ///
// Return non-zero if at end of file. // Return non-zero if at end of file.
/// ///
int (CEF_CALLBACK *eof)(struct _cef_read_handler_t* self); int(CEF_CALLBACK* eof)(struct _cef_read_handler_t* self);
/// ///
// Return true (1) if this handler performs work like accessing the file // Return true (1) if this handler performs work like accessing the file
// system which may block. Used as a hint for determining the thread to access // system which may block. Used as a hint for determining the thread to access
// the handler from. // the handler from.
/// ///
int (CEF_CALLBACK *may_block)(struct _cef_read_handler_t* self); int(CEF_CALLBACK* may_block)(struct _cef_read_handler_t* self);
} cef_read_handler_t; } cef_read_handler_t;
/// ///
// Structure used to read data from a stream. The functions of this structure // Structure used to read data from a stream. The functions of this structure
// may be called on any thread. // may be called on any thread.
@ -100,35 +103,37 @@ typedef struct _cef_stream_reader_t {
/// ///
// Read raw binary data. // Read raw binary data.
/// ///
size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr, size_t(CEF_CALLBACK* read)(struct _cef_stream_reader_t* self,
size_t size, size_t n); void* ptr,
size_t size,
size_t n);
/// ///
// Seek to the specified offset position. |whence| may be any one of SEEK_CUR, // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
// SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure. // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
/// ///
int (CEF_CALLBACK *seek)(struct _cef_stream_reader_t* self, int64 offset, int(CEF_CALLBACK* seek)(struct _cef_stream_reader_t* self,
int64 offset,
int whence); int whence);
/// ///
// Return the current offset position. // Return the current offset position.
/// ///
int64 (CEF_CALLBACK *tell)(struct _cef_stream_reader_t* self); int64(CEF_CALLBACK* tell)(struct _cef_stream_reader_t* self);
/// ///
// Return non-zero if at end of file. // Return non-zero if at end of file.
/// ///
int (CEF_CALLBACK *eof)(struct _cef_stream_reader_t* self); int(CEF_CALLBACK* eof)(struct _cef_stream_reader_t* self);
/// ///
// Returns true (1) if this reader performs work like accessing the file // Returns true (1) if this reader performs work like accessing the file
// system which may block. Used as a hint for determining the thread to access // system which may block. Used as a hint for determining the thread to access
// the reader from. // the reader from.
/// ///
int (CEF_CALLBACK *may_block)(struct _cef_stream_reader_t* self); int(CEF_CALLBACK* may_block)(struct _cef_stream_reader_t* self);
} cef_stream_reader_t; } cef_stream_reader_t;
/// ///
// Create a new cef_stream_reader_t object from a file. // Create a new cef_stream_reader_t object from a file.
/// ///
@ -147,7 +152,6 @@ CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler( CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_handler(
cef_read_handler_t* handler); cef_read_handler_t* handler);
/// ///
// Structure the client can implement to provide a custom stream writer. The // Structure the client can implement to provide a custom stream writer. The
// functions of this structure may be called on any thread. // functions of this structure may be called on any thread.
@ -161,35 +165,37 @@ typedef struct _cef_write_handler_t {
/// ///
// Write raw binary data. // Write raw binary data.
/// ///
size_t (CEF_CALLBACK *write)(struct _cef_write_handler_t* self, size_t(CEF_CALLBACK* write)(struct _cef_write_handler_t* self,
const void* ptr, size_t size, size_t n); const void* ptr,
size_t size,
size_t n);
/// ///
// Seek to the specified offset position. |whence| may be any one of SEEK_CUR, // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
// SEEK_END or SEEK_SET. Return zero on success and non-zero on failure. // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
/// ///
int (CEF_CALLBACK *seek)(struct _cef_write_handler_t* self, int64 offset, int(CEF_CALLBACK* seek)(struct _cef_write_handler_t* self,
int64 offset,
int whence); int whence);
/// ///
// Return the current offset position. // Return the current offset position.
/// ///
int64 (CEF_CALLBACK *tell)(struct _cef_write_handler_t* self); int64(CEF_CALLBACK* tell)(struct _cef_write_handler_t* self);
/// ///
// Flush the stream. // Flush the stream.
/// ///
int (CEF_CALLBACK *flush)(struct _cef_write_handler_t* self); int(CEF_CALLBACK* flush)(struct _cef_write_handler_t* self);
/// ///
// Return true (1) if this handler performs work like accessing the file // Return true (1) if this handler performs work like accessing the file
// system which may block. Used as a hint for determining the thread to access // system which may block. Used as a hint for determining the thread to access
// the handler from. // the handler from.
/// ///
int (CEF_CALLBACK *may_block)(struct _cef_write_handler_t* self); int(CEF_CALLBACK* may_block)(struct _cef_write_handler_t* self);
} cef_write_handler_t; } cef_write_handler_t;
/// ///
// Structure used to write data to a stream. The functions of this structure may // Structure used to write data to a stream. The functions of this structure may
// be called on any thread. // be called on any thread.
@ -203,35 +209,37 @@ typedef struct _cef_stream_writer_t {
/// ///
// Write raw binary data. // Write raw binary data.
/// ///
size_t (CEF_CALLBACK *write)(struct _cef_stream_writer_t* self, size_t(CEF_CALLBACK* write)(struct _cef_stream_writer_t* self,
const void* ptr, size_t size, size_t n); const void* ptr,
size_t size,
size_t n);
/// ///
// Seek to the specified offset position. |whence| may be any one of SEEK_CUR, // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
// SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure. // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
/// ///
int (CEF_CALLBACK *seek)(struct _cef_stream_writer_t* self, int64 offset, int(CEF_CALLBACK* seek)(struct _cef_stream_writer_t* self,
int64 offset,
int whence); int whence);
/// ///
// Return the current offset position. // Return the current offset position.
/// ///
int64 (CEF_CALLBACK *tell)(struct _cef_stream_writer_t* self); int64(CEF_CALLBACK* tell)(struct _cef_stream_writer_t* self);
/// ///
// Flush the stream. // Flush the stream.
/// ///
int (CEF_CALLBACK *flush)(struct _cef_stream_writer_t* self); int(CEF_CALLBACK* flush)(struct _cef_stream_writer_t* self);
/// ///
// Returns true (1) if this writer performs work like accessing the file // Returns true (1) if this writer performs work like accessing the file
// system which may block. Used as a hint for determining the thread to access // system which may block. Used as a hint for determining the thread to access
// the writer from. // the writer from.
/// ///
int (CEF_CALLBACK *may_block)(struct _cef_stream_writer_t* self); int(CEF_CALLBACK* may_block)(struct _cef_stream_writer_t* self);
} cef_stream_writer_t; } cef_stream_writer_t;
/// ///
// Create a new cef_stream_writer_t object for a file. // Create a new cef_stream_writer_t object for a file.
/// ///
@ -244,7 +252,6 @@ CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file(
CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler( CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_handler(
cef_write_handler_t* handler); cef_write_handler_t* handler);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
include/capi/cef_string_visitor_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=2e8edddfd49aea615c7adf8d0d092a4865b79229$
//
#ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to receive string values asynchronously. // Implement this structure to receive string values asynchronously.
/// ///
@ -57,11 +58,10 @@ typedef struct _cef_string_visitor_t {
/// ///
// Method that will be executed. // Method that will be executed.
/// ///
void (CEF_CALLBACK *visit)(struct _cef_string_visitor_t* self, void(CEF_CALLBACK* visit)(struct _cef_string_visitor_t* self,
const cef_string_t* string); const cef_string_t* string);
} cef_string_visitor_t; } cef_string_visitor_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

25
include/capi/cef_task_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=344ba415349b4cc305f51cb9e22563b232433e25$
//
#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure for asynchronous task execution. If the task is // Implement this structure for asynchronous task execution. If the task is
// posted successfully and if the associated message loop is still running then // posted successfully and if the associated message loop is still running then
@ -62,10 +63,9 @@ typedef struct _cef_task_t {
/// ///
// Method that will be executed on the target thread. // Method that will be executed on the target thread.
/// ///
void (CEF_CALLBACK *execute)(struct _cef_task_t* self); void(CEF_CALLBACK* execute)(struct _cef_task_t* self);
} cef_task_t; } cef_task_t;
/// ///
// Structure that asynchronously executes tasks on the associated thread. It is // Structure that asynchronously executes tasks on the associated thread. It is
// safe to call the functions of this structure on any thread. // safe to call the functions of this structure on any thread.
@ -85,26 +85,25 @@ typedef struct _cef_task_runner_t {
// Returns true (1) if this object is pointing to the same task runner as // Returns true (1) if this object is pointing to the same task runner as
// |that| object. // |that| object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_task_runner_t* self, int(CEF_CALLBACK* is_same)(struct _cef_task_runner_t* self,
struct _cef_task_runner_t* that); struct _cef_task_runner_t* that);
/// ///
// Returns true (1) if this task runner belongs to the current thread. // Returns true (1) if this task runner belongs to the current thread.
/// ///
int (CEF_CALLBACK *belongs_to_current_thread)( int(CEF_CALLBACK* belongs_to_current_thread)(struct _cef_task_runner_t* self);
struct _cef_task_runner_t* self);
/// ///
// Returns true (1) if this task runner is for the specified CEF thread. // Returns true (1) if this task runner is for the specified CEF thread.
/// ///
int (CEF_CALLBACK *belongs_to_thread)(struct _cef_task_runner_t* self, int(CEF_CALLBACK* belongs_to_thread)(struct _cef_task_runner_t* self,
cef_thread_id_t threadId); cef_thread_id_t threadId);
/// ///
// Post a task for execution on the thread associated with this task runner. // Post a task for execution on the thread associated with this task runner.
// Execution will occur asynchronously. // Execution will occur asynchronously.
/// ///
int (CEF_CALLBACK *post_task)(struct _cef_task_runner_t* self, int(CEF_CALLBACK* post_task)(struct _cef_task_runner_t* self,
struct _cef_task_t* task); struct _cef_task_t* task);
/// ///
@ -113,11 +112,11 @@ typedef struct _cef_task_runner_t {
// supported on V8 WebWorker threads and will be executed without the // supported on V8 WebWorker threads and will be executed without the
// specified delay. // specified delay.
/// ///
int (CEF_CALLBACK *post_delayed_task)(struct _cef_task_runner_t* self, int(CEF_CALLBACK* post_delayed_task)(struct _cef_task_runner_t* self,
struct _cef_task_t* task, int64 delay_ms); struct _cef_task_t* task,
int64 delay_ms);
} cef_task_runner_t; } cef_task_runner_t;
/// ///
// Returns the task runner for the current thread. Only CEF threads will have // Returns the task runner for the current thread. Only CEF threads will have
// task runners. An NULL reference will be returned if this function is called // task runners. An NULL reference will be returned if this function is called
@ -131,7 +130,6 @@ CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread();
CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread( CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
cef_thread_id_t threadId); cef_thread_id_t threadId);
/// ///
// Returns true (1) if called on the specified thread. Equivalent to using // Returns true (1) if called on the specified thread. Equivalent to using
// cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread(). // cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread().
@ -149,7 +147,8 @@ CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task);
// using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task, // using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task,
// delay_ms). // delay_ms).
/// ///
CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, cef_task_t* task, CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId,
cef_task_t* task,
int64 delay_ms); int64 delay_ms);
#ifdef __cplusplus #ifdef __cplusplus

22
include/capi/cef_thread_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=d844086fc675680bfae12c3fa12a6886cc804816$
//
#ifndef CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// A simple thread abstraction that establishes a message loop on a new thread. // A simple thread abstraction that establishes a message loop on a new thread.
// The consumer uses cef_task_tRunner to execute code on the thread's message // The consumer uses cef_task_tRunner to execute code on the thread's message
@ -67,14 +68,14 @@ typedef struct _cef_thread_t {
// Returns the cef_task_tRunner that will execute code on this thread's // Returns the cef_task_tRunner that will execute code on this thread's
// message loop. This function is safe to call from any thread. // message loop. This function is safe to call from any thread.
/// ///
struct _cef_task_runner_t* (CEF_CALLBACK *get_task_runner)( struct _cef_task_runner_t*(CEF_CALLBACK* get_task_runner)(
struct _cef_thread_t* self); struct _cef_thread_t* self);
/// ///
// Returns the platform thread ID. It will return the same value after stop() // Returns the platform thread ID. It will return the same value after stop()
// is called. This function is safe to call from any thread. // is called. This function is safe to call from any thread.
/// ///
cef_platform_thread_id_t (CEF_CALLBACK *get_platform_thread_id)( cef_platform_thread_id_t(CEF_CALLBACK* get_platform_thread_id)(
struct _cef_thread_t* self); struct _cef_thread_t* self);
/// ///
@ -82,16 +83,15 @@ typedef struct _cef_thread_t {
// that called cef_thread_create(). Do not call this function if // that called cef_thread_create(). Do not call this function if
// cef_thread_create() was called with a |stoppable| value of false (0). // cef_thread_create() was called with a |stoppable| value of false (0).
/// ///
void (CEF_CALLBACK *stop)(struct _cef_thread_t* self); void(CEF_CALLBACK* stop)(struct _cef_thread_t* self);
/// ///
// Returns true (1) if the thread is currently running. This function must be // Returns true (1) if the thread is currently running. This function must be
// called from the same thread that called cef_thread_create(). // called from the same thread that called cef_thread_create().
/// ///
int (CEF_CALLBACK *is_running)(struct _cef_thread_t* self); int(CEF_CALLBACK* is_running)(struct _cef_thread_t* self);
} cef_thread_t; } cef_thread_t;
/// ///
// Create and start a new thread. This function does not block waiting for the // Create and start a new thread. This function does not block waiting for the
// thread to run initialization. |display_name| is the name that will be used to // thread to run initialization. |display_name| is the name that will be used to
@ -103,10 +103,12 @@ typedef struct _cef_thread_t {
// specifies how COM will be initialized for the thread. If |com_init_mode| is // specifies how COM will be initialized for the thread. If |com_init_mode| is
// set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI. // set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI.
/// ///
CEF_EXPORT cef_thread_t* cef_thread_create(const cef_string_t* display_name, CEF_EXPORT cef_thread_t* cef_thread_create(
cef_thread_priority_t priority, cef_message_loop_type_t message_loop_type, const cef_string_t* display_name,
int stoppable, cef_com_init_mode_t com_init_mode); cef_thread_priority_t priority,
cef_message_loop_type_t message_loop_type,
int stoppable,
cef_com_init_mode_t com_init_mode);
#ifdef __cplusplus #ifdef __cplusplus
} }

6
include/capi/cef_trace_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=2684497985a960a8699e6c24aeb17370cf318e88$
//
#ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Implement this structure to receive notification when tracing has completed. // Implement this structure to receive notification when tracing has completed.
// The functions of this structure will be called on the browser process UI // The functions of this structure will be called on the browser process UI
@ -62,12 +63,11 @@ typedef struct _cef_end_tracing_callback_t {
// the path at which tracing data was written. The client is responsible for // the path at which tracing data was written. The client is responsible for
// deleting |tracing_file|. // deleting |tracing_file|.
/// ///
void (CEF_CALLBACK *on_end_tracing_complete)( void(CEF_CALLBACK* on_end_tracing_complete)(
struct _cef_end_tracing_callback_t* self, struct _cef_end_tracing_callback_t* self,
const cef_string_t* tracing_file); const cef_string_t* tracing_file);
} cef_end_tracing_callback_t; } cef_end_tracing_callback_t;
/// ///
// Start tracing events on all processes. Tracing is initialized asynchronously // Start tracing events on all processes. Tracing is initialized asynchronously
// and |callback| will be executed on the UI thread after initialization is // and |callback| will be executed on the UI thread after initialization is

54
include/capi/cef_urlrequest_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=d0ac53d1df275f9ea9cf19a6a07f8dce88f2b151$
//
#ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
@ -67,26 +69,26 @@ typedef struct _cef_urlrequest_t {
// Returns the request object used to create this URL request. The returned // Returns the request object used to create this URL request. The returned
// object is read-only and should not be modified. // object is read-only and should not be modified.
/// ///
struct _cef_request_t* (CEF_CALLBACK *get_request)( struct _cef_request_t*(CEF_CALLBACK* get_request)(
struct _cef_urlrequest_t* self); struct _cef_urlrequest_t* self);
/// ///
// Returns the client. // Returns the client.
/// ///
struct _cef_urlrequest_client_t* (CEF_CALLBACK *get_client)( struct _cef_urlrequest_client_t*(CEF_CALLBACK* get_client)(
struct _cef_urlrequest_t* self); struct _cef_urlrequest_t* self);
/// ///
// Returns the request status. // Returns the request status.
/// ///
cef_urlrequest_status_t (CEF_CALLBACK *get_request_status)( cef_urlrequest_status_t(CEF_CALLBACK* get_request_status)(
struct _cef_urlrequest_t* self); struct _cef_urlrequest_t* self);
/// ///
// Returns the request error if status is UR_CANCELED or UR_FAILED, or 0 // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
// otherwise. // otherwise.
/// ///
cef_errorcode_t (CEF_CALLBACK *get_request_error)( cef_errorcode_t(CEF_CALLBACK* get_request_error)(
struct _cef_urlrequest_t* self); struct _cef_urlrequest_t* self);
/// ///
@ -94,16 +96,15 @@ typedef struct _cef_urlrequest_t {
// Response information will only be available after the upload has completed. // Response information will only be available after the upload has completed.
// The returned object is read-only and should not be modified. // The returned object is read-only and should not be modified.
/// ///
struct _cef_response_t* (CEF_CALLBACK *get_response)( struct _cef_response_t*(CEF_CALLBACK* get_response)(
struct _cef_urlrequest_t* self); struct _cef_urlrequest_t* self);
/// ///
// Cancel the request. // Cancel the request.
/// ///
void (CEF_CALLBACK *cancel)(struct _cef_urlrequest_t* self); void(CEF_CALLBACK* cancel)(struct _cef_urlrequest_t* self);
} cef_urlrequest_t; } cef_urlrequest_t;
/// ///
// Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request // Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
// functions are supported. Multiple post data elements are not supported and // functions are supported. Multiple post data elements are not supported and
@ -120,10 +121,10 @@ typedef struct _cef_urlrequest_t {
// renderer process' browser will be used. // renderer process' browser will be used.
/// ///
CEF_EXPORT cef_urlrequest_t* cef_urlrequest_create( CEF_EXPORT cef_urlrequest_t* cef_urlrequest_create(
struct _cef_request_t* request, struct _cef_urlrequest_client_t* client, struct _cef_request_t* request,
struct _cef_urlrequest_client_t* client,
struct _cef_request_context_t* request_context); struct _cef_request_context_t* request_context);
/// ///
// Structure that should be implemented by the cef_urlrequest_t client. The // Structure that should be implemented by the cef_urlrequest_t client. The
// functions of this structure will be called on the same thread that created // functions of this structure will be called on the same thread that created
@ -140,8 +141,7 @@ typedef struct _cef_urlrequest_client_t {
// cef_urlrequest_t::GetRequestStatus function to determine if the request was // cef_urlrequest_t::GetRequestStatus function to determine if the request was
// successful or not. // successful or not.
/// ///
void (CEF_CALLBACK *on_request_complete)( void(CEF_CALLBACK* on_request_complete)(struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_t* request); struct _cef_urlrequest_t* request);
/// ///
@ -150,25 +150,30 @@ typedef struct _cef_urlrequest_client_t {
// chunked upload is enabled). This function will only be called if the // chunked upload is enabled). This function will only be called if the
// UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request. // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
/// ///
void (CEF_CALLBACK *on_upload_progress)(struct _cef_urlrequest_client_t* self, void(CEF_CALLBACK* on_upload_progress)(struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_t* request, int64 current, int64 total); struct _cef_urlrequest_t* request,
int64 current,
int64 total);
/// ///
// Notifies the client of download progress. |current| denotes the number of // Notifies the client of download progress. |current| denotes the number of
// bytes received up to the call and |total| is the expected total size of the // bytes received up to the call and |total| is the expected total size of the
// response (or -1 if not determined). // response (or -1 if not determined).
/// ///
void (CEF_CALLBACK *on_download_progress)( void(CEF_CALLBACK* on_download_progress)(
struct _cef_urlrequest_client_t* self, struct _cef_urlrequest_t* request, struct _cef_urlrequest_client_t* self,
int64 current, int64 total); struct _cef_urlrequest_t* request,
int64 current,
int64 total);
/// ///
// Called when some part of the response is read. |data| contains the current // Called when some part of the response is read. |data| contains the current
// bytes received since the last call. This function will not be called if the // bytes received since the last call. This function will not be called if the
// UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request. // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
/// ///
void (CEF_CALLBACK *on_download_data)(struct _cef_urlrequest_client_t* self, void(CEF_CALLBACK* on_download_data)(struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_t* request, const void* data, struct _cef_urlrequest_t* request,
const void* data,
size_t data_length); size_t data_length);
/// ///
@ -180,13 +185,16 @@ typedef struct _cef_urlrequest_client_t {
// function will only be called for requests initiated from the browser // function will only be called for requests initiated from the browser
// process. // process.
/// ///
int (CEF_CALLBACK *get_auth_credentials)( int(CEF_CALLBACK* get_auth_credentials)(
struct _cef_urlrequest_client_t* self, int isProxy, struct _cef_urlrequest_client_t* self,
const cef_string_t* host, int port, const cef_string_t* realm, int isProxy,
const cef_string_t* scheme, struct _cef_auth_callback_t* callback); const cef_string_t* host,
int port,
const cef_string_t* realm,
const cef_string_t* scheme,
struct _cef_auth_callback_t* callback);
} cef_urlrequest_client_t; } cef_urlrequest_client_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

257
include/capi/cef_v8_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=aecaacd4f1b5294258f4e78883bcfec0a5c5677f$
//
#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
@ -70,7 +72,7 @@ typedef struct _cef_v8context_t {
// be accessed from the thread on which they are created. This function can be // be accessed from the thread on which they are created. This function can be
// called on any render process thread. // called on any render process thread.
/// ///
struct _cef_task_runner_t* (CEF_CALLBACK *get_task_runner)( struct _cef_task_runner_t*(CEF_CALLBACK* get_task_runner)(
struct _cef_v8context_t* self); struct _cef_v8context_t* self);
/// ///
@ -78,26 +80,26 @@ typedef struct _cef_v8context_t {
// on the current thread. Do not call any other functions if this function // on the current thread. Do not call any other functions if this function
// returns false (0). // returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_v8context_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_v8context_t* self);
/// ///
// Returns the browser for this context. This function will return an NULL // Returns the browser for this context. This function will return an NULL
// reference for WebWorker contexts. // reference for WebWorker contexts.
/// ///
struct _cef_browser_t* (CEF_CALLBACK *get_browser)( struct _cef_browser_t*(CEF_CALLBACK* get_browser)(
struct _cef_v8context_t* self); struct _cef_v8context_t* self);
/// ///
// Returns the frame for this context. This function will return an NULL // Returns the frame for this context. This function will return an NULL
// reference for WebWorker contexts. // reference for WebWorker contexts.
/// ///
struct _cef_frame_t* (CEF_CALLBACK *get_frame)(struct _cef_v8context_t* self); struct _cef_frame_t*(CEF_CALLBACK* get_frame)(struct _cef_v8context_t* self);
/// ///
// Returns the global object for this context. The context must be entered // Returns the global object for this context. The context must be entered
// before calling this function. // before calling this function.
/// ///
struct _cef_v8value_t* (CEF_CALLBACK *get_global)( struct _cef_v8value_t*(CEF_CALLBACK* get_global)(
struct _cef_v8context_t* self); struct _cef_v8context_t* self);
/// ///
@ -107,19 +109,19 @@ typedef struct _cef_v8context_t {
// objects belong to the context in which they are created. Returns true (1) // objects belong to the context in which they are created. Returns true (1)
// if the scope was entered successfully. // if the scope was entered successfully.
/// ///
int (CEF_CALLBACK *enter)(struct _cef_v8context_t* self); int(CEF_CALLBACK* enter)(struct _cef_v8context_t* self);
/// ///
// Exit this context. Call this function only after calling enter(). Returns // Exit this context. Call this function only after calling enter(). Returns
// true (1) if the scope was exited successfully. // true (1) if the scope was exited successfully.
/// ///
int (CEF_CALLBACK *exit)(struct _cef_v8context_t* self); int(CEF_CALLBACK* exit)(struct _cef_v8context_t* self);
/// ///
// Returns true (1) if this object is pointing to the same handle as |that| // Returns true (1) if this object is pointing to the same handle as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_v8context_t* self, int(CEF_CALLBACK* is_same)(struct _cef_v8context_t* self,
struct _cef_v8context_t* that); struct _cef_v8context_t* that);
/// ///
@ -130,12 +132,14 @@ typedef struct _cef_v8context_t {
// function will return true (1). On failure |exception| will be set to the // function will return true (1). On failure |exception| will be set to the
// exception, if any, and the function will return false (0). // exception, if any, and the function will return false (0).
/// ///
int (CEF_CALLBACK *eval)(struct _cef_v8context_t* self, int(CEF_CALLBACK* eval)(struct _cef_v8context_t* self,
const cef_string_t* code, const cef_string_t* script_url, int start_line, const cef_string_t* code,
struct _cef_v8value_t** retval, struct _cef_v8exception_t** exception); const cef_string_t* script_url,
int start_line,
struct _cef_v8value_t** retval,
struct _cef_v8exception_t** exception);
} cef_v8context_t; } cef_v8context_t;
/// ///
// Returns the current (top) context object in the V8 context stack. // Returns the current (top) context object in the V8 context stack.
/// ///
@ -151,7 +155,6 @@ CEF_EXPORT cef_v8context_t* cef_v8context_get_entered_context();
/// ///
CEF_EXPORT int cef_v8context_in_context(); CEF_EXPORT int cef_v8context_in_context();
/// ///
// Structure that should be implemented to handle V8 function calls. The // Structure that should be implemented to handle V8 function calls. The
// functions of this structure will be called on the thread associated with the // functions of this structure will be called on the thread associated with the
@ -170,13 +173,15 @@ typedef struct _cef_v8handler_t {
// function return value. If execution fails set |exception| to the exception // function return value. If execution fails set |exception| to the exception
// that will be thrown. Return true (1) if execution was handled. // that will be thrown. Return true (1) if execution was handled.
/// ///
int (CEF_CALLBACK *execute)(struct _cef_v8handler_t* self, int(CEF_CALLBACK* execute)(struct _cef_v8handler_t* self,
const cef_string_t* name, struct _cef_v8value_t* object, const cef_string_t* name,
size_t argumentsCount, struct _cef_v8value_t* const* arguments, struct _cef_v8value_t* object,
struct _cef_v8value_t** retval, cef_string_t* exception); size_t argumentsCount,
struct _cef_v8value_t* const* arguments,
struct _cef_v8value_t** retval,
cef_string_t* exception);
} cef_v8handler_t; } cef_v8handler_t;
/// ///
// Structure that should be implemented to handle V8 accessor calls. Accessor // Structure that should be implemented to handle V8 accessor calls. Accessor
// identifiers are registered by calling cef_v8value_t::set_value(). The // identifiers are registered by calling cef_v8value_t::set_value(). The
@ -196,9 +201,11 @@ typedef struct _cef_v8accessor_t {
// exception that will be thrown. Return true (1) if accessor retrieval was // exception that will be thrown. Return true (1) if accessor retrieval was
// handled. // handled.
/// ///
int (CEF_CALLBACK *get)(struct _cef_v8accessor_t* self, int(CEF_CALLBACK* get)(struct _cef_v8accessor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object, const cef_string_t* name,
struct _cef_v8value_t** retval, cef_string_t* exception); struct _cef_v8value_t* object,
struct _cef_v8value_t** retval,
cef_string_t* exception);
/// ///
// Handle assignment of the accessor value identified by |name|. |object| is // Handle assignment of the accessor value identified by |name|. |object| is
@ -207,12 +214,13 @@ typedef struct _cef_v8accessor_t {
// exception that will be thrown. Return true (1) if accessor assignment was // exception that will be thrown. Return true (1) if accessor assignment was
// handled. // handled.
/// ///
int (CEF_CALLBACK *set)(struct _cef_v8accessor_t* self, int(CEF_CALLBACK* set)(struct _cef_v8accessor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object, const cef_string_t* name,
struct _cef_v8value_t* value, cef_string_t* exception); struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception);
} cef_v8accessor_t; } cef_v8accessor_t;
/// ///
// Structure that should be implemented to handle V8 interceptor calls. The // Structure that should be implemented to handle V8 interceptor calls. The
// functions of this structure will be called on the thread associated with the // functions of this structure will be called on the thread associated with the
@ -236,9 +244,11 @@ typedef struct _cef_v8interceptor_t {
// accessor, it will be called only if you don't set |retval|. Return true (1) // accessor, it will be called only if you don't set |retval|. Return true (1)
// if interceptor retrieval was handled, false (0) otherwise. // if interceptor retrieval was handled, false (0) otherwise.
/// ///
int (CEF_CALLBACK *get_byname)(struct _cef_v8interceptor_t* self, int(CEF_CALLBACK* get_byname)(struct _cef_v8interceptor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object, const cef_string_t* name,
struct _cef_v8value_t** retval, cef_string_t* exception); struct _cef_v8value_t* object,
struct _cef_v8value_t** retval,
cef_string_t* exception);
/// ///
// Handle retrieval of the interceptor value identified by |index|. |object| // Handle retrieval of the interceptor value identified by |index|. |object|
@ -248,8 +258,10 @@ typedef struct _cef_v8interceptor_t {
// |exception| to the exception that will be thrown. Return true (1) if // |exception| to the exception that will be thrown. Return true (1) if
// interceptor retrieval was handled, false (0) otherwise. // interceptor retrieval was handled, false (0) otherwise.
/// ///
int (CEF_CALLBACK *get_byindex)(struct _cef_v8interceptor_t* self, int index, int(CEF_CALLBACK* get_byindex)(struct _cef_v8interceptor_t* self,
struct _cef_v8value_t* object, struct _cef_v8value_t** retval, int index,
struct _cef_v8value_t* object,
struct _cef_v8value_t** retval,
cef_string_t* exception); cef_string_t* exception);
/// ///
@ -260,9 +272,11 @@ typedef struct _cef_v8interceptor_t {
// be called, even when the property has an associated accessor. Return true // be called, even when the property has an associated accessor. Return true
// (1) if interceptor assignment was handled, false (0) otherwise. // (1) if interceptor assignment was handled, false (0) otherwise.
/// ///
int (CEF_CALLBACK *set_byname)(struct _cef_v8interceptor_t* self, int(CEF_CALLBACK* set_byname)(struct _cef_v8interceptor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object, const cef_string_t* name,
struct _cef_v8value_t* value, cef_string_t* exception); struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception);
/// ///
// Handle assignment of the interceptor value identified by |index|. |object| // Handle assignment of the interceptor value identified by |index|. |object|
@ -271,12 +285,13 @@ typedef struct _cef_v8interceptor_t {
// |exception| to the exception that will be thrown. Return true (1) if // |exception| to the exception that will be thrown. Return true (1) if
// interceptor assignment was handled, false (0) otherwise. // interceptor assignment was handled, false (0) otherwise.
/// ///
int (CEF_CALLBACK *set_byindex)(struct _cef_v8interceptor_t* self, int index, int(CEF_CALLBACK* set_byindex)(struct _cef_v8interceptor_t* self,
struct _cef_v8value_t* object, struct _cef_v8value_t* value, int index,
struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception); cef_string_t* exception);
} cef_v8interceptor_t; } cef_v8interceptor_t;
/// ///
// Structure representing a V8 exception. The functions of this structure may be // Structure representing a V8 exception. The functions of this structure may be
// called on any render process thread. // called on any render process thread.
@ -291,14 +306,14 @@ typedef struct _cef_v8exception_t {
// Returns the exception message. // Returns the exception message.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_message)( cef_string_userfree_t(CEF_CALLBACK* get_message)(
struct _cef_v8exception_t* self); struct _cef_v8exception_t* self);
/// ///
// Returns the line of source code that the exception occurred within. // Returns the line of source code that the exception occurred within.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_source_line)( cef_string_userfree_t(CEF_CALLBACK* get_source_line)(
struct _cef_v8exception_t* self); struct _cef_v8exception_t* self);
/// ///
@ -306,41 +321,40 @@ typedef struct _cef_v8exception_t {
// the error originates. // the error originates.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_script_resource_name)( cef_string_userfree_t(CEF_CALLBACK* get_script_resource_name)(
struct _cef_v8exception_t* self); struct _cef_v8exception_t* self);
/// ///
// Returns the 1-based number of the line where the error occurred or 0 if the // Returns the 1-based number of the line where the error occurred or 0 if the
// line number is unknown. // line number is unknown.
/// ///
int (CEF_CALLBACK *get_line_number)(struct _cef_v8exception_t* self); int(CEF_CALLBACK* get_line_number)(struct _cef_v8exception_t* self);
/// ///
// Returns the index within the script of the first character where the error // Returns the index within the script of the first character where the error
// occurred. // occurred.
/// ///
int (CEF_CALLBACK *get_start_position)(struct _cef_v8exception_t* self); int(CEF_CALLBACK* get_start_position)(struct _cef_v8exception_t* self);
/// ///
// Returns the index within the script of the last character where the error // Returns the index within the script of the last character where the error
// occurred. // occurred.
/// ///
int (CEF_CALLBACK *get_end_position)(struct _cef_v8exception_t* self); int(CEF_CALLBACK* get_end_position)(struct _cef_v8exception_t* self);
/// ///
// Returns the index within the line of the first character where the error // Returns the index within the line of the first character where the error
// occurred. // occurred.
/// ///
int (CEF_CALLBACK *get_start_column)(struct _cef_v8exception_t* self); int(CEF_CALLBACK* get_start_column)(struct _cef_v8exception_t* self);
/// ///
// Returns the index within the line of the last character where the error // Returns the index within the line of the last character where the error
// occurred. // occurred.
/// ///
int (CEF_CALLBACK *get_end_column)(struct _cef_v8exception_t* self); int(CEF_CALLBACK* get_end_column)(struct _cef_v8exception_t* self);
} cef_v8exception_t; } cef_v8exception_t;
/// ///
// Structure representing a V8 value handle. V8 handles can only be accessed // Structure representing a V8 value handle. V8 handles can only be accessed
// from the thread on which they are created. Valid threads for creating a V8 // from the thread on which they are created. Valid threads for creating a V8
@ -359,103 +373,102 @@ typedef struct _cef_v8value_t {
// on the current thread. Do not call any other functions if this function // on the current thread. Do not call any other functions if this function
// returns false (0). // returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_v8value_t* self);
/// ///
// True if the value type is undefined. // True if the value type is undefined.
/// ///
int (CEF_CALLBACK *is_undefined)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_undefined)(struct _cef_v8value_t* self);
/// ///
// True if the value type is null. // True if the value type is null.
/// ///
int (CEF_CALLBACK *is_null)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_null)(struct _cef_v8value_t* self);
/// ///
// True if the value type is bool. // True if the value type is bool.
/// ///
int (CEF_CALLBACK *is_bool)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_bool)(struct _cef_v8value_t* self);
/// ///
// True if the value type is int. // True if the value type is int.
/// ///
int (CEF_CALLBACK *is_int)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_int)(struct _cef_v8value_t* self);
/// ///
// True if the value type is unsigned int. // True if the value type is unsigned int.
/// ///
int (CEF_CALLBACK *is_uint)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_uint)(struct _cef_v8value_t* self);
/// ///
// True if the value type is double. // True if the value type is double.
/// ///
int (CEF_CALLBACK *is_double)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_double)(struct _cef_v8value_t* self);
/// ///
// True if the value type is Date. // True if the value type is Date.
/// ///
int (CEF_CALLBACK *is_date)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_date)(struct _cef_v8value_t* self);
/// ///
// True if the value type is string. // True if the value type is string.
/// ///
int (CEF_CALLBACK *is_string)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_string)(struct _cef_v8value_t* self);
/// ///
// True if the value type is object. // True if the value type is object.
/// ///
int (CEF_CALLBACK *is_object)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_object)(struct _cef_v8value_t* self);
/// ///
// True if the value type is array. // True if the value type is array.
/// ///
int (CEF_CALLBACK *is_array)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_array)(struct _cef_v8value_t* self);
/// ///
// True if the value type is function. // True if the value type is function.
/// ///
int (CEF_CALLBACK *is_function)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_function)(struct _cef_v8value_t* self);
/// ///
// Returns true (1) if this object is pointing to the same handle as |that| // Returns true (1) if this object is pointing to the same handle as |that|
// object. // object.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_v8value_t* self, int(CEF_CALLBACK* is_same)(struct _cef_v8value_t* self,
struct _cef_v8value_t* that); struct _cef_v8value_t* that);
/// ///
// Return a bool value. // Return a bool value.
/// ///
int (CEF_CALLBACK *get_bool_value)(struct _cef_v8value_t* self); int(CEF_CALLBACK* get_bool_value)(struct _cef_v8value_t* self);
/// ///
// Return an int value. // Return an int value.
/// ///
int32 (CEF_CALLBACK *get_int_value)(struct _cef_v8value_t* self); int32(CEF_CALLBACK* get_int_value)(struct _cef_v8value_t* self);
/// ///
// Return an unsigned int value. // Return an unsigned int value.
/// ///
uint32 (CEF_CALLBACK *get_uint_value)(struct _cef_v8value_t* self); uint32(CEF_CALLBACK* get_uint_value)(struct _cef_v8value_t* self);
/// ///
// Return a double value. // Return a double value.
/// ///
double (CEF_CALLBACK *get_double_value)(struct _cef_v8value_t* self); double(CEF_CALLBACK* get_double_value)(struct _cef_v8value_t* self);
/// ///
// Return a Date value. // Return a Date value.
/// ///
cef_time_t (CEF_CALLBACK *get_date_value)(struct _cef_v8value_t* self); cef_time_t(CEF_CALLBACK* get_date_value)(struct _cef_v8value_t* self);
/// ///
// Return a string value. // Return a string value.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string_value)( cef_string_userfree_t(CEF_CALLBACK* get_string_value)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
// OBJECT METHODS - These functions are only available on objects. Arrays and // OBJECT METHODS - These functions are only available on objects. Arrays and
// functions are also objects. String- and integer-based keys can be used // functions are also objects. String- and integer-based keys can be used
// interchangably with the framework converting between them as necessary. // interchangably with the framework converting between them as necessary.
@ -463,31 +476,31 @@ typedef struct _cef_v8value_t {
/// ///
// Returns true (1) if this is a user created object. // Returns true (1) if this is a user created object.
/// ///
int (CEF_CALLBACK *is_user_created)(struct _cef_v8value_t* self); int(CEF_CALLBACK* is_user_created)(struct _cef_v8value_t* self);
/// ///
// Returns true (1) if the last function call resulted in an exception. This // Returns true (1) if the last function call resulted in an exception. This
// attribute exists only in the scope of the current CEF value object. // attribute exists only in the scope of the current CEF value object.
/// ///
int (CEF_CALLBACK *has_exception)(struct _cef_v8value_t* self); int(CEF_CALLBACK* has_exception)(struct _cef_v8value_t* self);
/// ///
// Returns the exception resulting from the last function call. This attribute // Returns the exception resulting from the last function call. This attribute
// exists only in the scope of the current CEF value object. // exists only in the scope of the current CEF value object.
/// ///
struct _cef_v8exception_t* (CEF_CALLBACK *get_exception)( struct _cef_v8exception_t*(CEF_CALLBACK* get_exception)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
/// ///
// Clears the last exception and returns true (1) on success. // Clears the last exception and returns true (1) on success.
/// ///
int (CEF_CALLBACK *clear_exception)(struct _cef_v8value_t* self); int(CEF_CALLBACK* clear_exception)(struct _cef_v8value_t* self);
/// ///
// Returns true (1) if this object will re-throw future exceptions. This // Returns true (1) if this object will re-throw future exceptions. This
// attribute exists only in the scope of the current CEF value object. // attribute exists only in the scope of the current CEF value object.
/// ///
int (CEF_CALLBACK *will_rethrow_exceptions)(struct _cef_v8value_t* self); int(CEF_CALLBACK* will_rethrow_exceptions)(struct _cef_v8value_t* self);
/// ///
// Set whether this object will re-throw future exceptions. By default // Set whether this object will re-throw future exceptions. By default
@ -496,19 +509,19 @@ typedef struct _cef_v8value_t {
// caught and not re-thrown. Returns true (1) on success. This attribute // caught and not re-thrown. Returns true (1) on success. This attribute
// exists only in the scope of the current CEF value object. // exists only in the scope of the current CEF value object.
/// ///
int (CEF_CALLBACK *set_rethrow_exceptions)(struct _cef_v8value_t* self, int(CEF_CALLBACK* set_rethrow_exceptions)(struct _cef_v8value_t* self,
int rethrow); int rethrow);
/// ///
// Returns true (1) if the object has a value with the specified identifier. // Returns true (1) if the object has a value with the specified identifier.
/// ///
int (CEF_CALLBACK *has_value_bykey)(struct _cef_v8value_t* self, int(CEF_CALLBACK* has_value_bykey)(struct _cef_v8value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns true (1) if the object has a value with the specified identifier. // Returns true (1) if the object has a value with the specified identifier.
/// ///
int (CEF_CALLBACK *has_value_byindex)(struct _cef_v8value_t* self, int index); int(CEF_CALLBACK* has_value_byindex)(struct _cef_v8value_t* self, int index);
/// ///
// Deletes the value with the specified identifier and returns true (1) on // Deletes the value with the specified identifier and returns true (1) on
@ -516,7 +529,7 @@ typedef struct _cef_v8value_t {
// exception is thrown. For read-only and don't-delete values this function // exception is thrown. For read-only and don't-delete values this function
// will return true (1) even though deletion failed. // will return true (1) even though deletion failed.
/// ///
int (CEF_CALLBACK *delete_value_bykey)(struct _cef_v8value_t* self, int(CEF_CALLBACK* delete_value_bykey)(struct _cef_v8value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
@ -525,22 +538,23 @@ typedef struct _cef_v8value_t {
// fails or an exception is thrown. For read-only and don't-delete values this // fails or an exception is thrown. For read-only and don't-delete values this
// function will return true (1) even though deletion failed. // function will return true (1) even though deletion failed.
/// ///
int (CEF_CALLBACK *delete_value_byindex)(struct _cef_v8value_t* self, int(CEF_CALLBACK* delete_value_byindex)(struct _cef_v8value_t* self,
int index); int index);
/// ///
// Returns the value with the specified identifier on success. Returns NULL if // Returns the value with the specified identifier on success. Returns NULL if
// this function is called incorrectly or an exception is thrown. // this function is called incorrectly or an exception is thrown.
/// ///
struct _cef_v8value_t* (CEF_CALLBACK *get_value_bykey)( struct _cef_v8value_t*(CEF_CALLBACK* get_value_bykey)(
struct _cef_v8value_t* self, const cef_string_t* key); struct _cef_v8value_t* self,
const cef_string_t* key);
/// ///
// Returns the value with the specified identifier on success. Returns NULL if // Returns the value with the specified identifier on success. Returns NULL if
// this function is called incorrectly or an exception is thrown. // this function is called incorrectly or an exception is thrown.
/// ///
struct _cef_v8value_t* (CEF_CALLBACK *get_value_byindex)( struct _cef_v8value_t*(
struct _cef_v8value_t* self, int index); CEF_CALLBACK* get_value_byindex)(struct _cef_v8value_t* self, int index);
/// ///
// Associates a value with the specified identifier and returns true (1) on // Associates a value with the specified identifier and returns true (1) on
@ -548,8 +562,9 @@ typedef struct _cef_v8value_t {
// exception is thrown. For read-only values this function will return true // exception is thrown. For read-only values this function will return true
// (1) even though assignment failed. // (1) even though assignment failed.
/// ///
int (CEF_CALLBACK *set_value_bykey)(struct _cef_v8value_t* self, int(CEF_CALLBACK* set_value_bykey)(struct _cef_v8value_t* self,
const cef_string_t* key, struct _cef_v8value_t* value, const cef_string_t* key,
struct _cef_v8value_t* value,
cef_v8_propertyattribute_t attribute); cef_v8_propertyattribute_t attribute);
/// ///
@ -558,7 +573,8 @@ typedef struct _cef_v8value_t {
// exception is thrown. For read-only values this function will return true // exception is thrown. For read-only values this function will return true
// (1) even though assignment failed. // (1) even though assignment failed.
/// ///
int (CEF_CALLBACK *set_value_byindex)(struct _cef_v8value_t* self, int index, int(CEF_CALLBACK* set_value_byindex)(struct _cef_v8value_t* self,
int index,
struct _cef_v8value_t* value); struct _cef_v8value_t* value);
/// ///
@ -568,15 +584,16 @@ typedef struct _cef_v8value_t {
// function is called incorrectly or an exception is thrown. For read-only // function is called incorrectly or an exception is thrown. For read-only
// values this function will return true (1) even though assignment failed. // values this function will return true (1) even though assignment failed.
/// ///
int (CEF_CALLBACK *set_value_byaccessor)(struct _cef_v8value_t* self, int(CEF_CALLBACK* set_value_byaccessor)(struct _cef_v8value_t* self,
const cef_string_t* key, cef_v8_accesscontrol_t settings, const cef_string_t* key,
cef_v8_accesscontrol_t settings,
cef_v8_propertyattribute_t attribute); cef_v8_propertyattribute_t attribute);
/// ///
// Read the keys for the object's values into the specified vector. Integer- // Read the keys for the object's values into the specified vector. Integer-
// based keys will also be returned as strings. // based keys will also be returned as strings.
/// ///
int (CEF_CALLBACK *get_keys)(struct _cef_v8value_t* self, int(CEF_CALLBACK* get_keys)(struct _cef_v8value_t* self,
cef_string_list_t keys); cef_string_list_t keys);
/// ///
@ -584,20 +601,20 @@ typedef struct _cef_v8value_t {
// false (0) if this function is called incorrectly. This function can only be // false (0) if this function is called incorrectly. This function can only be
// called on user created objects. // called on user created objects.
/// ///
int (CEF_CALLBACK *set_user_data)(struct _cef_v8value_t* self, int(CEF_CALLBACK* set_user_data)(struct _cef_v8value_t* self,
struct _cef_base_ref_counted_t* user_data); struct _cef_base_ref_counted_t* user_data);
/// ///
// Returns the user data, if any, assigned to this object. // Returns the user data, if any, assigned to this object.
/// ///
struct _cef_base_ref_counted_t* (CEF_CALLBACK *get_user_data)( struct _cef_base_ref_counted_t*(CEF_CALLBACK* get_user_data)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
/// ///
// Returns the amount of externally allocated memory registered for the // Returns the amount of externally allocated memory registered for the
// object. // object.
/// ///
int (CEF_CALLBACK *get_externally_allocated_memory)( int(CEF_CALLBACK* get_externally_allocated_memory)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
/// ///
@ -611,17 +628,16 @@ typedef struct _cef_v8value_t {
// returns the number of bytes associated with the object after the // returns the number of bytes associated with the object after the
// adjustment. This function can only be called on user created objects. // adjustment. This function can only be called on user created objects.
/// ///
int (CEF_CALLBACK *adjust_externally_allocated_memory)( int(CEF_CALLBACK* adjust_externally_allocated_memory)(
struct _cef_v8value_t* self, int change_in_bytes); struct _cef_v8value_t* self,
int change_in_bytes);
// ARRAY METHODS - These functions are only available on arrays. // ARRAY METHODS - These functions are only available on arrays.
/// ///
// Returns the number of elements in the array. // Returns the number of elements in the array.
/// ///
int (CEF_CALLBACK *get_array_length)(struct _cef_v8value_t* self); int(CEF_CALLBACK* get_array_length)(struct _cef_v8value_t* self);
// FUNCTION METHODS - These functions are only available on functions. // FUNCTION METHODS - These functions are only available on functions.
@ -629,13 +645,13 @@ typedef struct _cef_v8value_t {
// Returns the function name. // Returns the function name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_function_name)( cef_string_userfree_t(CEF_CALLBACK* get_function_name)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
/// ///
// Returns the function handler or NULL if not a CEF-created function. // Returns the function handler or NULL if not a CEF-created function.
/// ///
struct _cef_v8handler_t* (CEF_CALLBACK *get_function_handler)( struct _cef_v8handler_t*(CEF_CALLBACK* get_function_handler)(
struct _cef_v8value_t* self); struct _cef_v8value_t* self);
/// ///
@ -649,9 +665,11 @@ typedef struct _cef_v8value_t {
// Returns NULL if this function is called incorrectly or an exception is // Returns NULL if this function is called incorrectly or an exception is
// thrown. // thrown.
/// ///
struct _cef_v8value_t* (CEF_CALLBACK *execute_function)( struct _cef_v8value_t*(CEF_CALLBACK* execute_function)(
struct _cef_v8value_t* self, struct _cef_v8value_t* object, struct _cef_v8value_t* self,
size_t argumentsCount, struct _cef_v8value_t* const* arguments); struct _cef_v8value_t* object,
size_t argumentsCount,
struct _cef_v8value_t* const* arguments);
/// ///
// Execute the function using the specified V8 context. |object| is the // Execute the function using the specified V8 context. |object| is the
@ -661,13 +679,14 @@ typedef struct _cef_v8value_t {
// success. Returns NULL if this function is called incorrectly or an // success. Returns NULL if this function is called incorrectly or an
// exception is thrown. // exception is thrown.
/// ///
struct _cef_v8value_t* (CEF_CALLBACK *execute_function_with_context)( struct _cef_v8value_t*(CEF_CALLBACK* execute_function_with_context)(
struct _cef_v8value_t* self, struct _cef_v8context_t* context, struct _cef_v8value_t* self,
struct _cef_v8value_t* object, size_t argumentsCount, struct _cef_v8context_t* context,
struct _cef_v8value_t* object,
size_t argumentsCount,
struct _cef_v8value_t* const* arguments); struct _cef_v8value_t* const* arguments);
} cef_v8value_t; } cef_v8value_t;
/// ///
// Create a new cef_v8value_t object of type undefined. // Create a new cef_v8value_t object of type undefined.
/// ///
@ -718,7 +737,8 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value);
// callback, or in combination with calling enter() and exit() on a stored // callback, or in combination with calling enter() and exit() on a stored
// cef_v8context_t reference. // cef_v8context_t reference.
/// ///
CEF_EXPORT cef_v8value_t* cef_v8value_create_object(cef_v8accessor_t* accessor, CEF_EXPORT cef_v8value_t* cef_v8value_create_object(
cef_v8accessor_t* accessor,
cef_v8interceptor_t* interceptor); cef_v8interceptor_t* interceptor);
/// ///
@ -740,7 +760,6 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_array(int length);
CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name, CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name,
cef_v8handler_t* handler); cef_v8handler_t* handler);
/// ///
// Structure representing a V8 stack trace handle. V8 handles can only be // Structure representing a V8 stack trace handle. V8 handles can only be
// accessed from the thread on which they are created. Valid threads for // accessed from the thread on which they are created. Valid threads for
@ -759,28 +778,26 @@ typedef struct _cef_v8stack_trace_t {
// on the current thread. Do not call any other functions if this function // on the current thread. Do not call any other functions if this function
// returns false (0). // returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_trace_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_v8stack_trace_t* self);
/// ///
// Returns the number of stack frames. // Returns the number of stack frames.
/// ///
int (CEF_CALLBACK *get_frame_count)(struct _cef_v8stack_trace_t* self); int(CEF_CALLBACK* get_frame_count)(struct _cef_v8stack_trace_t* self);
/// ///
// Returns the stack frame at the specified 0-based index. // Returns the stack frame at the specified 0-based index.
/// ///
struct _cef_v8stack_frame_t* (CEF_CALLBACK *get_frame)( struct _cef_v8stack_frame_t*(
struct _cef_v8stack_trace_t* self, int index); CEF_CALLBACK* get_frame)(struct _cef_v8stack_trace_t* self, int index);
} cef_v8stack_trace_t; } cef_v8stack_trace_t;
/// ///
// Returns the stack trace for the currently active context. |frame_limit| is // Returns the stack trace for the currently active context. |frame_limit| is
// the maximum number of frames that will be captured. // the maximum number of frames that will be captured.
/// ///
CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit); CEF_EXPORT cef_v8stack_trace_t* cef_v8stack_trace_get_current(int frame_limit);
/// ///
// Structure representing a V8 stack frame handle. V8 handles can only be // Structure representing a V8 stack frame handle. V8 handles can only be
// accessed from the thread on which they are created. Valid threads for // accessed from the thread on which they are created. Valid threads for
@ -799,13 +816,13 @@ typedef struct _cef_v8stack_frame_t {
// on the current thread. Do not call any other functions if this function // on the current thread. Do not call any other functions if this function
// returns false (0). // returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_v8stack_frame_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_v8stack_frame_t* self);
/// ///
// Returns the name of the resource script that contains the function. // Returns the name of the resource script that contains the function.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_script_name)( cef_string_userfree_t(CEF_CALLBACK* get_script_name)(
struct _cef_v8stack_frame_t* self); struct _cef_v8stack_frame_t* self);
/// ///
@ -814,39 +831,38 @@ typedef struct _cef_v8stack_frame_t {
// "//@ sourceURL=..." string. // "//@ sourceURL=..." string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_script_name_or_source_url)( cef_string_userfree_t(CEF_CALLBACK* get_script_name_or_source_url)(
struct _cef_v8stack_frame_t* self); struct _cef_v8stack_frame_t* self);
/// ///
// Returns the name of the function. // Returns the name of the function.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_function_name)( cef_string_userfree_t(CEF_CALLBACK* get_function_name)(
struct _cef_v8stack_frame_t* self); struct _cef_v8stack_frame_t* self);
/// ///
// Returns the 1-based line number for the function call or 0 if unknown. // Returns the 1-based line number for the function call or 0 if unknown.
/// ///
int (CEF_CALLBACK *get_line_number)(struct _cef_v8stack_frame_t* self); int(CEF_CALLBACK* get_line_number)(struct _cef_v8stack_frame_t* self);
/// ///
// Returns the 1-based column offset on the line for the function call or 0 if // Returns the 1-based column offset on the line for the function call or 0 if
// unknown. // unknown.
/// ///
int (CEF_CALLBACK *get_column)(struct _cef_v8stack_frame_t* self); int(CEF_CALLBACK* get_column)(struct _cef_v8stack_frame_t* self);
/// ///
// Returns true (1) if the function was compiled using eval(). // Returns true (1) if the function was compiled using eval().
/// ///
int (CEF_CALLBACK *is_eval)(struct _cef_v8stack_frame_t* self); int(CEF_CALLBACK* is_eval)(struct _cef_v8stack_frame_t* self);
/// ///
// Returns true (1) if the function was called as a constructor via "new". // Returns true (1) if the function was called as a constructor via "new".
/// ///
int (CEF_CALLBACK *is_constructor)(struct _cef_v8stack_frame_t* self); int(CEF_CALLBACK* is_constructor)(struct _cef_v8stack_frame_t* self);
} cef_v8stack_frame_t; } cef_v8stack_frame_t;
/// ///
// Register a new V8 extension with the specified JavaScript extension code and // Register a new V8 extension with the specified JavaScript extension code and
// handler. Functions implemented by the handler are prototyped using the // handler. Functions implemented by the handler are prototyped using the
@ -904,7 +920,8 @@ typedef struct _cef_v8stack_frame_t {
// </pre> // </pre>
/// ///
CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name, CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name,
const cef_string_t* javascript_code, cef_v8handler_t* handler); const cef_string_t* javascript_code,
cef_v8handler_t* handler);
#ifdef __cplusplus #ifdef __cplusplus
} }

250
include/capi/cef_values_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=4119ecd62e8c308a5876e6a7ac92cf3ff7df6425$
//
#ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
@ -67,64 +69,64 @@ typedef struct _cef_value_t {
// object can be re-used by calling Set*() even if the underlying data is // object can be re-used by calling Set*() even if the underlying data is
// invalid. // invalid.
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_value_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_value_t* self);
/// ///
// Returns true (1) if the underlying data is owned by another object. // Returns true (1) if the underlying data is owned by another object.
/// ///
int (CEF_CALLBACK *is_owned)(struct _cef_value_t* self); int(CEF_CALLBACK* is_owned)(struct _cef_value_t* self);
/// ///
// Returns true (1) if the underlying data is read-only. Some APIs may expose // Returns true (1) if the underlying data is read-only. Some APIs may expose
// read-only objects. // read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_value_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_value_t* self);
/// ///
// Returns true (1) if this object and |that| object have the same underlying // Returns true (1) if this object and |that| object have the same underlying
// data. If true (1) modifications to this object will also affect |that| // data. If true (1) modifications to this object will also affect |that|
// object and vice-versa. // object and vice-versa.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_value_t* self, int(CEF_CALLBACK* is_same)(struct _cef_value_t* self,
struct _cef_value_t* that); struct _cef_value_t* that);
/// ///
// Returns true (1) if this object and |that| object have an equivalent // Returns true (1) if this object and |that| object have an equivalent
// underlying value but are not necessarily the same object. // underlying value but are not necessarily the same object.
/// ///
int (CEF_CALLBACK *is_equal)(struct _cef_value_t* self, int(CEF_CALLBACK* is_equal)(struct _cef_value_t* self,
struct _cef_value_t* that); struct _cef_value_t* that);
/// ///
// Returns a copy of this object. The underlying data will also be copied. // Returns a copy of this object. The underlying data will also be copied.
/// ///
struct _cef_value_t* (CEF_CALLBACK *copy)(struct _cef_value_t* self); struct _cef_value_t*(CEF_CALLBACK* copy)(struct _cef_value_t* self);
/// ///
// Returns the underlying value type. // Returns the underlying value type.
/// ///
cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_value_t* self); cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_value_t* self);
/// ///
// Returns the underlying value as type bool. // Returns the underlying value as type bool.
/// ///
int (CEF_CALLBACK *get_bool)(struct _cef_value_t* self); int(CEF_CALLBACK* get_bool)(struct _cef_value_t* self);
/// ///
// Returns the underlying value as type int. // Returns the underlying value as type int.
/// ///
int (CEF_CALLBACK *get_int)(struct _cef_value_t* self); int(CEF_CALLBACK* get_int)(struct _cef_value_t* self);
/// ///
// Returns the underlying value as type double. // Returns the underlying value as type double.
/// ///
double (CEF_CALLBACK *get_double)(struct _cef_value_t* self); double(CEF_CALLBACK* get_double)(struct _cef_value_t* self);
/// ///
// Returns the underlying value as type string. // Returns the underlying value as type string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)(struct _cef_value_t* self); cef_string_userfree_t(CEF_CALLBACK* get_string)(struct _cef_value_t* self);
/// ///
// Returns the underlying value as type binary. The returned reference may // Returns the underlying value as type binary. The returned reference may
@ -134,7 +136,7 @@ typedef struct _cef_value_t {
// the set_value() function instead of passing the returned reference to // the set_value() function instead of passing the returned reference to
// set_binary(). // set_binary().
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)( struct _cef_binary_value_t*(CEF_CALLBACK* get_binary)(
struct _cef_value_t* self); struct _cef_value_t* self);
/// ///
@ -145,7 +147,7 @@ typedef struct _cef_value_t {
// the set_value() function instead of passing the returned reference to // the set_value() function instead of passing the returned reference to
// set_dictionary(). // set_dictionary().
/// ///
struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)( struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)(
struct _cef_value_t* self); struct _cef_value_t* self);
/// ///
@ -156,37 +158,37 @@ typedef struct _cef_value_t {
// the set_value() function instead of passing the returned reference to // the set_value() function instead of passing the returned reference to
// set_list(). // set_list().
/// ///
struct _cef_list_value_t* (CEF_CALLBACK *get_list)(struct _cef_value_t* self); struct _cef_list_value_t*(CEF_CALLBACK* get_list)(struct _cef_value_t* self);
/// ///
// Sets the underlying value as type null. Returns true (1) if the value was // Sets the underlying value as type null. Returns true (1) if the value was
// set successfully. // set successfully.
/// ///
int (CEF_CALLBACK *set_null)(struct _cef_value_t* self); int(CEF_CALLBACK* set_null)(struct _cef_value_t* self);
/// ///
// Sets the underlying value as type bool. Returns true (1) if the value was // Sets the underlying value as type bool. Returns true (1) if the value was
// set successfully. // set successfully.
/// ///
int (CEF_CALLBACK *set_bool)(struct _cef_value_t* self, int value); int(CEF_CALLBACK* set_bool)(struct _cef_value_t* self, int value);
/// ///
// Sets the underlying value as type int. Returns true (1) if the value was // Sets the underlying value as type int. Returns true (1) if the value was
// set successfully. // set successfully.
/// ///
int (CEF_CALLBACK *set_int)(struct _cef_value_t* self, int value); int(CEF_CALLBACK* set_int)(struct _cef_value_t* self, int value);
/// ///
// Sets the underlying value as type double. Returns true (1) if the value was // Sets the underlying value as type double. Returns true (1) if the value was
// set successfully. // set successfully.
/// ///
int (CEF_CALLBACK *set_double)(struct _cef_value_t* self, double value); int(CEF_CALLBACK* set_double)(struct _cef_value_t* self, double value);
/// ///
// Sets the underlying value as type string. Returns true (1) if the value was // Sets the underlying value as type string. Returns true (1) if the value was
// set successfully. // set successfully.
/// ///
int (CEF_CALLBACK *set_string)(struct _cef_value_t* self, int(CEF_CALLBACK* set_string)(struct _cef_value_t* self,
const cef_string_t* value); const cef_string_t* value);
/// ///
@ -194,7 +196,7 @@ typedef struct _cef_value_t {
// set successfully. This object keeps a reference to |value| and ownership of // set successfully. This object keeps a reference to |value| and ownership of
// the underlying data remains unchanged. // the underlying data remains unchanged.
/// ///
int (CEF_CALLBACK *set_binary)(struct _cef_value_t* self, int(CEF_CALLBACK* set_binary)(struct _cef_value_t* self,
struct _cef_binary_value_t* value); struct _cef_binary_value_t* value);
/// ///
@ -202,7 +204,7 @@ typedef struct _cef_value_t {
// set successfully. This object keeps a reference to |value| and ownership of // set successfully. This object keeps a reference to |value| and ownership of
// the underlying data remains unchanged. // the underlying data remains unchanged.
/// ///
int (CEF_CALLBACK *set_dictionary)(struct _cef_value_t* self, int(CEF_CALLBACK* set_dictionary)(struct _cef_value_t* self,
struct _cef_dictionary_value_t* value); struct _cef_dictionary_value_t* value);
/// ///
@ -210,17 +212,15 @@ typedef struct _cef_value_t {
// set successfully. This object keeps a reference to |value| and ownership of // set successfully. This object keeps a reference to |value| and ownership of
// the underlying data remains unchanged. // the underlying data remains unchanged.
/// ///
int (CEF_CALLBACK *set_list)(struct _cef_value_t* self, int(CEF_CALLBACK* set_list)(struct _cef_value_t* self,
struct _cef_list_value_t* value); struct _cef_list_value_t* value);
} cef_value_t; } cef_value_t;
/// ///
// Creates a new object. // Creates a new object.
/// ///
CEF_EXPORT cef_value_t* cef_value_create(); CEF_EXPORT cef_value_t* cef_value_create();
/// ///
// Structure representing a binary value. Can be used on any process and thread. // Structure representing a binary value. Can be used on any process and thread.
/// ///
@ -236,47 +236,48 @@ typedef struct _cef_binary_value_t {
// and that other object is then modified or destroyed. Do not call any other // and that other object is then modified or destroyed. Do not call any other
// functions if this function returns false (0). // functions if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_binary_value_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_binary_value_t* self);
/// ///
// Returns true (1) if this object is currently owned by another object. // Returns true (1) if this object is currently owned by another object.
/// ///
int (CEF_CALLBACK *is_owned)(struct _cef_binary_value_t* self); int(CEF_CALLBACK* is_owned)(struct _cef_binary_value_t* self);
/// ///
// Returns true (1) if this object and |that| object have the same underlying // Returns true (1) if this object and |that| object have the same underlying
// data. // data.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_binary_value_t* self, int(CEF_CALLBACK* is_same)(struct _cef_binary_value_t* self,
struct _cef_binary_value_t* that); struct _cef_binary_value_t* that);
/// ///
// Returns true (1) if this object and |that| object have an equivalent // Returns true (1) if this object and |that| object have an equivalent
// underlying value but are not necessarily the same object. // underlying value but are not necessarily the same object.
/// ///
int (CEF_CALLBACK *is_equal)(struct _cef_binary_value_t* self, int(CEF_CALLBACK* is_equal)(struct _cef_binary_value_t* self,
struct _cef_binary_value_t* that); struct _cef_binary_value_t* that);
/// ///
// Returns a copy of this object. The data in this object will also be copied. // Returns a copy of this object. The data in this object will also be copied.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *copy)( struct _cef_binary_value_t*(CEF_CALLBACK* copy)(
struct _cef_binary_value_t* self); struct _cef_binary_value_t* self);
/// ///
// Returns the data size. // Returns the data size.
/// ///
size_t (CEF_CALLBACK *get_size)(struct _cef_binary_value_t* self); size_t(CEF_CALLBACK* get_size)(struct _cef_binary_value_t* self);
/// ///
// Read up to |buffer_size| number of bytes into |buffer|. Reading begins at // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
// the specified byte |data_offset|. Returns the number of bytes read. // the specified byte |data_offset|. Returns the number of bytes read.
/// ///
size_t (CEF_CALLBACK *get_data)(struct _cef_binary_value_t* self, size_t(CEF_CALLBACK* get_data)(struct _cef_binary_value_t* self,
void* buffer, size_t buffer_size, size_t data_offset); void* buffer,
size_t buffer_size,
size_t data_offset);
} cef_binary_value_t; } cef_binary_value_t;
/// ///
// Creates a new object that is not owned by any other object. The specified // Creates a new object that is not owned by any other object. The specified
// |data| will be copied. // |data| will be copied.
@ -284,7 +285,6 @@ typedef struct _cef_binary_value_t {
CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data, CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data,
size_t data_size); size_t data_size);
/// ///
// Structure representing a dictionary value. Can be used on any process and // Structure representing a dictionary value. Can be used on any process and
// thread. // thread.
@ -301,75 +301,76 @@ typedef struct _cef_dictionary_value_t {
// and that other object is then modified or destroyed. Do not call any other // and that other object is then modified or destroyed. Do not call any other
// functions if this function returns false (0). // functions if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_dictionary_value_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_dictionary_value_t* self);
/// ///
// Returns true (1) if this object is currently owned by another object. // Returns true (1) if this object is currently owned by another object.
/// ///
int (CEF_CALLBACK *is_owned)(struct _cef_dictionary_value_t* self); int(CEF_CALLBACK* is_owned)(struct _cef_dictionary_value_t* self);
/// ///
// Returns true (1) if the values of this object are read-only. Some APIs may // Returns true (1) if the values of this object are read-only. Some APIs may
// expose read-only objects. // expose read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_dictionary_value_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_dictionary_value_t* self);
/// ///
// Returns true (1) if this object and |that| object have the same underlying // Returns true (1) if this object and |that| object have the same underlying
// data. If true (1) modifications to this object will also affect |that| // data. If true (1) modifications to this object will also affect |that|
// object and vice-versa. // object and vice-versa.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* is_same)(struct _cef_dictionary_value_t* self,
struct _cef_dictionary_value_t* that); struct _cef_dictionary_value_t* that);
/// ///
// Returns true (1) if this object and |that| object have an equivalent // Returns true (1) if this object and |that| object have an equivalent
// underlying value but are not necessarily the same object. // underlying value but are not necessarily the same object.
/// ///
int (CEF_CALLBACK *is_equal)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* is_equal)(struct _cef_dictionary_value_t* self,
struct _cef_dictionary_value_t* that); struct _cef_dictionary_value_t* that);
/// ///
// Returns a writable copy of this object. If |exclude_NULL_children| is true // Returns a writable copy of this object. If |exclude_NULL_children| is true
// (1) any NULL dictionaries or lists will be excluded from the copy. // (1) any NULL dictionaries or lists will be excluded from the copy.
/// ///
struct _cef_dictionary_value_t* (CEF_CALLBACK *copy)( struct _cef_dictionary_value_t*(CEF_CALLBACK* copy)(
struct _cef_dictionary_value_t* self, int exclude_empty_children); struct _cef_dictionary_value_t* self,
int exclude_empty_children);
/// ///
// Returns the number of values. // Returns the number of values.
/// ///
size_t (CEF_CALLBACK *get_size)(struct _cef_dictionary_value_t* self); size_t(CEF_CALLBACK* get_size)(struct _cef_dictionary_value_t* self);
/// ///
// Removes all values. Returns true (1) on success. // Removes all values. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *clear)(struct _cef_dictionary_value_t* self); int(CEF_CALLBACK* clear)(struct _cef_dictionary_value_t* self);
/// ///
// Returns true (1) if the current dictionary has a value for the given key. // Returns true (1) if the current dictionary has a value for the given key.
/// ///
int (CEF_CALLBACK *has_key)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* has_key)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Reads all keys for this dictionary into the specified vector. // Reads all keys for this dictionary into the specified vector.
/// ///
int (CEF_CALLBACK *get_keys)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* get_keys)(struct _cef_dictionary_value_t* self,
cef_string_list_t keys); cef_string_list_t keys);
/// ///
// Removes the value at the specified key. Returns true (1) is the value was // Removes the value at the specified key. Returns true (1) is the value was
// removed successfully. // removed successfully.
/// ///
int (CEF_CALLBACK *remove)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* remove)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns the value type for the specified key. // Returns the value type for the specified key.
/// ///
cef_value_type_t (CEF_CALLBACK *get_type)( cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_dictionary_value_t* self,
struct _cef_dictionary_value_t* self, const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns the value at the specified key. For simple types the returned value // Returns the value at the specified key. For simple types the returned value
@ -378,56 +379,61 @@ typedef struct _cef_dictionary_value_t {
// will reference existing data and modifications to the value will modify // will reference existing data and modifications to the value will modify
// this object. // this object.
/// ///
struct _cef_value_t* (CEF_CALLBACK *get_value)( struct _cef_value_t*(CEF_CALLBACK* get_value)(
struct _cef_dictionary_value_t* self, const cef_string_t* key); struct _cef_dictionary_value_t* self,
const cef_string_t* key);
/// ///
// Returns the value at the specified key as type bool. // Returns the value at the specified key as type bool.
/// ///
int (CEF_CALLBACK *get_bool)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* get_bool)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns the value at the specified key as type int. // Returns the value at the specified key as type int.
/// ///
int (CEF_CALLBACK *get_int)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* get_int)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns the value at the specified key as type double. // Returns the value at the specified key as type double.
/// ///
double (CEF_CALLBACK *get_double)(struct _cef_dictionary_value_t* self, double(CEF_CALLBACK* get_double)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Returns the value at the specified key as type string. // Returns the value at the specified key as type string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)( cef_string_userfree_t(CEF_CALLBACK* get_string)(
struct _cef_dictionary_value_t* self, const cef_string_t* key); struct _cef_dictionary_value_t* self,
const cef_string_t* key);
/// ///
// Returns the value at the specified key as type binary. The returned value // Returns the value at the specified key as type binary. The returned value
// will reference existing data. // will reference existing data.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)( struct _cef_binary_value_t*(CEF_CALLBACK* get_binary)(
struct _cef_dictionary_value_t* self, const cef_string_t* key); struct _cef_dictionary_value_t* self,
const cef_string_t* key);
/// ///
// Returns the value at the specified key as type dictionary. The returned // Returns the value at the specified key as type dictionary. The returned
// value will reference existing data and modifications to the value will // value will reference existing data and modifications to the value will
// modify this object. // modify this object.
/// ///
struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)( struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)(
struct _cef_dictionary_value_t* self, const cef_string_t* key); struct _cef_dictionary_value_t* self,
const cef_string_t* key);
/// ///
// Returns the value at the specified key as type list. The returned value // Returns the value at the specified key as type list. The returned value
// will reference existing data and modifications to the value will modify // will reference existing data and modifications to the value will modify
// this object. // this object.
/// ///
struct _cef_list_value_t* (CEF_CALLBACK *get_list)( struct _cef_list_value_t*(CEF_CALLBACK* get_list)(
struct _cef_dictionary_value_t* self, const cef_string_t* key); struct _cef_dictionary_value_t* self,
const cef_string_t* key);
/// ///
// Sets the value at the specified key. Returns true (1) if the value was set // Sets the value at the specified key. Returns true (1) if the value was set
@ -437,43 +443,48 @@ typedef struct _cef_dictionary_value_t {
// underlying data will be referenced and modifications to |value| will modify // underlying data will be referenced and modifications to |value| will modify
// this object. // this object.
/// ///
int (CEF_CALLBACK *set_value)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_value)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, struct _cef_value_t* value); const cef_string_t* key,
struct _cef_value_t* value);
/// ///
// Sets the value at the specified key as type null. Returns true (1) if the // Sets the value at the specified key as type null. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_null)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_null)(struct _cef_dictionary_value_t* self,
const cef_string_t* key); const cef_string_t* key);
/// ///
// Sets the value at the specified key as type bool. Returns true (1) if the // Sets the value at the specified key as type bool. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_bool)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_bool)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, int value); const cef_string_t* key,
int value);
/// ///
// Sets the value at the specified key as type int. Returns true (1) if the // Sets the value at the specified key as type int. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_int)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_int)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, int value); const cef_string_t* key,
int value);
/// ///
// Sets the value at the specified key as type double. Returns true (1) if the // Sets the value at the specified key as type double. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_double)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_double)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, double value); const cef_string_t* key,
double value);
/// ///
// Sets the value at the specified key as type string. Returns true (1) if the // Sets the value at the specified key as type string. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_string)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_string)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, const cef_string_t* value); const cef_string_t* key,
const cef_string_t* value);
/// ///
// Sets the value at the specified key as type binary. Returns true (1) if the // Sets the value at the specified key as type binary. Returns true (1) if the
@ -482,8 +493,9 @@ typedef struct _cef_dictionary_value_t {
// Otherwise, ownership will be transferred to this object and the |value| // Otherwise, ownership will be transferred to this object and the |value|
// reference will be invalidated. // reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_binary)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_binary)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, struct _cef_binary_value_t* value); const cef_string_t* key,
struct _cef_binary_value_t* value);
/// ///
// Sets the value at the specified key as type dict. Returns true (1) if the // Sets the value at the specified key as type dict. Returns true (1) if the
@ -492,8 +504,9 @@ typedef struct _cef_dictionary_value_t {
// Otherwise, ownership will be transferred to this object and the |value| // Otherwise, ownership will be transferred to this object and the |value|
// reference will be invalidated. // reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_dictionary)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_dictionary)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, struct _cef_dictionary_value_t* value); const cef_string_t* key,
struct _cef_dictionary_value_t* value);
/// ///
// Sets the value at the specified key as type list. Returns true (1) if the // Sets the value at the specified key as type list. Returns true (1) if the
@ -502,17 +515,16 @@ typedef struct _cef_dictionary_value_t {
// Otherwise, ownership will be transferred to this object and the |value| // Otherwise, ownership will be transferred to this object and the |value|
// reference will be invalidated. // reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_list)(struct _cef_dictionary_value_t* self, int(CEF_CALLBACK* set_list)(struct _cef_dictionary_value_t* self,
const cef_string_t* key, struct _cef_list_value_t* value); const cef_string_t* key,
struct _cef_list_value_t* value);
} cef_dictionary_value_t; } cef_dictionary_value_t;
/// ///
// Creates a new object that is not owned by any other object. // Creates a new object that is not owned by any other object.
/// ///
CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create(); CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create();
/// ///
// Structure representing a list value. Can be used on any process and thread. // Structure representing a list value. Can be used on any process and thread.
/// ///
@ -528,65 +540,64 @@ typedef struct _cef_list_value_t {
// and that other object is then modified or destroyed. Do not call any other // and that other object is then modified or destroyed. Do not call any other
// functions if this function returns false (0). // functions if this function returns false (0).
/// ///
int (CEF_CALLBACK *is_valid)(struct _cef_list_value_t* self); int(CEF_CALLBACK* is_valid)(struct _cef_list_value_t* self);
/// ///
// Returns true (1) if this object is currently owned by another object. // Returns true (1) if this object is currently owned by another object.
/// ///
int (CEF_CALLBACK *is_owned)(struct _cef_list_value_t* self); int(CEF_CALLBACK* is_owned)(struct _cef_list_value_t* self);
/// ///
// Returns true (1) if the values of this object are read-only. Some APIs may // Returns true (1) if the values of this object are read-only. Some APIs may
// expose read-only objects. // expose read-only objects.
/// ///
int (CEF_CALLBACK *is_read_only)(struct _cef_list_value_t* self); int(CEF_CALLBACK* is_read_only)(struct _cef_list_value_t* self);
/// ///
// Returns true (1) if this object and |that| object have the same underlying // Returns true (1) if this object and |that| object have the same underlying
// data. If true (1) modifications to this object will also affect |that| // data. If true (1) modifications to this object will also affect |that|
// object and vice-versa. // object and vice-versa.
/// ///
int (CEF_CALLBACK *is_same)(struct _cef_list_value_t* self, int(CEF_CALLBACK* is_same)(struct _cef_list_value_t* self,
struct _cef_list_value_t* that); struct _cef_list_value_t* that);
/// ///
// Returns true (1) if this object and |that| object have an equivalent // Returns true (1) if this object and |that| object have an equivalent
// underlying value but are not necessarily the same object. // underlying value but are not necessarily the same object.
/// ///
int (CEF_CALLBACK *is_equal)(struct _cef_list_value_t* self, int(CEF_CALLBACK* is_equal)(struct _cef_list_value_t* self,
struct _cef_list_value_t* that); struct _cef_list_value_t* that);
/// ///
// Returns a writable copy of this object. // Returns a writable copy of this object.
/// ///
struct _cef_list_value_t* (CEF_CALLBACK *copy)( struct _cef_list_value_t*(CEF_CALLBACK* copy)(struct _cef_list_value_t* self);
struct _cef_list_value_t* self);
/// ///
// Sets the number of values. If the number of values is expanded all new // Sets the number of values. If the number of values is expanded all new
// value slots will default to type null. Returns true (1) on success. // value slots will default to type null. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *set_size)(struct _cef_list_value_t* self, size_t size); int(CEF_CALLBACK* set_size)(struct _cef_list_value_t* self, size_t size);
/// ///
// Returns the number of values. // Returns the number of values.
/// ///
size_t (CEF_CALLBACK *get_size)(struct _cef_list_value_t* self); size_t(CEF_CALLBACK* get_size)(struct _cef_list_value_t* self);
/// ///
// Removes all values. Returns true (1) on success. // Removes all values. Returns true (1) on success.
/// ///
int (CEF_CALLBACK *clear)(struct _cef_list_value_t* self); int(CEF_CALLBACK* clear)(struct _cef_list_value_t* self);
/// ///
// Removes the value at the specified index. // Removes the value at the specified index.
/// ///
int (CEF_CALLBACK *remove)(struct _cef_list_value_t* self, size_t index); int(CEF_CALLBACK* remove)(struct _cef_list_value_t* self, size_t index);
/// ///
// Returns the value type at the specified index. // Returns the value type at the specified index.
/// ///
cef_value_type_t (CEF_CALLBACK *get_type)(struct _cef_list_value_t* self, cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_list_value_t* self,
size_t index); size_t index);
/// ///
@ -596,54 +607,55 @@ typedef struct _cef_list_value_t {
// returned value will reference existing data and modifications to the value // returned value will reference existing data and modifications to the value
// will modify this object. // will modify this object.
/// ///
struct _cef_value_t* (CEF_CALLBACK *get_value)(struct _cef_list_value_t* self, struct _cef_value_t*(CEF_CALLBACK* get_value)(struct _cef_list_value_t* self,
size_t index); size_t index);
/// ///
// Returns the value at the specified index as type bool. // Returns the value at the specified index as type bool.
/// ///
int (CEF_CALLBACK *get_bool)(struct _cef_list_value_t* self, size_t index); int(CEF_CALLBACK* get_bool)(struct _cef_list_value_t* self, size_t index);
/// ///
// Returns the value at the specified index as type int. // Returns the value at the specified index as type int.
/// ///
int (CEF_CALLBACK *get_int)(struct _cef_list_value_t* self, size_t index); int(CEF_CALLBACK* get_int)(struct _cef_list_value_t* self, size_t index);
/// ///
// Returns the value at the specified index as type double. // Returns the value at the specified index as type double.
/// ///
double (CEF_CALLBACK *get_double)(struct _cef_list_value_t* self, double(CEF_CALLBACK* get_double)(struct _cef_list_value_t* self,
size_t index); size_t index);
/// ///
// Returns the value at the specified index as type string. // Returns the value at the specified index as type string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)( cef_string_userfree_t(
struct _cef_list_value_t* self, size_t index); CEF_CALLBACK* get_string)(struct _cef_list_value_t* self, size_t index);
/// ///
// Returns the value at the specified index as type binary. The returned value // Returns the value at the specified index as type binary. The returned value
// will reference existing data. // will reference existing data.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)( struct _cef_binary_value_t*(
struct _cef_list_value_t* self, size_t index); CEF_CALLBACK* get_binary)(struct _cef_list_value_t* self, size_t index);
/// ///
// Returns the value at the specified index as type dictionary. The returned // Returns the value at the specified index as type dictionary. The returned
// value will reference existing data and modifications to the value will // value will reference existing data and modifications to the value will
// modify this object. // modify this object.
/// ///
struct _cef_dictionary_value_t* (CEF_CALLBACK *get_dictionary)( struct _cef_dictionary_value_t*(CEF_CALLBACK* get_dictionary)(
struct _cef_list_value_t* self, size_t index); struct _cef_list_value_t* self,
size_t index);
/// ///
// Returns the value at the specified index as type list. The returned value // Returns the value at the specified index as type list. The returned value
// will reference existing data and modifications to the value will modify // will reference existing data and modifications to the value will modify
// this object. // this object.
/// ///
struct _cef_list_value_t* (CEF_CALLBACK *get_list)( struct _cef_list_value_t*(
struct _cef_list_value_t* self, size_t index); CEF_CALLBACK* get_list)(struct _cef_list_value_t* self, size_t index);
/// ///
// Sets the value at the specified index. Returns true (1) if the value was // Sets the value at the specified index. Returns true (1) if the value was
@ -653,41 +665,46 @@ typedef struct _cef_list_value_t {
// then the underlying data will be referenced and modifications to |value| // then the underlying data will be referenced and modifications to |value|
// will modify this object. // will modify this object.
/// ///
int (CEF_CALLBACK *set_value)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_value)(struct _cef_list_value_t* self,
size_t index,
struct _cef_value_t* value); struct _cef_value_t* value);
/// ///
// Sets the value at the specified index as type null. Returns true (1) if the // Sets the value at the specified index as type null. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_null)(struct _cef_list_value_t* self, size_t index); int(CEF_CALLBACK* set_null)(struct _cef_list_value_t* self, size_t index);
/// ///
// Sets the value at the specified index as type bool. Returns true (1) if the // Sets the value at the specified index as type bool. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_bool)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_bool)(struct _cef_list_value_t* self,
size_t index,
int value); int value);
/// ///
// Sets the value at the specified index as type int. Returns true (1) if the // Sets the value at the specified index as type int. Returns true (1) if the
// value was set successfully. // value was set successfully.
/// ///
int (CEF_CALLBACK *set_int)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_int)(struct _cef_list_value_t* self,
size_t index,
int value); int value);
/// ///
// Sets the value at the specified index as type double. Returns true (1) if // Sets the value at the specified index as type double. Returns true (1) if
// the value was set successfully. // the value was set successfully.
/// ///
int (CEF_CALLBACK *set_double)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_double)(struct _cef_list_value_t* self,
size_t index,
double value); double value);
/// ///
// Sets the value at the specified index as type string. Returns true (1) if // Sets the value at the specified index as type string. Returns true (1) if
// the value was set successfully. // the value was set successfully.
/// ///
int (CEF_CALLBACK *set_string)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_string)(struct _cef_list_value_t* self,
size_t index,
const cef_string_t* value); const cef_string_t* value);
/// ///
@ -697,7 +714,8 @@ typedef struct _cef_list_value_t {
// change. Otherwise, ownership will be transferred to this object and the // change. Otherwise, ownership will be transferred to this object and the
// |value| reference will be invalidated. // |value| reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_binary)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_binary)(struct _cef_list_value_t* self,
size_t index,
struct _cef_binary_value_t* value); struct _cef_binary_value_t* value);
/// ///
@ -707,8 +725,9 @@ typedef struct _cef_list_value_t {
// Otherwise, ownership will be transferred to this object and the |value| // Otherwise, ownership will be transferred to this object and the |value|
// reference will be invalidated. // reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_dictionary)(struct _cef_list_value_t* self, int(CEF_CALLBACK* set_dictionary)(struct _cef_list_value_t* self,
size_t index, struct _cef_dictionary_value_t* value); size_t index,
struct _cef_dictionary_value_t* value);
/// ///
// Sets the value at the specified index as type list. Returns true (1) if the // Sets the value at the specified index as type list. Returns true (1) if the
@ -717,17 +736,16 @@ typedef struct _cef_list_value_t {
// Otherwise, ownership will be transferred to this object and the |value| // Otherwise, ownership will be transferred to this object and the |value|
// reference will be invalidated. // reference will be invalidated.
/// ///
int (CEF_CALLBACK *set_list)(struct _cef_list_value_t* self, size_t index, int(CEF_CALLBACK* set_list)(struct _cef_list_value_t* self,
size_t index,
struct _cef_list_value_t* value); struct _cef_list_value_t* value);
} cef_list_value_t; } cef_list_value_t;
/// ///
// Creates a new object that is not owned by any other object. // Creates a new object that is not owned by any other object.
/// ///
CEF_EXPORT cef_list_value_t* cef_list_value_create(); CEF_EXPORT cef_list_value_t* cef_list_value_create();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

18
include/capi/cef_waitable_event_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=a8fdbd327fff7769353b0aba47c74cba61333144$
//
#ifndef CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
@ -44,7 +46,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// WaitableEvent is a thread synchronization tool that allows one thread to wait // WaitableEvent is a thread synchronization tool that allows one thread to wait
// for another thread to finish some work. This is equivalent to using a // for another thread to finish some work. This is equivalent to using a
@ -65,27 +66,27 @@ typedef struct _cef_waitable_event_t {
/// ///
// Put the event in the un-signaled state. // Put the event in the un-signaled state.
/// ///
void (CEF_CALLBACK *reset)(struct _cef_waitable_event_t* self); void(CEF_CALLBACK* reset)(struct _cef_waitable_event_t* self);
/// ///
// Put the event in the signaled state. This causes any thread blocked on Wait // Put the event in the signaled state. This causes any thread blocked on Wait
// to be woken up. // to be woken up.
/// ///
void (CEF_CALLBACK *signal)(struct _cef_waitable_event_t* self); void(CEF_CALLBACK* signal)(struct _cef_waitable_event_t* self);
/// ///
// Returns true (1) if the event is in the signaled state, else false (0). If // Returns true (1) if the event is in the signaled state, else false (0). If
// the event was created with |automatic_reset| set to true (1) then calling // the event was created with |automatic_reset| set to true (1) then calling
// this function will also cause a reset. // this function will also cause a reset.
/// ///
int (CEF_CALLBACK *is_signaled)(struct _cef_waitable_event_t* self); int(CEF_CALLBACK* is_signaled)(struct _cef_waitable_event_t* self);
/// ///
// Wait indefinitely for the event to be signaled. This function will not // Wait indefinitely for the event to be signaled. This function will not
// return until after the call to signal() has completed. This function cannot // return until after the call to signal() has completed. This function cannot
// be called on the browser process UI or IO threads. // be called on the browser process UI or IO threads.
/// ///
void (CEF_CALLBACK *wait)(struct _cef_waitable_event_t* self); void(CEF_CALLBACK* wait)(struct _cef_waitable_event_t* self);
/// ///
// Wait up to |max_ms| milliseconds for the event to be signaled. Returns true // Wait up to |max_ms| milliseconds for the event to be signaled. Returns true
@ -94,11 +95,10 @@ typedef struct _cef_waitable_event_t {
// until after the call to signal() has completed. This function cannot be // until after the call to signal() has completed. This function cannot be
// called on the browser process UI or IO threads. // called on the browser process UI or IO threads.
/// ///
int (CEF_CALLBACK *timed_wait)(struct _cef_waitable_event_t* self, int(CEF_CALLBACK* timed_wait)(struct _cef_waitable_event_t* self,
int64 max_ms); int64 max_ms);
} cef_waitable_event_t; } cef_waitable_event_t;
/// ///
// Create a new waitable event. If |automatic_reset| is true (1) then the event // Create a new waitable event. If |automatic_reset| is true (1) then the event
// state is automatically reset to un-signaled after a single waiting thread has // state is automatically reset to un-signaled after a single waiting thread has
@ -106,10 +106,10 @@ typedef struct _cef_waitable_event_t {
// manually. If |initially_signaled| is true (1) then the event will start in // manually. If |initially_signaled| is true (1) then the event will start in
// the signaled state. // the signaled state.
/// ///
CEF_EXPORT cef_waitable_event_t* cef_waitable_event_create(int automatic_reset, CEF_EXPORT cef_waitable_event_t* cef_waitable_event_create(
int automatic_reset,
int initially_signaled); int initially_signaled);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

36
include/capi/cef_web_plugin_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=95dbecaa1c2b67c99e32d29e7bcd3aff4d126baf$
//
#ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
@ -59,32 +61,31 @@ typedef struct _cef_web_plugin_info_t {
// Returns the plugin name (i.e. Flash). // Returns the plugin name (i.e. Flash).
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_name)( cef_string_userfree_t(CEF_CALLBACK* get_name)(
struct _cef_web_plugin_info_t* self); struct _cef_web_plugin_info_t* self);
/// ///
// Returns the plugin file path (DLL/bundle/library). // Returns the plugin file path (DLL/bundle/library).
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_path)( cef_string_userfree_t(CEF_CALLBACK* get_path)(
struct _cef_web_plugin_info_t* self); struct _cef_web_plugin_info_t* self);
/// ///
// Returns the version of the plugin (may be OS-specific). // Returns the version of the plugin (may be OS-specific).
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_version)( cef_string_userfree_t(CEF_CALLBACK* get_version)(
struct _cef_web_plugin_info_t* self); struct _cef_web_plugin_info_t* self);
/// ///
// Returns a description of the plugin from the version information. // Returns a description of the plugin from the version information.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_description)( cef_string_userfree_t(CEF_CALLBACK* get_description)(
struct _cef_web_plugin_info_t* self); struct _cef_web_plugin_info_t* self);
} cef_web_plugin_info_t; } cef_web_plugin_info_t;
/// ///
// Structure to implement for visiting web plugin information. The functions of // Structure to implement for visiting web plugin information. The functions of
// this structure will be called on the browser process UI thread. // this structure will be called on the browser process UI thread.
@ -101,11 +102,12 @@ typedef struct _cef_web_plugin_info_visitor_t {
// Return false (0) to stop visiting plugins. This function may never be // Return false (0) to stop visiting plugins. This function may never be
// called if no plugins are found. // called if no plugins are found.
/// ///
int (CEF_CALLBACK *visit)(struct _cef_web_plugin_info_visitor_t* self, int(CEF_CALLBACK* visit)(struct _cef_web_plugin_info_visitor_t* self,
struct _cef_web_plugin_info_t* info, int count, int total); struct _cef_web_plugin_info_t* info,
int count,
int total);
} cef_web_plugin_info_visitor_t; } cef_web_plugin_info_visitor_t;
/// ///
// Structure to implement for receiving unstable plugin information. The // Structure to implement for receiving unstable plugin information. The
// functions of this structure will be called on the browser process IO thread. // functions of this structure will be called on the browser process IO thread.
@ -121,12 +123,12 @@ typedef struct _cef_web_plugin_unstable_callback_t {
// true (1) if the plugin has reached the crash count threshold of 3 times in // true (1) if the plugin has reached the crash count threshold of 3 times in
// 120 seconds. // 120 seconds.
/// ///
void (CEF_CALLBACK *is_unstable)( void(CEF_CALLBACK* is_unstable)(
struct _cef_web_plugin_unstable_callback_t* self, struct _cef_web_plugin_unstable_callback_t* self,
const cef_string_t* path, int unstable); const cef_string_t* path,
int unstable);
} cef_web_plugin_unstable_callback_t; } cef_web_plugin_unstable_callback_t;
/// ///
// Implement this structure to receive notification when CDM registration is // Implement this structure to receive notification when CDM registration is
// complete. The functions of this structure will be called on the browser // complete. The functions of this structure will be called on the browser
@ -144,12 +146,12 @@ typedef struct _cef_register_cdm_callback_t {
// Otherwise, |result| and |error_message| will contain additional information // Otherwise, |result| and |error_message| will contain additional information
// about why registration failed. // about why registration failed.
/// ///
void (CEF_CALLBACK *on_cdm_registration_complete)( void(CEF_CALLBACK* on_cdm_registration_complete)(
struct _cef_register_cdm_callback_t* self, struct _cef_register_cdm_callback_t* self,
cef_cdm_registration_error_t result, const cef_string_t* error_message); cef_cdm_registration_error_t result,
const cef_string_t* error_message);
} cef_register_cdm_callback_t; } cef_register_cdm_callback_t;
/// ///
// Visit web plugin information. Can be called on any thread in the browser // Visit web plugin information. Can be called on any thread in the browser
// process. // process.
@ -181,7 +183,8 @@ CEF_EXPORT void cef_register_web_plugin_crash(const cef_string_t* path);
// Query if a plugin is unstable. Can be called on any thread in the browser // Query if a plugin is unstable. Can be called on any thread in the browser
// process. // process.
/// ///
CEF_EXPORT void cef_is_web_plugin_unstable(const cef_string_t* path, CEF_EXPORT void cef_is_web_plugin_unstable(
const cef_string_t* path,
cef_web_plugin_unstable_callback_t* callback); cef_web_plugin_unstable_callback_t* callback);
/// ///
@ -229,7 +232,8 @@ CEF_EXPORT void cef_is_web_plugin_unstable(const cef_string_t* path,
// |callback| will receive a |result| value of // |callback| will receive a |result| value of
// CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED. // CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED.
/// ///
CEF_EXPORT void cef_register_widevine_cdm(const cef_string_t* path, CEF_EXPORT void cef_register_widevine_cdm(
const cef_string_t* path,
cef_register_cdm_callback_t* callback); cef_register_cdm_callback_t* callback);
#ifdef __cplusplus #ifdef __cplusplus

61
include/capi/cef_x509_certificate_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=9eccfa7e4ebd9ccd0d3d7e0424a9595053e6febe$
//
#ifndef CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure representing the issuer or subject field of an X.509 certificate. // Structure representing the issuer or subject field of an X.509 certificate.
/// ///
@ -61,63 +62,66 @@ typedef struct _cef_x509cert_principal_t {
// (OU) and returns the first non-NULL one found. // (OU) and returns the first non-NULL one found.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_display_name)( cef_string_userfree_t(CEF_CALLBACK* get_display_name)(
struct _cef_x509cert_principal_t* self); struct _cef_x509cert_principal_t* self);
/// ///
// Returns the common name. // Returns the common name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_common_name)( cef_string_userfree_t(CEF_CALLBACK* get_common_name)(
struct _cef_x509cert_principal_t* self); struct _cef_x509cert_principal_t* self);
/// ///
// Returns the locality name. // Returns the locality name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_locality_name)( cef_string_userfree_t(CEF_CALLBACK* get_locality_name)(
struct _cef_x509cert_principal_t* self); struct _cef_x509cert_principal_t* self);
/// ///
// Returns the state or province name. // Returns the state or province name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_state_or_province_name)( cef_string_userfree_t(CEF_CALLBACK* get_state_or_province_name)(
struct _cef_x509cert_principal_t* self); struct _cef_x509cert_principal_t* self);
/// ///
// Returns the country name. // Returns the country name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_country_name)( cef_string_userfree_t(CEF_CALLBACK* get_country_name)(
struct _cef_x509cert_principal_t* self); struct _cef_x509cert_principal_t* self);
/// ///
// Retrieve the list of street addresses. // Retrieve the list of street addresses.
/// ///
void (CEF_CALLBACK *get_street_addresses)( void(CEF_CALLBACK* get_street_addresses)(
struct _cef_x509cert_principal_t* self, cef_string_list_t addresses); struct _cef_x509cert_principal_t* self,
cef_string_list_t addresses);
/// ///
// Retrieve the list of organization names. // Retrieve the list of organization names.
/// ///
void (CEF_CALLBACK *get_organization_names)( void(CEF_CALLBACK* get_organization_names)(
struct _cef_x509cert_principal_t* self, cef_string_list_t names); struct _cef_x509cert_principal_t* self,
cef_string_list_t names);
/// ///
// Retrieve the list of organization unit names. // Retrieve the list of organization unit names.
/// ///
void (CEF_CALLBACK *get_organization_unit_names)( void(CEF_CALLBACK* get_organization_unit_names)(
struct _cef_x509cert_principal_t* self, cef_string_list_t names); struct _cef_x509cert_principal_t* self,
cef_string_list_t names);
/// ///
// Retrieve the list of domain components. // Retrieve the list of domain components.
/// ///
void (CEF_CALLBACK *get_domain_components)( void(CEF_CALLBACK* get_domain_components)(
struct _cef_x509cert_principal_t* self, cef_string_list_t components); struct _cef_x509cert_principal_t* self,
cef_string_list_t components);
} cef_x509cert_principal_t; } cef_x509cert_principal_t;
/// ///
// Structure representing a X.509 certificate. // Structure representing a X.509 certificate.
/// ///
@ -132,53 +136,53 @@ typedef struct _cef_x509certificate_t {
// this represents the web server. The common name of the subject should // this represents the web server. The common name of the subject should
// match the host name of the web server. // match the host name of the web server.
/// ///
struct _cef_x509cert_principal_t* (CEF_CALLBACK *get_subject)( struct _cef_x509cert_principal_t*(CEF_CALLBACK* get_subject)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the issuer of the X.509 certificate. // Returns the issuer of the X.509 certificate.
/// ///
struct _cef_x509cert_principal_t* (CEF_CALLBACK *get_issuer)( struct _cef_x509cert_principal_t*(CEF_CALLBACK* get_issuer)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the DER encoded serial number for the X.509 certificate. The value // Returns the DER encoded serial number for the X.509 certificate. The value
// possibly includes a leading 00 byte. // possibly includes a leading 00 byte.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_serial_number)( struct _cef_binary_value_t*(CEF_CALLBACK* get_serial_number)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the date before which the X.509 certificate is invalid. // Returns the date before which the X.509 certificate is invalid.
// CefTime.GetTimeT() will return 0 if no date was specified. // CefTime.GetTimeT() will return 0 if no date was specified.
/// ///
cef_time_t (CEF_CALLBACK *get_valid_start)( cef_time_t(CEF_CALLBACK* get_valid_start)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the date after which the X.509 certificate is invalid. // Returns the date after which the X.509 certificate is invalid.
// CefTime.GetTimeT() will return 0 if no date was specified. // CefTime.GetTimeT() will return 0 if no date was specified.
/// ///
cef_time_t (CEF_CALLBACK *get_valid_expiry)( cef_time_t(CEF_CALLBACK* get_valid_expiry)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the DER encoded data for the X.509 certificate. // Returns the DER encoded data for the X.509 certificate.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_derencoded)( struct _cef_binary_value_t*(CEF_CALLBACK* get_derencoded)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the PEM encoded data for the X.509 certificate. // Returns the PEM encoded data for the X.509 certificate.
/// ///
struct _cef_binary_value_t* (CEF_CALLBACK *get_pemencoded)( struct _cef_binary_value_t*(CEF_CALLBACK* get_pemencoded)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
// Returns the number of certificates in the issuer chain. If 0, the // Returns the number of certificates in the issuer chain. If 0, the
// certificate is self-signed. // certificate is self-signed.
/// ///
size_t (CEF_CALLBACK *get_issuer_chain_size)( size_t(CEF_CALLBACK* get_issuer_chain_size)(
struct _cef_x509certificate_t* self); struct _cef_x509certificate_t* self);
/// ///
@ -186,8 +190,9 @@ typedef struct _cef_x509certificate_t {
// to encode a certificate in the chain it is still present in the array but // to encode a certificate in the chain it is still present in the array but
// is an NULL string. // is an NULL string.
/// ///
void (CEF_CALLBACK *get_derencoded_issuer_chain)( void(CEF_CALLBACK* get_derencoded_issuer_chain)(
struct _cef_x509certificate_t* self, size_t* chainCount, struct _cef_x509certificate_t* self,
size_t* chainCount,
struct _cef_binary_value_t** chain); struct _cef_binary_value_t** chain);
/// ///
@ -195,12 +200,12 @@ typedef struct _cef_x509certificate_t {
// to encode a certificate in the chain it is still present in the array but // to encode a certificate in the chain it is still present in the array but
// is an NULL string. // is an NULL string.
/// ///
void (CEF_CALLBACK *get_pemencoded_issuer_chain)( void(CEF_CALLBACK* get_pemencoded_issuer_chain)(
struct _cef_x509certificate_t* self, size_t* chainCount, struct _cef_x509certificate_t* self,
size_t* chainCount,
struct _cef_binary_value_t** chain); struct _cef_binary_value_t** chain);
} cef_x509certificate_t; } cef_x509certificate_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

82
include/capi/cef_xml_reader_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=8356c87c40363434391cc18f509b580860db4404$
//
#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure that supports the reading of XML data via the libxml streaming API. // Structure that supports the reading of XML data via the libxml streaming API.
// The functions of this structure should only be called on the thread that // The functions of this structure should only be called on the thread that
@ -62,46 +63,45 @@ typedef struct _cef_xml_reader_t {
// called at least once to set the current cursor position. Returns true (1) // called at least once to set the current cursor position. Returns true (1)
// if the cursor position was set successfully. // if the cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_next_node)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* move_to_next_node)(struct _cef_xml_reader_t* self);
/// ///
// Close the document. This should be called directly to ensure that cleanup // Close the document. This should be called directly to ensure that cleanup
// occurs on the correct thread. // occurs on the correct thread.
/// ///
int (CEF_CALLBACK *close)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* close)(struct _cef_xml_reader_t* self);
/// ///
// Returns true (1) if an error has been reported by the XML parser. // Returns true (1) if an error has been reported by the XML parser.
/// ///
int (CEF_CALLBACK *has_error)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* has_error)(struct _cef_xml_reader_t* self);
/// ///
// Returns the error string. // Returns the error string.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_error)( cef_string_userfree_t(CEF_CALLBACK* get_error)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
// The below functions retrieve data for the node at the current cursor // The below functions retrieve data for the node at the current cursor
// position. // position.
/// ///
// Returns the node type. // Returns the node type.
/// ///
cef_xml_node_type_t (CEF_CALLBACK *get_type)(struct _cef_xml_reader_t* self); cef_xml_node_type_t(CEF_CALLBACK* get_type)(struct _cef_xml_reader_t* self);
/// ///
// Returns the node depth. Depth starts at 0 for the root node. // Returns the node depth. Depth starts at 0 for the root node.
/// ///
int (CEF_CALLBACK *get_depth)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* get_depth)(struct _cef_xml_reader_t* self);
/// ///
// Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT- // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT-
// LocalPart for additional details. // LocalPart for additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_local_name)( cef_string_userfree_t(CEF_CALLBACK* get_local_name)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
@ -109,7 +109,7 @@ typedef struct _cef_xml_reader_t {
// additional details. // additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_prefix)( cef_string_userfree_t(CEF_CALLBACK* get_prefix)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
@ -117,7 +117,7 @@ typedef struct _cef_xml_reader_t {
// http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details. // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_qualified_name)( cef_string_userfree_t(CEF_CALLBACK* get_qualified_name)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
@ -125,7 +125,7 @@ typedef struct _cef_xml_reader_t {
// http://www.w3.org/TR/REC-xml-names/ for additional details. // http://www.w3.org/TR/REC-xml-names/ for additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_namespace_uri)( cef_string_userfree_t(CEF_CALLBACK* get_namespace_uri)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
@ -133,7 +133,7 @@ typedef struct _cef_xml_reader_t {
// additional details. // additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_base_uri)( cef_string_userfree_t(CEF_CALLBACK* get_base_uri)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
@ -141,79 +141,81 @@ typedef struct _cef_xml_reader_t {
// http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details. // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_xml_lang)( cef_string_userfree_t(CEF_CALLBACK* get_xml_lang)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
// Returns true (1) if the node represents an NULL element. <a/> is considered // Returns true (1) if the node represents an NULL element. <a/> is considered
// NULL but <a></a> is not. // NULL but <a></a> is not.
/// ///
int (CEF_CALLBACK *is_empty_element)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* is_empty_element)(struct _cef_xml_reader_t* self);
/// ///
// Returns true (1) if the node has a text value. // Returns true (1) if the node has a text value.
/// ///
int (CEF_CALLBACK *has_value)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* has_value)(struct _cef_xml_reader_t* self);
/// ///
// Returns the text value. // Returns the text value.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_value)( cef_string_userfree_t(CEF_CALLBACK* get_value)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
// Returns true (1) if the node has attributes. // Returns true (1) if the node has attributes.
/// ///
int (CEF_CALLBACK *has_attributes)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* has_attributes)(struct _cef_xml_reader_t* self);
/// ///
// Returns the number of attributes. // Returns the number of attributes.
/// ///
size_t (CEF_CALLBACK *get_attribute_count)(struct _cef_xml_reader_t* self); size_t(CEF_CALLBACK* get_attribute_count)(struct _cef_xml_reader_t* self);
/// ///
// Returns the value of the attribute at the specified 0-based index. // Returns the value of the attribute at the specified 0-based index.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_attribute_byindex)( cef_string_userfree_t(CEF_CALLBACK* get_attribute_byindex)(
struct _cef_xml_reader_t* self, int index); struct _cef_xml_reader_t* self,
int index);
/// ///
// Returns the value of the attribute with the specified qualified name. // Returns the value of the attribute with the specified qualified name.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_attribute_byqname)( cef_string_userfree_t(CEF_CALLBACK* get_attribute_byqname)(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName); struct _cef_xml_reader_t* self,
const cef_string_t* qualifiedName);
/// ///
// Returns the value of the attribute with the specified local name and // Returns the value of the attribute with the specified local name and
// namespace URI. // namespace URI.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_attribute_bylname)( cef_string_userfree_t(CEF_CALLBACK* get_attribute_bylname)(
struct _cef_xml_reader_t* self, const cef_string_t* localName, struct _cef_xml_reader_t* self,
const cef_string_t* localName,
const cef_string_t* namespaceURI); const cef_string_t* namespaceURI);
/// ///
// Returns an XML representation of the current node's children. // Returns an XML representation of the current node's children.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_inner_xml)( cef_string_userfree_t(CEF_CALLBACK* get_inner_xml)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
// Returns an XML representation of the current node including its children. // Returns an XML representation of the current node including its children.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_outer_xml)( cef_string_userfree_t(CEF_CALLBACK* get_outer_xml)(
struct _cef_xml_reader_t* self); struct _cef_xml_reader_t* self);
/// ///
// Returns the line number for the current node. // Returns the line number for the current node.
/// ///
int (CEF_CALLBACK *get_line_number)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* get_line_number)(struct _cef_xml_reader_t* self);
// Attribute nodes are not traversed by default. The below functions can be // Attribute nodes are not traversed by default. The below functions can be
// used to move the cursor to an attribute node. move_to_carrying_element() // used to move the cursor to an attribute node. move_to_carrying_element()
@ -224,14 +226,15 @@ typedef struct _cef_xml_reader_t {
// Moves the cursor to the attribute at the specified 0-based index. Returns // Moves the cursor to the attribute at the specified 0-based index. Returns
// true (1) if the cursor position was set successfully. // true (1) if the cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_attribute_byindex)(struct _cef_xml_reader_t* self, int(CEF_CALLBACK* move_to_attribute_byindex)(struct _cef_xml_reader_t* self,
int index); int index);
/// ///
// Moves the cursor to the attribute with the specified qualified name. // Moves the cursor to the attribute with the specified qualified name.
// Returns true (1) if the cursor position was set successfully. // Returns true (1) if the cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_attribute_byqname)(struct _cef_xml_reader_t* self, int(CEF_CALLBACK* move_to_attribute_byqname)(
struct _cef_xml_reader_t* self,
const cef_string_t* qualifiedName); const cef_string_t* qualifiedName);
/// ///
@ -239,38 +242,39 @@ typedef struct _cef_xml_reader_t {
// namespace URI. Returns true (1) if the cursor position was set // namespace URI. Returns true (1) if the cursor position was set
// successfully. // successfully.
/// ///
int (CEF_CALLBACK *move_to_attribute_bylname)(struct _cef_xml_reader_t* self, int(CEF_CALLBACK* move_to_attribute_bylname)(
const cef_string_t* localName, const cef_string_t* namespaceURI); struct _cef_xml_reader_t* self,
const cef_string_t* localName,
const cef_string_t* namespaceURI);
/// ///
// Moves the cursor to the first attribute in the current element. Returns // Moves the cursor to the first attribute in the current element. Returns
// true (1) if the cursor position was set successfully. // true (1) if the cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_first_attribute)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* move_to_first_attribute)(struct _cef_xml_reader_t* self);
/// ///
// Moves the cursor to the next attribute in the current element. Returns true // Moves the cursor to the next attribute in the current element. Returns true
// (1) if the cursor position was set successfully. // (1) if the cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_next_attribute)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* move_to_next_attribute)(struct _cef_xml_reader_t* self);
/// ///
// Moves the cursor back to the carrying element. Returns true (1) if the // Moves the cursor back to the carrying element. Returns true (1) if the
// cursor position was set successfully. // cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_carrying_element)(struct _cef_xml_reader_t* self); int(CEF_CALLBACK* move_to_carrying_element)(struct _cef_xml_reader_t* self);
} cef_xml_reader_t; } cef_xml_reader_t;
/// ///
// Create a new cef_xml_reader_t object. The returned object's functions can // Create a new cef_xml_reader_t object. The returned object's functions can
// only be called from the thread that created the object. // only be called from the thread that created the object.
/// ///
CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create( CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(
struct _cef_stream_reader_t* stream, cef_xml_encoding_type_t encodingType, struct _cef_stream_reader_t* stream,
cef_xml_encoding_type_t encodingType,
const cef_string_t* URI); const cef_string_t* URI);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

34
include/capi/cef_zip_reader_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=fec66a36497e467f3da1d2b86d0ae66b8cf709b7$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_ #define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" { extern "C" {
#endif #endif
/// ///
// Structure that supports the reading of zip archives via the zlib unzip API. // Structure that supports the reading of zip archives via the zlib unzip API.
// The functions of this structure should only be called on the thread that // The functions of this structure should only be called on the thread that
@ -61,28 +62,28 @@ typedef struct _cef_zip_reader_t {
// Moves the cursor to the first file in the archive. Returns true (1) if the // Moves the cursor to the first file in the archive. Returns true (1) if the
// cursor position was set successfully. // cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_first_file)(struct _cef_zip_reader_t* self); int(CEF_CALLBACK* move_to_first_file)(struct _cef_zip_reader_t* self);
/// ///
// Moves the cursor to the next file in the archive. Returns true (1) if the // Moves the cursor to the next file in the archive. Returns true (1) if the
// cursor position was set successfully. // cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_next_file)(struct _cef_zip_reader_t* self); int(CEF_CALLBACK* move_to_next_file)(struct _cef_zip_reader_t* self);
/// ///
// Moves the cursor to the specified file in the archive. If |caseSensitive| // Moves the cursor to the specified file in the archive. If |caseSensitive|
// is true (1) then the search will be case sensitive. Returns true (1) if the // is true (1) then the search will be case sensitive. Returns true (1) if the
// cursor position was set successfully. // cursor position was set successfully.
/// ///
int (CEF_CALLBACK *move_to_file)(struct _cef_zip_reader_t* self, int(CEF_CALLBACK* move_to_file)(struct _cef_zip_reader_t* self,
const cef_string_t* fileName, int caseSensitive); const cef_string_t* fileName,
int caseSensitive);
/// ///
// Closes the archive. This should be called directly to ensure that cleanup // Closes the archive. This should be called directly to ensure that cleanup
// occurs on the correct thread. // occurs on the correct thread.
/// ///
int (CEF_CALLBACK *close)(struct _cef_zip_reader_t* self); int(CEF_CALLBACK* close)(struct _cef_zip_reader_t* self);
// The below functions act on the file at the current cursor position. // The below functions act on the file at the current cursor position.
@ -90,51 +91,51 @@ typedef struct _cef_zip_reader_t {
// Returns the name of the file. // Returns the name of the file.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_file_name)( cef_string_userfree_t(CEF_CALLBACK* get_file_name)(
struct _cef_zip_reader_t* self); struct _cef_zip_reader_t* self);
/// ///
// Returns the uncompressed size of the file. // Returns the uncompressed size of the file.
/// ///
int64 (CEF_CALLBACK *get_file_size)(struct _cef_zip_reader_t* self); int64(CEF_CALLBACK* get_file_size)(struct _cef_zip_reader_t* self);
/// ///
// Returns the last modified timestamp for the file. // Returns the last modified timestamp for the file.
/// ///
cef_time_t (CEF_CALLBACK *get_file_last_modified)( cef_time_t(CEF_CALLBACK* get_file_last_modified)(
struct _cef_zip_reader_t* self); struct _cef_zip_reader_t* self);
/// ///
// Opens the file for reading of uncompressed data. A read password may // Opens the file for reading of uncompressed data. A read password may
// optionally be specified. // optionally be specified.
/// ///
int (CEF_CALLBACK *open_file)(struct _cef_zip_reader_t* self, int(CEF_CALLBACK* open_file)(struct _cef_zip_reader_t* self,
const cef_string_t* password); const cef_string_t* password);
/// ///
// Closes the file. // Closes the file.
/// ///
int (CEF_CALLBACK *close_file)(struct _cef_zip_reader_t* self); int(CEF_CALLBACK* close_file)(struct _cef_zip_reader_t* self);
/// ///
// Read uncompressed file contents into the specified buffer. Returns < 0 if // Read uncompressed file contents into the specified buffer. Returns < 0 if
// an error occurred, 0 if at the end of file, or the number of bytes read. // an error occurred, 0 if at the end of file, or the number of bytes read.
/// ///
int (CEF_CALLBACK *read_file)(struct _cef_zip_reader_t* self, void* buffer, int(CEF_CALLBACK* read_file)(struct _cef_zip_reader_t* self,
void* buffer,
size_t bufferSize); size_t bufferSize);
/// ///
// Returns the current offset in the uncompressed file contents. // Returns the current offset in the uncompressed file contents.
/// ///
int64 (CEF_CALLBACK *tell)(struct _cef_zip_reader_t* self); int64(CEF_CALLBACK* tell)(struct _cef_zip_reader_t* self);
/// ///
// Returns true (1) if at end of the file contents. // Returns true (1) if at end of the file contents.
/// ///
int (CEF_CALLBACK *eof)(struct _cef_zip_reader_t* self); int(CEF_CALLBACK* eof)(struct _cef_zip_reader_t* self);
} cef_zip_reader_t; } cef_zip_reader_t;
/// ///
// Create a new cef_zip_reader_t object. The returned object's functions can // Create a new cef_zip_reader_t object. The returned object's functions can
// only be called from the thread that created the object. // only be called from the thread that created the object.
@ -142,7 +143,6 @@ typedef struct _cef_zip_reader_t {
CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create( CEF_EXPORT cef_zip_reader_t* cef_zip_reader_create(
struct _cef_stream_reader_t* stream); struct _cef_stream_reader_t* stream);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

298
include/capi/test/cef_translator_test_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for // by hand. See the translator.README.txt file in the tools directory for
// more information. // more information.
// //
// $hash=ec043910c391a84dda3b85cf01ea11cd44f37c1f$
//
#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_ #ifndef CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
#define CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_ #define CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
@ -67,88 +69,87 @@ typedef struct _cef_translator_test_t {
/// ///
cef_base_ref_counted_t base; cef_base_ref_counted_t base;
// PRIMITIVE VALUES // PRIMITIVE VALUES
/// ///
// Return a void value. // Return a void value.
/// ///
void (CEF_CALLBACK *get_void)(struct _cef_translator_test_t* self); void(CEF_CALLBACK* get_void)(struct _cef_translator_test_t* self);
/// ///
// Return a bool value. // Return a bool value.
/// ///
int (CEF_CALLBACK *get_bool)(struct _cef_translator_test_t* self); int(CEF_CALLBACK* get_bool)(struct _cef_translator_test_t* self);
/// ///
// Return an int value. // Return an int value.
/// ///
int (CEF_CALLBACK *get_int)(struct _cef_translator_test_t* self); int(CEF_CALLBACK* get_int)(struct _cef_translator_test_t* self);
/// ///
// Return a double value. // Return a double value.
/// ///
double (CEF_CALLBACK *get_double)(struct _cef_translator_test_t* self); double(CEF_CALLBACK* get_double)(struct _cef_translator_test_t* self);
/// ///
// Return a long value. // Return a long value.
/// ///
long (CEF_CALLBACK *get_long)(struct _cef_translator_test_t* self); long(CEF_CALLBACK* get_long)(struct _cef_translator_test_t* self);
/// ///
// Return a size_t value. // Return a size_t value.
/// ///
size_t (CEF_CALLBACK *get_sizet)(struct _cef_translator_test_t* self); size_t(CEF_CALLBACK* get_sizet)(struct _cef_translator_test_t* self);
/// ///
// Set a void value. // Set a void value.
/// ///
int (CEF_CALLBACK *set_void)(struct _cef_translator_test_t* self); int(CEF_CALLBACK* set_void)(struct _cef_translator_test_t* self);
/// ///
// Set a bool value. // Set a bool value.
/// ///
int (CEF_CALLBACK *set_bool)(struct _cef_translator_test_t* self, int val); int(CEF_CALLBACK* set_bool)(struct _cef_translator_test_t* self, int val);
/// ///
// Set an int value. // Set an int value.
/// ///
int (CEF_CALLBACK *set_int)(struct _cef_translator_test_t* self, int val); int(CEF_CALLBACK* set_int)(struct _cef_translator_test_t* self, int val);
/// ///
// Set a double value. // Set a double value.
/// ///
int (CEF_CALLBACK *set_double)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_double)(struct _cef_translator_test_t* self,
double val); double val);
/// ///
// Set a long value. // Set a long value.
/// ///
int (CEF_CALLBACK *set_long)(struct _cef_translator_test_t* self, long val); int(CEF_CALLBACK* set_long)(struct _cef_translator_test_t* self, long val);
/// ///
// Set a size_t value. // Set a size_t value.
/// ///
int (CEF_CALLBACK *set_sizet)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_sizet)(struct _cef_translator_test_t* self, size_t val);
size_t val);
/// ///
// Set a int list value. // Set a int list value.
/// ///
int (CEF_CALLBACK *set_int_list)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_int_list)(struct _cef_translator_test_t* self,
size_t valCount, int const* val); size_t valCount,
int const* val);
/// ///
// Return an int list value by out-param. // Return an int list value by out-param.
/// ///
int (CEF_CALLBACK *get_int_list_by_ref)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* get_int_list_by_ref)(struct _cef_translator_test_t* self,
size_t* valCount, int* val); size_t* valCount,
int* val);
/// ///
// Return the number of points that will be output above. // Return the number of points that will be output above.
/// ///
size_t (CEF_CALLBACK *get_int_list_size)(struct _cef_translator_test_t* self); size_t(CEF_CALLBACK* get_int_list_size)(struct _cef_translator_test_t* self);
// STRING VALUES // STRING VALUES
@ -156,103 +157,104 @@ typedef struct _cef_translator_test_t {
// Return a string value. // Return a string value.
/// ///
// The resulting string must be freed by calling cef_string_userfree_free(). // The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)( cef_string_userfree_t(CEF_CALLBACK* get_string)(
struct _cef_translator_test_t* self); struct _cef_translator_test_t* self);
/// ///
// Set a string value. // Set a string value.
/// ///
int (CEF_CALLBACK *set_string)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_string)(struct _cef_translator_test_t* self,
const cef_string_t* val); const cef_string_t* val);
/// ///
// Return a string value by out-param. // Return a string value by out-param.
/// ///
void (CEF_CALLBACK *get_string_by_ref)(struct _cef_translator_test_t* self, void(CEF_CALLBACK* get_string_by_ref)(struct _cef_translator_test_t* self,
cef_string_t* val); cef_string_t* val);
/// ///
// Set a string list value. // Set a string list value.
/// ///
int (CEF_CALLBACK *set_string_list)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_string_list)(struct _cef_translator_test_t* self,
cef_string_list_t val); cef_string_list_t val);
/// ///
// Return a string list value by out-param. // Return a string list value by out-param.
/// ///
int (CEF_CALLBACK *get_string_list_by_ref)( int(CEF_CALLBACK* get_string_list_by_ref)(struct _cef_translator_test_t* self,
struct _cef_translator_test_t* self, cef_string_list_t val); cef_string_list_t val);
/// ///
// Set a string map value. // Set a string map value.
/// ///
int (CEF_CALLBACK *set_string_map)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_string_map)(struct _cef_translator_test_t* self,
cef_string_map_t val); cef_string_map_t val);
/// ///
// Return a string map value by out-param. // Return a string map value by out-param.
/// ///
int (CEF_CALLBACK *get_string_map_by_ref)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* get_string_map_by_ref)(struct _cef_translator_test_t* self,
cef_string_map_t val); cef_string_map_t val);
/// ///
// Set a string multimap value. // Set a string multimap value.
/// ///
int (CEF_CALLBACK *set_string_multimap)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_string_multimap)(struct _cef_translator_test_t* self,
cef_string_multimap_t val); cef_string_multimap_t val);
/// ///
// Return a string multimap value by out-param. // Return a string multimap value by out-param.
/// ///
int (CEF_CALLBACK *get_string_multimap_by_ref)( int(CEF_CALLBACK* get_string_multimap_by_ref)(
struct _cef_translator_test_t* self, cef_string_multimap_t val); struct _cef_translator_test_t* self,
cef_string_multimap_t val);
// STRUCT VALUES // STRUCT VALUES
/// ///
// Return a point value. // Return a point value.
/// ///
cef_point_t (CEF_CALLBACK *get_point)(struct _cef_translator_test_t* self); cef_point_t(CEF_CALLBACK* get_point)(struct _cef_translator_test_t* self);
/// ///
// Set a point value. // Set a point value.
/// ///
int (CEF_CALLBACK *set_point)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_point)(struct _cef_translator_test_t* self,
const cef_point_t* val); const cef_point_t* val);
/// ///
// Return a point value by out-param. // Return a point value by out-param.
/// ///
void (CEF_CALLBACK *get_point_by_ref)(struct _cef_translator_test_t* self, void(CEF_CALLBACK* get_point_by_ref)(struct _cef_translator_test_t* self,
cef_point_t* val); cef_point_t* val);
/// ///
// Set a point list vlaue. // Set a point list vlaue.
/// ///
int (CEF_CALLBACK *set_point_list)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_point_list)(struct _cef_translator_test_t* self,
size_t valCount, cef_point_t const* val); size_t valCount,
cef_point_t const* val);
/// ///
// Return a point list value by out-param. // Return a point list value by out-param.
/// ///
int (CEF_CALLBACK *get_point_list_by_ref)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* get_point_list_by_ref)(struct _cef_translator_test_t* self,
size_t* valCount, cef_point_t* val); size_t* valCount,
cef_point_t* val);
/// ///
// Return the number of points that will be output above. // Return the number of points that will be output above.
/// ///
size_t (CEF_CALLBACK *get_point_list_size)( size_t(CEF_CALLBACK* get_point_list_size)(
struct _cef_translator_test_t* self); struct _cef_translator_test_t* self);
// LIBRARY-SIDE REFPTR VALUES // LIBRARY-SIDE REFPTR VALUES
/// ///
// Return an new library-side object. // Return an new library-side object.
/// ///
struct _cef_translator_test_ref_ptr_library_t* ( struct _cef_translator_test_ref_ptr_library_t*(
CEF_CALLBACK *get_ref_ptr_library)(struct _cef_translator_test_t* self, CEF_CALLBACK* get_ref_ptr_library)(struct _cef_translator_test_t* self,
int val); int val);
/// ///
@ -260,15 +262,16 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_library_t::get_value(). This tests input and // cef_translator_test_ref_ptr_library_t::get_value(). This tests input and
// execution of a library-side object type. // execution of a library-side object type.
/// ///
int (CEF_CALLBACK *set_ref_ptr_library)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_ref_ptr_library)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_t* val); struct _cef_translator_test_ref_ptr_library_t* val);
/// ///
// Set an object. Returns the object passed in. This tests input and output of // Set an object. Returns the object passed in. This tests input and output of
// a library-side object type. // a library-side object type.
/// ///
struct _cef_translator_test_ref_ptr_library_t* ( struct _cef_translator_test_ref_ptr_library_t*(
CEF_CALLBACK *set_ref_ptr_library_and_return)( CEF_CALLBACK* set_ref_ptr_library_and_return)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_t* val); struct _cef_translator_test_ref_ptr_library_t* val);
@ -277,7 +280,7 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_library_t::get_value(). This tests input of a // cef_translator_test_ref_ptr_library_t::get_value(). This tests input of a
// library- side child object type and execution as the parent type. // library- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_ref_ptr_library)( int(CEF_CALLBACK* set_child_ref_ptr_library)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_child_t* val); struct _cef_translator_test_ref_ptr_library_child_t* val);
@ -285,34 +288,37 @@ typedef struct _cef_translator_test_t {
// Set a child object. Returns the object as the parent type. This tests input // Set a child object. Returns the object as the parent type. This tests input
// of a library-side child object type and return as the parent type. // of a library-side child object type and return as the parent type.
/// ///
struct _cef_translator_test_ref_ptr_library_t* ( struct _cef_translator_test_ref_ptr_library_t*(
CEF_CALLBACK *set_child_ref_ptr_library_and_return_parent)( CEF_CALLBACK* set_child_ref_ptr_library_and_return_parent)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_child_t* val); struct _cef_translator_test_ref_ptr_library_child_t* val);
/// ///
// Set an object list vlaue. // Set an object list vlaue.
/// ///
int (CEF_CALLBACK *set_ref_ptr_library_list)( int(CEF_CALLBACK* set_ref_ptr_library_list)(
struct _cef_translator_test_t* self, size_t valCount, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_t* const* val, int val1, size_t valCount,
struct _cef_translator_test_ref_ptr_library_t* const* val,
int val1,
int val2); int val2);
/// ///
// Return an object list value by out-param. // Return an object list value by out-param.
/// ///
int (CEF_CALLBACK *get_ref_ptr_library_list_by_ref)( int(CEF_CALLBACK* get_ref_ptr_library_list_by_ref)(
struct _cef_translator_test_t* self, size_t* valCount, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_library_t** val, int val1, size_t* valCount,
struct _cef_translator_test_ref_ptr_library_t** val,
int val1,
int val2); int val2);
/// ///
// Return the number of object that will be output above. // Return the number of object that will be output above.
/// ///
size_t (CEF_CALLBACK *get_ref_ptr_library_list_size)( size_t(CEF_CALLBACK* get_ref_ptr_library_list_size)(
struct _cef_translator_test_t* self); struct _cef_translator_test_t* self);
// CLIENT-SIDE REFPTR VALUES // CLIENT-SIDE REFPTR VALUES
/// ///
@ -320,15 +326,16 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_client_t::get_value(). This tests input and // cef_translator_test_ref_ptr_client_t::get_value(). This tests input and
// execution of a client-side object type. // execution of a client-side object type.
/// ///
int (CEF_CALLBACK *set_ref_ptr_client)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_ref_ptr_client)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_client_t* val); struct _cef_translator_test_ref_ptr_client_t* val);
/// ///
// Set an object. Returns the handler passed in. This tests input and output // Set an object. Returns the handler passed in. This tests input and output
// of a client-side object type. // of a client-side object type.
/// ///
struct _cef_translator_test_ref_ptr_client_t* ( struct _cef_translator_test_ref_ptr_client_t*(
CEF_CALLBACK *set_ref_ptr_client_and_return)( CEF_CALLBACK* set_ref_ptr_client_and_return)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_client_t* val); struct _cef_translator_test_ref_ptr_client_t* val);
@ -337,7 +344,7 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_client_t::get_value(). This tests input of a // cef_translator_test_ref_ptr_client_t::get_value(). This tests input of a
// client- side child object type and execution as the parent type. // client- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_ref_ptr_client)( int(CEF_CALLBACK* set_child_ref_ptr_client)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_client_child_t* val); struct _cef_translator_test_ref_ptr_client_child_t* val);
@ -345,24 +352,27 @@ typedef struct _cef_translator_test_t {
// Set a child object. Returns the object as the parent type. This tests input // Set a child object. Returns the object as the parent type. This tests input
// of a client-side child object type and return as the parent type. // of a client-side child object type and return as the parent type.
/// ///
struct _cef_translator_test_ref_ptr_client_t* ( struct _cef_translator_test_ref_ptr_client_t*(
CEF_CALLBACK *set_child_ref_ptr_client_and_return_parent)( CEF_CALLBACK* set_child_ref_ptr_client_and_return_parent)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_client_child_t* val); struct _cef_translator_test_ref_ptr_client_child_t* val);
/// ///
// Set an object list vlaue. // Set an object list vlaue.
/// ///
int (CEF_CALLBACK *set_ref_ptr_client_list)( int(CEF_CALLBACK* set_ref_ptr_client_list)(
struct _cef_translator_test_t* self, size_t valCount, struct _cef_translator_test_t* self,
struct _cef_translator_test_ref_ptr_client_t* const* val, int val1, size_t valCount,
struct _cef_translator_test_ref_ptr_client_t* const* val,
int val1,
int val2); int val2);
/// ///
// Return an object list value by out-param. // Return an object list value by out-param.
/// ///
int (CEF_CALLBACK *get_ref_ptr_client_list_by_ref)( int(CEF_CALLBACK* get_ref_ptr_client_list_by_ref)(
struct _cef_translator_test_t* self, size_t* valCount, struct _cef_translator_test_t* self,
size_t* valCount,
struct _cef_translator_test_ref_ptr_client_t** val, struct _cef_translator_test_ref_ptr_client_t** val,
struct _cef_translator_test_ref_ptr_client_t* val1, struct _cef_translator_test_ref_ptr_client_t* val1,
struct _cef_translator_test_ref_ptr_client_t* val2); struct _cef_translator_test_ref_ptr_client_t* val2);
@ -370,17 +380,16 @@ typedef struct _cef_translator_test_t {
/// ///
// Return the number of object that will be output above. // Return the number of object that will be output above.
/// ///
size_t (CEF_CALLBACK *get_ref_ptr_client_list_size)( size_t(CEF_CALLBACK* get_ref_ptr_client_list_size)(
struct _cef_translator_test_t* self); struct _cef_translator_test_t* self);
// LIBRARY-SIDE OWNPTR VALUES // LIBRARY-SIDE OWNPTR VALUES
/// ///
// Return an new library-side object. // Return an new library-side object.
/// ///
struct _cef_translator_test_scoped_library_t* ( struct _cef_translator_test_scoped_library_t*(
CEF_CALLBACK *get_own_ptr_library)(struct _cef_translator_test_t* self, CEF_CALLBACK* get_own_ptr_library)(struct _cef_translator_test_t* self,
int val); int val);
/// ///
@ -388,15 +397,16 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_library_t::get_value(). This tests input and // cef_translator_test_scoped_library_t::get_value(). This tests input and
// execution of a library-side object type. // execution of a library-side object type.
/// ///
int (CEF_CALLBACK *set_own_ptr_library)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_own_ptr_library)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_t* val); struct _cef_translator_test_scoped_library_t* val);
/// ///
// Set an object. Returns the object passed in. This tests input and output of // Set an object. Returns the object passed in. This tests input and output of
// a library-side object type. // a library-side object type.
/// ///
struct _cef_translator_test_scoped_library_t* ( struct _cef_translator_test_scoped_library_t*(
CEF_CALLBACK *set_own_ptr_library_and_return)( CEF_CALLBACK* set_own_ptr_library_and_return)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_t* val); struct _cef_translator_test_scoped_library_t* val);
@ -405,7 +415,7 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_library_t::get_value(). This tests input of a // cef_translator_test_scoped_library_t::get_value(). This tests input of a
// library- side child object type and execution as the parent type. // library- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_own_ptr_library)( int(CEF_CALLBACK* set_child_own_ptr_library)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_child_t* val); struct _cef_translator_test_scoped_library_child_t* val);
@ -413,12 +423,11 @@ typedef struct _cef_translator_test_t {
// Set a child object. Returns the object as the parent type. This tests input // Set a child object. Returns the object as the parent type. This tests input
// of a library-side child object type and return as the parent type. // of a library-side child object type and return as the parent type.
/// ///
struct _cef_translator_test_scoped_library_t* ( struct _cef_translator_test_scoped_library_t*(
CEF_CALLBACK *set_child_own_ptr_library_and_return_parent)( CEF_CALLBACK* set_child_own_ptr_library_and_return_parent)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_child_t* val); struct _cef_translator_test_scoped_library_child_t* val);
// CLIENT-SIDE OWNPTR VALUES // CLIENT-SIDE OWNPTR VALUES
/// ///
@ -426,15 +435,16 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_client_t::get_value(). This tests input and // cef_translator_test_scoped_client_t::get_value(). This tests input and
// execution of a client-side object type. // execution of a client-side object type.
/// ///
int (CEF_CALLBACK *set_own_ptr_client)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_own_ptr_client)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_t* val); struct _cef_translator_test_scoped_client_t* val);
/// ///
// Set an object. Returns the handler passed in. This tests input and output // Set an object. Returns the handler passed in. This tests input and output
// of a client-side object type. // of a client-side object type.
/// ///
struct _cef_translator_test_scoped_client_t* ( struct _cef_translator_test_scoped_client_t*(
CEF_CALLBACK *set_own_ptr_client_and_return)( CEF_CALLBACK* set_own_ptr_client_and_return)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_t* val); struct _cef_translator_test_scoped_client_t* val);
@ -443,7 +453,7 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_client_t::get_value(). This tests input of a // cef_translator_test_scoped_client_t::get_value(). This tests input of a
// client- side child object type and execution as the parent type. // client- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_own_ptr_client)( int(CEF_CALLBACK* set_child_own_ptr_client)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_child_t* val); struct _cef_translator_test_scoped_client_child_t* val);
@ -451,12 +461,11 @@ typedef struct _cef_translator_test_t {
// Set a child object. Returns the object as the parent type. This tests input // Set a child object. Returns the object as the parent type. This tests input
// of a client-side child object type and return as the parent type. // of a client-side child object type and return as the parent type.
/// ///
struct _cef_translator_test_scoped_client_t* ( struct _cef_translator_test_scoped_client_t*(
CEF_CALLBACK *set_child_own_ptr_client_and_return_parent)( CEF_CALLBACK* set_child_own_ptr_client_and_return_parent)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_child_t* val); struct _cef_translator_test_scoped_client_child_t* val);
// LIBRARY-SIDE RAWPTR VALUES // LIBRARY-SIDE RAWPTR VALUES
/// ///
@ -464,7 +473,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_library_t::get_value(). This tests input and // cef_translator_test_scoped_library_t::get_value(). This tests input and
// execution of a library-side object type. // execution of a library-side object type.
/// ///
int (CEF_CALLBACK *set_raw_ptr_library)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_raw_ptr_library)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_t* val); struct _cef_translator_test_scoped_library_t* val);
/// ///
@ -472,19 +482,20 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_library_t::get_value(). This tests input of a // cef_translator_test_scoped_library_t::get_value(). This tests input of a
// library- side child object type and execution as the parent type. // library- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_raw_ptr_library)( int(CEF_CALLBACK* set_child_raw_ptr_library)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_child_t* val); struct _cef_translator_test_scoped_library_child_t* val);
/// ///
// Set an object list vlaue. // Set an object list vlaue.
/// ///
int (CEF_CALLBACK *set_raw_ptr_library_list)( int(CEF_CALLBACK* set_raw_ptr_library_list)(
struct _cef_translator_test_t* self, size_t valCount, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_t* const* val, int val1, size_t valCount,
struct _cef_translator_test_scoped_library_t* const* val,
int val1,
int val2); int val2);
// CLIENT-SIDE RAWPTR VALUES // CLIENT-SIDE RAWPTR VALUES
/// ///
@ -492,7 +503,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_client_t::get_value(). This tests input and // cef_translator_test_scoped_client_t::get_value(). This tests input and
// execution of a client-side object type. // execution of a client-side object type.
/// ///
int (CEF_CALLBACK *set_raw_ptr_client)(struct _cef_translator_test_t* self, int(CEF_CALLBACK* set_raw_ptr_client)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_t* val); struct _cef_translator_test_scoped_client_t* val);
/// ///
@ -500,26 +512,26 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_client_t::get_value(). This tests input of a // cef_translator_test_scoped_client_t::get_value(). This tests input of a
// client- side child object type and execution as the parent type. // client- side child object type and execution as the parent type.
/// ///
int (CEF_CALLBACK *set_child_raw_ptr_client)( int(CEF_CALLBACK* set_child_raw_ptr_client)(
struct _cef_translator_test_t* self, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_child_t* val); struct _cef_translator_test_scoped_client_child_t* val);
/// ///
// Set an object list vlaue. // Set an object list vlaue.
/// ///
int (CEF_CALLBACK *set_raw_ptr_client_list)( int(CEF_CALLBACK* set_raw_ptr_client_list)(
struct _cef_translator_test_t* self, size_t valCount, struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_t* const* val, int val1, size_t valCount,
struct _cef_translator_test_scoped_client_t* const* val,
int val1,
int val2); int val2);
} cef_translator_test_t; } cef_translator_test_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_t* cef_translator_test_create(); CEF_EXPORT cef_translator_test_t* cef_translator_test_create();
/// ///
// Library-side test object for RefPtr. // Library-side test object for RefPtr.
/// ///
@ -532,23 +544,22 @@ typedef struct _cef_translator_test_ref_ptr_library_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_value)( int(CEF_CALLBACK* get_value)(
struct _cef_translator_test_ref_ptr_library_t* self); struct _cef_translator_test_ref_ptr_library_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_value)( void(CEF_CALLBACK* set_value)(
struct _cef_translator_test_ref_ptr_library_t* self, int value); struct _cef_translator_test_ref_ptr_library_t* self,
int value);
} cef_translator_test_ref_ptr_library_t; } cef_translator_test_ref_ptr_library_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_ref_ptr_library_t* cef_translator_test_ref_ptr_library_create( CEF_EXPORT cef_translator_test_ref_ptr_library_t*
int value); cef_translator_test_ref_ptr_library_create(int value);
/// ///
// Library-side child test object for RefPtr. // Library-side child test object for RefPtr.
@ -562,23 +573,22 @@ typedef struct _cef_translator_test_ref_ptr_library_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_value)( int(CEF_CALLBACK* get_other_value)(
struct _cef_translator_test_ref_ptr_library_child_t* self); struct _cef_translator_test_ref_ptr_library_child_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_other_value)( void(CEF_CALLBACK* set_other_value)(
struct _cef_translator_test_ref_ptr_library_child_t* self, int value); struct _cef_translator_test_ref_ptr_library_child_t* self,
int value);
} cef_translator_test_ref_ptr_library_child_t; } cef_translator_test_ref_ptr_library_child_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_ref_ptr_library_child_t* cef_translator_test_ref_ptr_library_child_create( CEF_EXPORT cef_translator_test_ref_ptr_library_child_t*
int value, int other_value); cef_translator_test_ref_ptr_library_child_create(int value, int other_value);
/// ///
// Another library-side child test object for RefPtr. // Another library-side child test object for RefPtr.
@ -592,24 +602,24 @@ typedef struct _cef_translator_test_ref_ptr_library_child_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_other_value)( int(CEF_CALLBACK* get_other_other_value)(
struct _cef_translator_test_ref_ptr_library_child_child_t* self); struct _cef_translator_test_ref_ptr_library_child_child_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_other_other_value)( void(CEF_CALLBACK* set_other_other_value)(
struct _cef_translator_test_ref_ptr_library_child_child_t* self, struct _cef_translator_test_ref_ptr_library_child_child_t* self,
int value); int value);
} cef_translator_test_ref_ptr_library_child_child_t; } cef_translator_test_ref_ptr_library_child_child_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_ref_ptr_library_child_child_t* cef_translator_test_ref_ptr_library_child_child_create( CEF_EXPORT cef_translator_test_ref_ptr_library_child_child_t*
int value, int other_value, int other_other_value); cef_translator_test_ref_ptr_library_child_child_create(int value,
int other_value,
int other_other_value);
/// ///
// Client-side test object for RefPtr. // Client-side test object for RefPtr.
@ -623,11 +633,10 @@ typedef struct _cef_translator_test_ref_ptr_client_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_value)( int(CEF_CALLBACK* get_value)(
struct _cef_translator_test_ref_ptr_client_t* self); struct _cef_translator_test_ref_ptr_client_t* self);
} cef_translator_test_ref_ptr_client_t; } cef_translator_test_ref_ptr_client_t;
/// ///
// Client-side child test object for RefPtr. // Client-side child test object for RefPtr.
/// ///
@ -640,11 +649,10 @@ typedef struct _cef_translator_test_ref_ptr_client_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_value)( int(CEF_CALLBACK* get_other_value)(
struct _cef_translator_test_ref_ptr_client_child_t* self); struct _cef_translator_test_ref_ptr_client_child_t* self);
} cef_translator_test_ref_ptr_client_child_t; } cef_translator_test_ref_ptr_client_child_t;
/// ///
// Library-side test object for OwnPtr/RawPtr. // Library-side test object for OwnPtr/RawPtr.
/// ///
@ -657,23 +665,22 @@ typedef struct _cef_translator_test_scoped_library_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_value)( int(CEF_CALLBACK* get_value)(
struct _cef_translator_test_scoped_library_t* self); struct _cef_translator_test_scoped_library_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_value)( void(CEF_CALLBACK* set_value)(
struct _cef_translator_test_scoped_library_t* self, int value); struct _cef_translator_test_scoped_library_t* self,
int value);
} cef_translator_test_scoped_library_t; } cef_translator_test_scoped_library_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_scoped_library_t* cef_translator_test_scoped_library_create( CEF_EXPORT cef_translator_test_scoped_library_t*
int value); cef_translator_test_scoped_library_create(int value);
/// ///
// Library-side child test object for OwnPtr/RawPtr. // Library-side child test object for OwnPtr/RawPtr.
@ -687,23 +694,22 @@ typedef struct _cef_translator_test_scoped_library_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_value)( int(CEF_CALLBACK* get_other_value)(
struct _cef_translator_test_scoped_library_child_t* self); struct _cef_translator_test_scoped_library_child_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_other_value)( void(CEF_CALLBACK* set_other_value)(
struct _cef_translator_test_scoped_library_child_t* self, int value); struct _cef_translator_test_scoped_library_child_t* self,
int value);
} cef_translator_test_scoped_library_child_t; } cef_translator_test_scoped_library_child_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_scoped_library_child_t* cef_translator_test_scoped_library_child_create( CEF_EXPORT cef_translator_test_scoped_library_child_t*
int value, int other_value); cef_translator_test_scoped_library_child_create(int value, int other_value);
/// ///
// Another library-side child test object for OwnPtr/RawPtr. // Another library-side child test object for OwnPtr/RawPtr.
@ -717,24 +723,24 @@ typedef struct _cef_translator_test_scoped_library_child_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_other_value)( int(CEF_CALLBACK* get_other_other_value)(
struct _cef_translator_test_scoped_library_child_child_t* self); struct _cef_translator_test_scoped_library_child_child_t* self);
/// ///
// Set a value. // Set a value.
/// ///
void (CEF_CALLBACK *set_other_other_value)( void(CEF_CALLBACK* set_other_other_value)(
struct _cef_translator_test_scoped_library_child_child_t* self, struct _cef_translator_test_scoped_library_child_child_t* self,
int value); int value);
} cef_translator_test_scoped_library_child_child_t; } cef_translator_test_scoped_library_child_child_t;
/// ///
// Create the test object. // Create the test object.
/// ///
CEF_EXPORT cef_translator_test_scoped_library_child_child_t* cef_translator_test_scoped_library_child_child_create( CEF_EXPORT cef_translator_test_scoped_library_child_child_t*
int value, int other_value, int other_other_value); cef_translator_test_scoped_library_child_child_create(int value,
int other_value,
int other_other_value);
/// ///
// Client-side test object for OwnPtr/RawPtr. // Client-side test object for OwnPtr/RawPtr.
@ -748,11 +754,10 @@ typedef struct _cef_translator_test_scoped_client_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_value)( int(CEF_CALLBACK* get_value)(
struct _cef_translator_test_scoped_client_t* self); struct _cef_translator_test_scoped_client_t* self);
} cef_translator_test_scoped_client_t; } cef_translator_test_scoped_client_t;
/// ///
// Client-side child test object for OwnPtr/RawPtr. // Client-side child test object for OwnPtr/RawPtr.
/// ///
@ -765,11 +770,10 @@ typedef struct _cef_translator_test_scoped_client_child_t {
/// ///
// Return a value. // Return a value.
/// ///
int (CEF_CALLBACK *get_other_value)( int(CEF_CALLBACK* get_other_value)(
struct _cef_translator_test_scoped_client_child_t* self); struct _cef_translator_test_scoped_client_child_t* self);
} cef_translator_test_scoped_client_child_t; } cef_translator_test_scoped_client_child_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

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