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

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
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
# more information.
#
# $hash=9b613878ab9c9f72136f890b1df4a145d6341790$
#
{
'variables': {

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.
Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 increment);
Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
// These following lower-level operations are typically useful only to people
// 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
// <inttypes.h> format macros even in the LP64 model.
#if defined(__LP64__) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
typedef long int64; // NOLINT(runtime/int)
typedef unsigned long uint64; // NOLINT(runtime/int)
typedef long int64;
typedef unsigned long uint64;
#else
typedef long long int64; // NOLINT(runtime/int)
typedef unsigned long long uint64; // NOLINT(runtime/int)
typedef long long int64;
typedef unsigned long long uint64;
#endif
// TODO: Remove these type guards. These are to avoid conflicts with

209
include/base/cef_bind.h
View File

@ -89,34 +89,32 @@
namespace base {
template <typename Functor>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void()>
::UnboundRunType>
void()>::UnboundRunType>
Bind(Functor 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 cef_internal::BindState<RunnableType, RunType, void()> BindState;
return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor)));
}
template <typename Functor, typename P1>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
::UnboundRunType>
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>::
UnboundRunType>
Bind(Functor functor, const P1& p1) {
// 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;
// Use RunnableType::RunType instead of RunType above because our
@ -138,32 +136,32 @@ Bind(Functor functor, const P1& p1) {
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
typedef cef_internal::BindState<RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)> BindState;
typedef cef_internal::BindState<
RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1));
}
template <typename Functor, typename P1, typename P2>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType)>
::UnboundRunType>
typename cef_internal::CallbackParamTraits<P2>::StorageType)>::
UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2) {
// 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;
// Use RunnableType::RunType instead of RunType above because our
@ -186,8 +184,7 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
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,
typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState;
typename cef_internal::CallbackParamTraits<P2>::StorageType)>
BindState;
return Callback<typename BindState::UnboundRunType>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2));
}
template <typename Functor, typename P1, typename P2, typename P3>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType)>
::UnboundRunType>
typename cef_internal::CallbackParamTraits<P3>::StorageType)>::
UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
// 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;
// Use RunnableType::RunType instead of RunType above because our
@ -239,8 +237,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
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,
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>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType)>
::UnboundRunType>
typename cef_internal::CallbackParamTraits<P4>::StorageType)>::
UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
// 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;
// Use RunnableType::RunType instead of RunType above because our
@ -297,8 +295,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
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,
typename cef_internal::CallbackParamTraits<P2>::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>(
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>
base::Callback<
typename cef_internal::BindState<
base::Callback<typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType)>
::UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
typename cef_internal::CallbackParamTraits<P5>::StorageType)>::
UnboundRunType>
Bind(Functor functor,
const P1& p1,
const P2& p2,
const P3& p3,
const P4& p4,
const P5& p5) {
// 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;
// Use RunnableType::RunType instead of RunType above because our
@ -362,8 +368,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
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,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::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>(
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6>
base::Callback<
typename cef_internal::BindState<
template <typename Functor,
typename P1,
typename P2,
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>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@ -400,12 +410,18 @@ base::Callback<
typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType)>
::UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
const P5& p5, const P6& p6) {
typename cef_internal::CallbackParamTraits<P6>::StorageType)>::
UnboundRunType>
Bind(Functor functor,
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.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our
@ -432,8 +448,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
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,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::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(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
return Callback<typename BindState::UnboundRunType>(new BindState(
cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6, typename P7>
base::Callback<
typename cef_internal::BindState<
template <typename Functor,
typename P1,
typename P2,
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>::RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
@ -474,12 +495,19 @@ base::Callback<
typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::StorageType,
typename cef_internal::CallbackParamTraits<P6>::StorageType,
typename cef_internal::CallbackParamTraits<P7>::StorageType)>
::UnboundRunType>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
const P5& p5, const P6& p6, const P7& p7) {
typename cef_internal::CallbackParamTraits<P7>::StorageType)>::
UnboundRunType>
Bind(Functor functor,
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.
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef
typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
// Use RunnableType::RunType instead of RunType above because our
@ -507,8 +535,7 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// a scoped_refptr because BindState<> itself takes care of AddRef() for
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
cef_internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
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);
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
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,
typename cef_internal::CallbackParamTraits<P2>::StorageType,
typename cef_internal::CallbackParamTraits<P3>::StorageType,
typename cef_internal::CallbackParamTraits<P4>::StorageType,
typename cef_internal::CallbackParamTraits<P5>::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(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
p7));
return Callback<typename BindState::UnboundRunType>(new BindState(
cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6, p7));
}
} // namespace base

35
include/base/cef_bind_helpers.h
View File

@ -276,13 +276,13 @@ class SupportsAddRefAndRelease {
#pragma warning(push)
#pragma warning(disable : 4624)
#endif
struct Base : public T, public BaseMixin {
};
struct Base : public T, public BaseMixin {};
#if defined(OS_WIN)
#pragma warning(pop)
#endif
template <void(BaseMixin::*)(void)> struct Helper {};
template <void (BaseMixin::*)(void)>
struct Helper {};
template <typename C>
static No& Check(Helper<&C::AddRef>*);
@ -297,22 +297,18 @@ class SupportsAddRefAndRelease {
// Helpers to assert that arguments of a recounted type are bound with a
// scoped_refptr.
template <bool IsClasstype, typename T>
struct UnsafeBindtoRefCountedArgHelper : false_type {
};
struct UnsafeBindtoRefCountedArgHelper : false_type {};
template <typename T>
struct UnsafeBindtoRefCountedArgHelper<true, T>
: integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
};
: integral_constant<bool, SupportsAddRefAndRelease<T>::value> {};
template <typename T>
struct UnsafeBindtoRefCountedArg : false_type {
};
struct UnsafeBindtoRefCountedArg : false_type {};
template <typename T>
struct UnsafeBindtoRefCountedArg<T*>
: UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
};
: UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {};
template <typename T>
class HasIsMethodTag {
@ -334,6 +330,7 @@ class UnretainedWrapper {
public:
explicit UnretainedWrapper(T* o) : ptr_(o) {}
T* get() const { return ptr_; }
private:
T* ptr_;
};
@ -343,6 +340,7 @@ class ConstRefWrapper {
public:
explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
const T& get() const { return *ptr_; }
private:
const T* ptr_;
};
@ -409,8 +407,7 @@ class PassedWrapper {
public:
explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
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 {
CHECK(is_valid_);
is_valid_ = false;
@ -460,17 +457,13 @@ struct UnwrapTraits<WeakPtr<T> > {
template <typename T>
struct UnwrapTraits<OwnedWrapper<T>> {
typedef T* ForwardType;
static ForwardType Unwrap(const OwnedWrapper<T>& o) {
return o.get();
}
static ForwardType Unwrap(const OwnedWrapper<T>& o) { return o.get(); }
};
template <typename T>
struct UnwrapTraits<PassedWrapper<T>> {
typedef T ForwardType;
static T Unwrap(PassedWrapper<T>& o) {
return o.Pass();
}
static T Unwrap(PassedWrapper<T>& o) { return o.Pass(); }
};
// Utility for handling different refcounting semantics in the Bind()
@ -567,8 +560,8 @@ static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
}
template <typename T>
static inline cef_internal::IgnoreResultHelper<Callback<T> >
IgnoreResult(const Callback<T>& data) {
static inline cef_internal::IgnoreResultHelper<Callback<T>> IgnoreResult(
const Callback<T>& data) {
return cef_internal::IgnoreResultHelper<Callback<T>>(data);
}

10
include/base/cef_build.h
View File

@ -27,7 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CEF_INCLUDE_BASE_CEF_BUILD_H_
#define CEF_INCLUDE_BASE_CEF_BUILD_H_
#pragma once
@ -116,12 +115,10 @@
// Type detection for wchar_t.
#if defined(OS_WIN)
#define WCHAR_T_IS_UTF16
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
defined(__WCHAR_MAX__) && \
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
(__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
#define WCHAR_T_IS_UTF32
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
defined(__WCHAR_MAX__) && \
#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
(__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
// 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
@ -191,8 +188,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
#if __cplusplus > 199711L || \
(defined(_MSC_VER) && _MSC_VER >= 1800) || \
#if __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER >= 1800) || \
(defined(__GNUC__) && \
(__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ >= 40700))
#define HAS_CPP11_TEMPLATE_ALIAS_SUPPORT

144
include/base/cef_callback.h
View File

@ -45,9 +45,9 @@
// If the Chromium implementation diverges the below implementation should be
// updated to match.
#include "include/base/internal/cef_callback_internal.h"
#include "include/base/cef_callback_forward.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
// Closure should #include "base/cef_callback_forward.h" instead of this file.
@ -412,16 +412,15 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -437,9 +436,7 @@ class Callback<R(void)> : public cef_internal::CallbackBase {
}
private:
typedef R(*PolymorphicInvoke)(
cef_internal::BindStateBase*);
typedef R (*PolymorphicInvoke)(cef_internal::BindStateBase*);
};
template <typename R, typename A1>
@ -452,16 +449,15 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -480,7 +476,6 @@ class Callback<R(A1)> : public cef_internal::CallbackBase {
typedef R (*PolymorphicInvoke)(
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType);
};
template <typename R, typename A1, typename A2>
@ -493,16 +488,15 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -524,7 +518,6 @@ class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType);
};
template <typename R, typename A1, typename A2, typename A3>
@ -537,16 +530,15 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -571,7 +563,6 @@ class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType);
};
template <typename R, typename A1, typename A2, typename A3, typename A4>
@ -584,16 +575,15 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -621,10 +611,13 @@ class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::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>
class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
public:
@ -635,16 +628,15 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -660,11 +652,10 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2),
cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4),
cef_internal::CallbackForward(a5));
return f(
bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5));
}
private:
@ -675,11 +666,15 @@ class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
typename cef_internal::CallbackParamTraits<A3>::ForwardType,
typename cef_internal::CallbackParamTraits<A4>::ForwardType,
typename cef_internal::CallbackParamTraits<A5>::ForwardType);
};
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6>
template <typename R,
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 {
public:
typedef R(RunType)(A1, A2, A3, A4, A5, A6);
@ -689,16 +684,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -715,11 +709,10 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2),
cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4),
cef_internal::CallbackForward(a5),
return f(
bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a6));
}
@ -732,12 +725,18 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
typename cef_internal::CallbackParamTraits<A4>::ForwardType,
typename cef_internal::CallbackParamTraits<A5>::ForwardType,
typename cef_internal::CallbackParamTraits<A6>::ForwardType);
};
template <typename R, typename A1, 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 {
template <typename R,
typename A1,
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:
typedef R(RunType)(A1, A2, A3, A4, A5, A6, A7);
@ -746,16 +745,15 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
// Note that this constructor CANNOT be explicit, and that Bind() CANNOT
// return the exact Callback<> type. See base/bind.h for details.
template <typename Runnable, typename BindRunType, typename BoundArgsType>
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
Callback(
cef_internal::BindState<Runnable, BindRunType, BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
// Force the assignment to a local variable of PolymorphicInvoke
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
&cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@ -773,13 +771,11 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public cef_internal::CallbackBas
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2),
cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4),
cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a6),
cef_internal::CallbackForward(a7));
return f(
bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2), cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4), cef_internal::CallbackForward(a5),
cef_internal::CallbackForward(a6), cef_internal::CallbackForward(a7));
}
private:
@ -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<A6>::ForwardType,
typename cef_internal::CallbackParamTraits<A7>::ForwardType);
};
// Syntactic sugar to make Callbacks<void(void)> easier to declare since it
// will be used in a lot of APIs with delayed execution.
typedef Callback<void(void)> Closure;

47
include/base/cef_callback_list.h
View File

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

47
include/base/cef_cancelable_callback.h
View File

@ -83,8 +83,8 @@
// updated to match.
#include "include/base/cef_bind.h"
#include "include/base/cef_callback.h"
#include "include/base/cef_build.h"
#include "include/base/cef_callback.h"
#include "include/base/cef_logging.h"
#include "include/base/cef_macros.h"
#include "include/base/cef_weak_ptr.h"
@ -102,8 +102,7 @@ class CancelableCallback<void(void)> {
// |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(void)>& callback)
: weak_factory_(this),
callback_(callback) {
: weak_factory_(this), callback_(callback) {
DCHECK(!callback.is_null());
InitializeForwarder();
}
@ -118,9 +117,7 @@ class CancelableCallback<void(void)> {
}
// Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const {
return callback_.is_null();
}
bool IsCancelled() const { return callback_.is_null(); }
// Sets |callback| as the closure that may be cancelled. |callback| may not
// 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().
const base::Callback<void(void)>& callback() const {
return forwarder_;
}
const base::Callback<void(void)>& callback() const { return forwarder_; }
private:
void Forward() {
callback_.Run();
}
void Forward() { callback_.Run(); }
// Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|.
@ -172,8 +165,7 @@ class CancelableCallback<void(A1)> {
// |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(A1)>& callback)
: weak_factory_(this),
callback_(callback) {
: weak_factory_(this), callback_(callback) {
DCHECK(!callback.is_null());
InitializeForwarder();
}
@ -188,9 +180,7 @@ class CancelableCallback<void(A1)> {
}
// Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const {
return callback_.is_null();
}
bool IsCancelled() const { return callback_.is_null(); }
// Sets |callback| as the closure that may be cancelled. |callback| may not
// 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().
const base::Callback<void(A1)>& callback() const {
return forwarder_;
}
const base::Callback<void(A1)>& callback() const { return forwarder_; }
private:
void Forward(A1 a1) const {
callback_.Run(a1);
}
void Forward(A1 a1) const { callback_.Run(a1); }
// Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|.
@ -242,8 +228,7 @@ class CancelableCallback<void(A1, A2)> {
// |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(A1, A2)>& callback)
: weak_factory_(this),
callback_(callback) {
: weak_factory_(this), callback_(callback) {
DCHECK(!callback.is_null());
InitializeForwarder();
}
@ -258,9 +243,7 @@ class CancelableCallback<void(A1, A2)> {
}
// Returns true if the wrapped callback has been cancelled.
bool IsCancelled() const {
return callback_.is_null();
}
bool IsCancelled() const { return callback_.is_null(); }
// Sets |callback| as the closure that may be cancelled. |callback| may not
// 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().
const base::Callback<void(A1, A2)>& callback() const {
return forwarder_;
}
const base::Callback<void(A1, A2)>& callback() const { return forwarder_; }
private:
void Forward(A1 a1, A2 a2) const {
callback_.Run(a1, a2);
}
void Forward(A1 a1, A2 a2) const { callback_.Run(a1, a2); }
// Helper method to bind |forwarder_| using a weak pointer from
// |weak_factory_|.

8
include/base/cef_lock.h
View File

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

104
include/base/cef_logging.h
View File

@ -158,9 +158,9 @@
// updated to match.
#include <cassert>
#include <string>
#include <cstring>
#include <sstream>
#include <string>
#include "include/base/cef_build.h"
#include "include/base/cef_macros.h"
@ -217,16 +217,11 @@ const LogSeverity LOG_DFATAL = LOG_FATAL;
cef::logging::ClassName(__FILE__, __LINE__, cef::logging::LOG_DFATAL, \
##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_INFO \
COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
#define COMPACT_GOOGLE_LOG_WARNING \
COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
#define COMPACT_GOOGLE_LOG_ERROR \
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)
#define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
#define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
#define COMPACT_GOOGLE_LOG_ERROR 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)
// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
@ -291,11 +286,13 @@ const LogSeverity LOG_0 = LOG_ERROR;
#if defined(OS_WIN)
#define VPLOG_STREAM(verbose_level) \
cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
::cef::logging::GetLastSystemErrorCode()).stream()
::cef::logging::GetLastSystemErrorCode()) \
.stream()
#elif defined(OS_POSIX)
#define VPLOG_STREAM(verbose_level) \
cef::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
::cef::logging::GetLastSystemErrorCode()).stream()
::cef::logging::GetLastSystemErrorCode()) \
.stream()
#endif
#define VPLOG(verbose_level) \
@ -315,15 +312,16 @@ const LogSeverity LOG_0 = LOG_ERROR;
#if defined(OS_WIN)
#define PLOG_STREAM(severity) \
COMPACT_GOOGLE_LOG_EX_##severity(Win32ErrorLogMessage, \
::cef::logging::GetLastSystemErrorCode()).stream()
::cef::logging::GetLastSystemErrorCode()) \
.stream()
#elif defined(OS_POSIX)
#define PLOG_STREAM(severity) \
COMPACT_GOOGLE_LOG_EX_##severity(ErrnoLogMessage, \
::cef::logging::GetLastSystemErrorCode()).stream()
::cef::logging::GetLastSystemErrorCode()) \
.stream()
#endif
#define PLOG(severity) \
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
#define PLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
#define PLOG_IF(severity, condition) \
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
@ -353,9 +351,8 @@ const LogSeverity LOG_0 = LOG_ERROR;
// TODO(akalin): Rewrite this so that constructs like if (...)
// CHECK_EQ(...) else { ... } work properly.
#define CHECK_OP(name, op, val1, val2) \
if (std::string* _result = \
cef::logging::Check##name##Impl((val1), (val2), \
#val1 " " #op " " #val2)) \
if (std::string* _result = cef::logging::Check##name##Impl( \
(val1), (val2), #val1 " " #op " " #val2)) \
cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()
// Build the error message string. This is separate from the "Impl"
@ -374,20 +371,25 @@ std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
#if !defined(COMPILER_MSVC)
// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
// in logging.cc.
extern template std::string* MakeCheckOpString<int, int>(
const int&, const int&, const char* names);
extern template
std::string* MakeCheckOpString<unsigned long, unsigned long>(
const unsigned long&, const unsigned long&, const char* names);
extern template
std::string* MakeCheckOpString<unsigned long, unsigned int>(
const unsigned long&, const unsigned int&, const char* names);
extern template
std::string* MakeCheckOpString<unsigned int, unsigned long>(
const unsigned int&, const unsigned long&, const char* names);
extern template
std::string* MakeCheckOpString<std::string, std::string>(
const std::string&, const std::string&, const char* name);
extern template std::string* MakeCheckOpString<int, int>(const int&,
const int&,
const char* names);
extern template std::string* MakeCheckOpString<unsigned long, unsigned long>(
const unsigned long&,
const unsigned long&,
const char* names);
extern template std::string* MakeCheckOpString<unsigned long, unsigned int>(
const unsigned long&,
const unsigned int&,
const char* names);
extern template std::string* MakeCheckOpString<unsigned int, unsigned long>(
const unsigned int&,
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
// Helper functions for CHECK_OP macro.
@ -398,12 +400,16 @@ std::string* MakeCheckOpString<std::string, std::string>(
template <class t1, class t2> \
inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
const char* names) { \
if (v1 op v2) return NULL; \
else return MakeCheckOpString(v1, v2, names); \
if (v1 op v2) \
return NULL; \
else \
return MakeCheckOpString(v1, v2, names); \
} \
inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
if (v1 op v2) return NULL; \
else return MakeCheckOpString(v1, v2, names); \
if (v1 op v2) \
return NULL; \
else \
return MakeCheckOpString(v1, v2, names); \
}
DEFINE_CHECK_OP_IMPL(EQ, ==)
DEFINE_CHECK_OP_IMPL(NE, !=)
@ -471,11 +477,9 @@ enum { DEBUG_MODE = ENABLE_DLOG };
#undef ENABLE_DLOG
#define DLOG(severity) \
LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
#define DLOG(severity) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
#define DPLOG(severity) \
LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
#define DPLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
@ -519,8 +523,9 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
if (DCHECK_IS_ON()) \
if (std::string* _result = cef::logging::Check##name##Impl( \
(val1), (val2), #val1 " " #op " " #val2)) \
cef::logging::LogMessage(__FILE__, __LINE__, \
::cef::logging::LOG_DCHECK, _result).stream()
cef::logging::LogMessage(__FILE__, __LINE__, ::cef::logging::LOG_DCHECK, \
_result) \
.stream()
// Equality/Inequality checks - compare two values, and log a
// LOG_DCHECK message including the two values when the result is not
@ -549,8 +554,8 @@ const LogSeverity LOG_DCHECK = LOG_INFO;
#define DCHECK_GT(val1, val2) DCHECK_OP(GT, >, val1, val2)
#if defined(NDEBUG) && defined(OS_CHROMEOS)
#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \
__FUNCTION__ << ". "
#define NOTREACHED() \
LOG(ERROR) << "NOTREACHED() hit in " << __FUNCTION__ << ". "
#else
#define NOTREACHED() DCHECK(false)
#endif
@ -577,7 +582,9 @@ class LogMessage {
LogMessage(const char* file, int line, std::string* result);
// 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);
~LogMessage();
@ -739,7 +746,8 @@ inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
#elif NOTIMPLEMENTED_POLICY == 4
#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
#elif NOTIMPLEMENTED_POLICY == 5
#define NOTIMPLEMENTED() do {\
#define NOTIMPLEMENTED() \
do { \
static bool logged_once = false; \
LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
logged_once = true; \

17
include/base/cef_macros.h
View File

@ -126,14 +126,13 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
namespace cef {
template <bool>
struct CompileAssert {
};
struct CompileAssert {};
} // namespace cef
#define COMPILE_ASSERT(expr, msg) \
typedef cef::CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] \
ALLOW_UNUSED_TYPE
typedef cef::CompileAssert<(bool(expr))> \
msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE
// 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.
// The warning remains disabled until popped by MSVC_POP_WARNING.
#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
__pragma(warning(disable:n))
#define MSVC_PUSH_DISABLE_WARNING(n) \
__pragma(warning(push)) __pragma(warning(disable : n))
// 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
@ -207,9 +206,9 @@ struct CompileAssert {
//
// Compiler warning C4355: 'this': used in base member initializer list:
// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
#define ALLOW_THIS_IN_INITIALIZER_LIST(code) MSVC_PUSH_DISABLE_WARNING(4355) \
code \
MSVC_POP_WARNING()
#define ALLOW_THIS_IN_INITIALIZER_LIST(code) \
MSVC_PUSH_DISABLE_WARNING(4355) \
code MSVC_POP_WARNING()
#else // !COMPILER_MSVC
#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code

2
include/base/cef_move.h
View File

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

17
include/base/cef_platform_thread.h
View File

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

26
include/base/cef_ref_counted.h
View File

@ -65,7 +65,8 @@ class RefCountedBase {
RefCountedBase()
: ref_count_(0)
#if DCHECK_IS_ON()
, in_dtor_(false)
,
in_dtor_(false)
#endif
{
}
@ -76,7 +77,6 @@ class RefCountedBase {
#endif
}
void AddRef() const {
// TODO(maruel): Add back once it doesn't assert 500 times/sec.
// Current thread books the critical section "AddRelease"
@ -160,9 +160,7 @@ class RefCounted : public cef_subtle::RefCountedBase {
public:
RefCounted() {}
void AddRef() const {
cef_subtle::RefCountedBase::AddRef();
}
void AddRef() const { cef_subtle::RefCountedBase::AddRef(); }
void Release() const {
if (cef_subtle::RefCountedBase::Release()) {
@ -178,7 +176,8 @@ class RefCounted : public cef_subtle::RefCountedBase {
};
// 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
// count reaches 0. Overload to delete it on a different thread etc.
@ -188,8 +187,8 @@ struct DefaultRefCountedThreadSafeTraits {
// Delete through RefCountedThreadSafe to make child classes only need to be
// friend with RefCountedThreadSafe instead of this struct, which is an
// implementation detail.
RefCountedThreadSafe<T,
DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
RefCountedThreadSafe<T, DefaultRefCountedThreadSafeTraits>::DeleteInternal(
x);
}
};
@ -210,9 +209,7 @@ class RefCountedThreadSafe : public cef_subtle::RefCountedThreadSafeBase {
public:
RefCountedThreadSafe() {}
void AddRef() const {
cef_subtle::RefCountedThreadSafeBase::AddRef();
}
void AddRef() const { cef_subtle::RefCountedThreadSafeBase::AddRef(); }
void Release() const {
if (cef_subtle::RefCountedThreadSafeBase::Release()) {
@ -303,8 +300,7 @@ class scoped_refptr {
public:
typedef T element_type;
scoped_refptr() : ptr_(NULL) {
}
scoped_refptr() : ptr_(NULL) {}
scoped_refptr(T* p) : ptr_(p) {
if (ptr_)
@ -364,9 +360,7 @@ class scoped_refptr {
*pp = p;
}
void swap(scoped_refptr<T>& r) {
swap(&r.ptr_);
}
void swap(scoped_refptr<T>& r) { swap(&r.ptr_); }
protected:
T* ptr_;

60
include/base/cef_scoped_ptr.h
View File

@ -154,7 +154,8 @@ class RefCountedThreadSafeBase;
template <class T>
struct 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
// if U* is implicitly convertible to T* and U is not an array type.
//
@ -194,7 +195,8 @@ struct DefaultDeleter<T[]> {
// References:
// C++98 [expr.delete]p3
// 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>
@ -209,18 +211,18 @@ struct DefaultDeleter<T[n]> {
// scoped_ptr<int, base::FreeDeleter> foo_ptr(
// static_cast<int*>(malloc(sizeof(int))));
struct FreeDeleter {
inline void operator()(void* ptr) const {
free(ptr);
}
inline void operator()(void* ptr) const { free(ptr); }
};
namespace cef_internal {
template <typename T> struct IsNotRefCounted {
template <typename T>
struct IsNotRefCounted {
enum {
value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
!base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
value
value =
!base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
!base::is_convertible<T*,
base::subtle::RefCountedThreadSafeBase*>::value
};
};
@ -309,7 +311,8 @@ class scoped_ptr_impl {
private:
// 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
// member, while avoiding any space overhead for it when D is an
@ -443,18 +446,14 @@ class scoped_ptr {
bool operator!=(const element_type* p) const { return impl_.get() != p; }
// Swap two scoped pointers.
void swap(scoped_ptr& p2) {
impl_.swap(p2.impl_);
}
void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
// Release a pointer.
// The return value is the current pointer held by this object.
// If this object holds a NULL pointer, the return value is NULL.
// After this operation, this object will hold a NULL pointer,
// and will not own the object any more.
element_type* release() WARN_UNUSED_RESULT {
return impl_.release();
}
element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
// C++98 doesn't support functions templates with default parameters which
// makes it hard to write a PassAs() that understands converting the deleter
@ -469,7 +468,8 @@ class scoped_ptr {
private:
// 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_;
// 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
// because you should never have the same object owned by two different
// scoped_ptrs.
template <class U> bool operator==(scoped_ptr<U> const& p2) const;
template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
template <class U>
bool operator==(scoped_ptr<U> const& p2) const;
template <class U>
bool operator!=(scoped_ptr<U> const& p2) const;
};
template <class T, class D>
@ -553,18 +555,14 @@ class scoped_ptr<T[], D> {
bool operator!=(element_type* array) const { return impl_.get() != array; }
// Swap two scoped pointers.
void swap(scoped_ptr& p2) {
impl_.swap(p2.impl_);
}
void swap(scoped_ptr& p2) { impl_.swap(p2.impl_); }
// Release a pointer.
// The return value is the current pointer held by this object.
// If this object holds a NULL pointer, the return value is NULL.
// After this operation, this object will hold a NULL pointer,
// and will not own the object any more.
element_type* release() WARN_UNUSED_RESULT {
return impl_.release();
}
element_type* release() WARN_UNUSED_RESULT { return impl_.release(); }
private:
// 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
// call delete[] on an array whose static type does not match its dynamic
// 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);
// Disable reset() from any type other than element_type*, for the same
// 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);
// 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
// because you should never have the same object owned by two different
// scoped_ptrs.
template <class U> bool operator==(scoped_ptr<U> const& p2) const;
template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
template <class U>
bool operator==(scoped_ptr<U> const& p2) const;
template <class U>
bool operator!=(scoped_ptr<U> const& p2) const;
};
// Free functions

35
include/base/cef_string16.h
View File

@ -112,26 +112,19 @@ struct string16_char_traits {
typedef mbstate_t state_type;
typedef std::fpos<state_type> pos_type;
static void assign(char_type& c1, const char_type& c2) {
c1 = c2;
}
static void assign(char_type& c1, const char_type& c2) { c1 = c2; }
static bool eq(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 bool eq(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) {
return c16memcmp(s1, s2, n);
}
static size_t length(const char_type* s) {
return c16len(s);
}
static size_t length(const char_type* 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) {
return c16memchr(s, a, n);
}
@ -152,21 +145,15 @@ struct string16_char_traits {
return eq_int_type(c, eof()) ? 0 : c;
}
static char_type to_char_type(const int_type& c) {
return char_type(c);
}
static char_type to_char_type(const int_type& c) { return char_type(c); }
static int_type to_int_type(const char_type& c) {
return int_type(c);
}
static int_type to_int_type(const char_type& c) { return int_type(c); }
static bool eq_int_type(const int_type& c1, const int_type& c2) {
return c1 == c2;
}
static int_type eof() {
return static_cast<int_type>(EOF);
}
static int_type eof() { return static_cast<int_type>(EOF); }
};
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.
extern template
class std::basic_string<base::char16, base::string16_char_traits>;
extern template class std::basic_string<base::char16,
base::string16_char_traits>;
#endif // WCHAR_T_IS_UTF32

68
include/base/cef_template_util.h
View File

@ -60,13 +60,16 @@ struct integral_constant {
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, false> false_type;
template <class T> struct is_pointer : false_type {};
template <class T> struct is_pointer<T*> : true_type {};
template <class T>
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
// below. This is built-in to C++ 11, and we can remove this when we switch.
@ -93,30 +96,49 @@ struct is_member_function_pointer<R(Z::*)(A, B, C)> : true_type {};
template <typename R, typename Z, typename A, typename B, typename C>
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>
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>
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 T> struct is_same<T,T> : true_type {};
template <class>
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, size_t n> struct is_array<T[n]> : public true_type {};
template<class T> struct is_array<T[]> : public true_type {};
template <class T>
struct is_non_const_reference : false_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> 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_const : false_type {};
template <class T>
struct is_const<const T> : true_type {};
template <class T> struct is_const : false_type {};
template <class T> struct is_const<const T> : true_type {};
template <class T> struct is_void : false_type {};
template <> struct is_void<void> : true_type {};
template <class T>
struct is_void : false_type {};
template <>
struct is_void<void> : true_type {};
namespace cef_internal {
@ -169,21 +191,21 @@ struct is_convertible
: integral_constant<bool,
sizeof(cef_internal::ConvertHelper::Test<To>(
cef_internal::ConvertHelper::Create<From>())) ==
sizeof(cef_internal::YesType)> {
};
sizeof(cef_internal::YesType)> {};
template <typename T>
struct is_class
: integral_constant<bool,
sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
sizeof(cef_internal::YesType)> {
};
sizeof(cef_internal::YesType)> {};
template <bool B, class T = void>
struct enable_if {};
template <class T>
struct enable_if<true, T> { typedef T type; };
struct enable_if<true, T> {
typedef T type;
};
} // namespace base

11
include/base/cef_thread_checker.h
View File

@ -58,7 +58,6 @@
#define ENABLE_THREAD_CHECKER 0
#endif
namespace base {
namespace cef_internal {
@ -69,9 +68,7 @@ namespace cef_internal {
// right version for your build configuration.
class ThreadCheckerDoNothing {
public:
bool CalledOnValidThread() const {
return true;
}
bool CalledOnValidThread() const { return true; }
void DetachFromThread() {}
};
@ -110,11 +107,9 @@ class ThreadCheckerDoNothing {
//
// In Release mode, CalledOnValidThread will always return true.
#if ENABLE_THREAD_CHECKER
class ThreadChecker : public cef_internal::ThreadCheckerImpl {
};
class ThreadChecker : public cef_internal::ThreadCheckerImpl {};
#else
class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {
};
class ThreadChecker : public cef_internal::ThreadCheckerDoNothing {};
#endif // 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_);
// };
#if DCHECK_IS_ON()
// Defines a class member that acts like a mutex. It is used only as a
// verification tool.
#define DFAKE_MUTEX(obj) \
mutable base::ThreadCollisionWarner obj
#define DFAKE_MUTEX(obj) mutable base::ThreadCollisionWarner obj
// Asserts the call is never called simultaneously in two threads. Used at
// member function scope.
#define DFAKE_SCOPED_LOCK(obj) \
@ -187,13 +185,9 @@ class ThreadCollisionWarner {
public:
// The parameter asserter is there only for test purpose
explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
: valid_thread_id_(0),
counter_(0),
asserter_(asserter) {}
: valid_thread_id_(0), counter_(0), asserter_(asserter) {}
~ThreadCollisionWarner() {
delete asserter_;
}
~ThreadCollisionWarner() { delete asserter_; }
// This class is meant to be used through the macro
// DFAKE_SCOPED_LOCK_THREAD_LOCKED
@ -202,8 +196,7 @@ class ThreadCollisionWarner {
// from one thread
class Check {
public:
explicit Check(ThreadCollisionWarner* warner)
: warner_(warner) {
explicit Check(ThreadCollisionWarner* warner) : warner_(warner) {
warner_->EnterSelf();
}
@ -219,14 +212,11 @@ class ThreadCollisionWarner {
// DFAKE_SCOPED_LOCK
class ScopedCheck {
public:
explicit ScopedCheck(ThreadCollisionWarner* warner)
: warner_(warner) {
explicit ScopedCheck(ThreadCollisionWarner* warner) : warner_(warner) {
warner_->Enter();
}
~ScopedCheck() {
warner_->Leave();
}
~ScopedCheck() { warner_->Leave(); }
private:
ThreadCollisionWarner* warner_;
@ -243,9 +233,7 @@ class ThreadCollisionWarner {
warner_->EnterSelf();
}
~ScopedRecursiveCheck() {
warner_->Leave();
}
~ScopedRecursiveCheck() { warner_->Leave(); }
private:
ThreadCollisionWarner* warner_;

75
include/base/cef_trace_event.h
View File

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

947
include/base/cef_tuple.h
View File

File diff suppressed because it is too large Load Diff

47
include/base/cef_weak_ptr.h
View File

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

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

@ -103,7 +103,8 @@ inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
// reloop = 0
// if (prev_value != old_value)
// reloop = STREX(ptr, new_value)
__asm__ __volatile__(" ldrex %0, [%3]\n"
__asm__ __volatile__(
" ldrex %0, [%3]\n"
" mov %1, #0\n"
" cmp %0, %4\n"
#ifdef __thumb2__
@ -143,7 +144,8 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
// value += increment
// reloop = STREX(ptr, value)
//
__asm__ __volatile__(" ldrex %0, [%3]\n"
__asm__ __volatile__(
" ldrex %0, [%3]\n"
" add %0, %0, %4\n"
" strex %1, %0, [%3]\n"
: "=&r"(value), "=&r"(reloop), "+m"(*ptr)
@ -171,7 +173,8 @@ inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
do {
// old_value = LDREX(ptr)
// reloop = STREX(ptr, new_value)
__asm__ __volatile__(" ldrex %0, [%3]\n"
__asm__ __volatile__(
" ldrex %0, [%3]\n"
" strex %1, %4, [%3]\n"
: "=&r"(old_value), "=&r"(reloop), "+m"(*ptr)
: "r"(ptr), "r"(new_value)
@ -301,7 +304,9 @@ inline void Release_Store(volatile Atomic32* ptr, Atomic32 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) {
Atomic32 value = *ptr;

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

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

15
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
// after acquire compare-and-swap.
};
extern struct AtomicOps_x86CPUFeatureStruct
AtomicOps_Internalx86CPUFeatures;
extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures;
#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
@ -76,7 +75,8 @@ inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 temp = increment;
__asm__ __volatile__("lock; xaddl %0,%1"
: "+r"(temp), "+m"(*ptr)
: : "memory");
:
: "memory");
// temp now holds the old value of *ptr
return temp + increment;
}
@ -86,7 +86,8 @@ inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 temp = increment;
__asm__ __volatile__("lock; xaddl %0,%1"
: "+r"(temp), "+m"(*ptr)
: : "memory");
:
: "memory");
// temp now holds the old value of *ptr
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
__asm__ __volatile__("lfence" : : : "memory");
@ -174,7 +175,8 @@ inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 temp = increment;
__asm__ __volatile__("lock; xaddq %0,%1"
: "+r"(temp), "+m"(*ptr)
: : "memory");
:
: "memory");
// temp now contains the previous value of *ptr
return temp + increment;
}
@ -184,7 +186,8 @@ inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 temp = increment;
__asm__ __volatile__("lock; xaddq %0,%1"
: "+r"(temp), "+m"(*ptr)
: : "memory");
:
: "memory");
// temp now contains the previous value of *ptr
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
__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 new_value) {
LONG result = _InterlockedCompareExchange(
reinterpret_cast<volatile LONG*>(ptr),
static_cast<LONG>(new_value),
reinterpret_cast<volatile LONG*>(ptr), static_cast<LONG>(new_value),
static_cast<LONG>(old_value));
return static_cast<Atomic32>(result);
}
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
Atomic32 new_value) {
LONG result = _InterlockedExchange(
reinterpret_cast<volatile LONG*>(ptr),
LONG result = _InterlockedExchange(reinterpret_cast<volatile LONG*>(ptr),
static_cast<LONG>(new_value));
return static_cast<Atomic32>(result);
}
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
Atomic32 increment) {
return _InterlockedExchangeAdd(
reinterpret_cast<volatile LONG*>(ptr),
static_cast<LONG>(increment)) + increment;
return _InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
static_cast<LONG>(increment)) +
increment;
}
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,
Atomic64 new_value) {
PVOID result = InterlockedExchangePointer(
reinterpret_cast<volatile PVOID*>(ptr),
PVOID result =
InterlockedExchangePointer(reinterpret_cast<volatile PVOID*>(ptr),
reinterpret_cast<PVOID>(new_value));
return reinterpret_cast<Atomic64>(result);
}
inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
Atomic64 increment) {
return InterlockedExchangeAdd64(
reinterpret_cast<volatile LONGLONG*>(ptr),
static_cast<LONGLONG>(increment)) + increment;
return InterlockedExchangeAdd64(reinterpret_cast<volatile LONGLONG*>(ptr),
static_cast<LONGLONG>(increment)) +
increment;
}
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);
}
#endif // defined(_WIN64)
} // namespace base::subtle

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

File diff suppressed because it is too large Load Diff

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

@ -52,13 +52,9 @@ class RunnableAdapter<R(__stdcall *)()> {
public:
typedef R(RunType)();
explicit RunnableAdapter(R(__stdcall *function)())
: function_(function) {
}
explicit RunnableAdapter(R(__stdcall* function)()) : function_(function) {}
R Run() {
return function_();
}
R Run() { return function_(); }
private:
R(__stdcall* function_)();
@ -70,13 +66,9 @@ class RunnableAdapter<R(__fastcall *)()> {
public:
typedef R(RunType)();
explicit RunnableAdapter(R(__fastcall *function)())
: function_(function) {
}
explicit RunnableAdapter(R(__fastcall* function)()) : function_(function) {}
R Run() {
return function_();
}
R Run() { return function_(); }
private:
R(__fastcall* function_)();
@ -88,9 +80,7 @@ class RunnableAdapter<R(__stdcall *)(A1)> {
public:
typedef R(RunType)(A1);
explicit RunnableAdapter(R(__stdcall *function)(A1))
: function_(function) {
}
explicit RunnableAdapter(R(__stdcall* function)(A1)) : function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
return function_(a1);
@ -106,9 +96,7 @@ class RunnableAdapter<R(__fastcall *)(A1)> {
public:
typedef R(RunType)(A1);
explicit RunnableAdapter(R(__fastcall *function)(A1))
: function_(function) {
}
explicit RunnableAdapter(R(__fastcall* function)(A1)) : function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1) {
return function_(a1);
@ -125,8 +113,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2)> {
typedef R(RunType)(A1, A2);
explicit RunnableAdapter(R(__stdcall* function)(A1, A2))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2) {
@ -144,8 +131,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2)> {
typedef R(RunType)(A1, A2);
explicit RunnableAdapter(R(__fastcall* function)(A1, A2))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2) {
@ -163,8 +149,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3)> {
typedef R(RunType)(A1, A2, A3);
explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -183,8 +168,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3)> {
typedef R(RunType)(A1, A2, A3);
explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -203,8 +187,7 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4)> {
typedef R(RunType)(A1, A2, A3, A4);
explicit RunnableAdapter(R(__stdcall* function)(A1, A2, A3, A4))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -224,8 +207,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
typedef R(RunType)(A1, A2, A3, A4);
explicit RunnableAdapter(R(__fastcall* function)(A1, A2, A3, A4))
: function_(function) {
}
: function_(function) {}
R Run(typename CallbackParamTraits<A1>::ForwardType a1,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -239,15 +221,18 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4)> {
};
// __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>
class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -262,15 +247,18 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5)> {
};
// __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>
class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -285,15 +273,19 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5)> {
};
// __stdcall Function: Arity 6.
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6>
template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -309,15 +301,19 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6)> {
};
// __fastcall Function: Arity 6.
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6>
template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -333,15 +329,20 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6)> {
};
// __stdcall Function: Arity 7.
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7>
template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class RunnableAdapter<R(__stdcall*)(A1, A2, A3, A4, A5, A6, A7)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,
@ -358,15 +359,20 @@ class RunnableAdapter<R(__stdcall *)(A1, A2, A3, A4, A5, A6, A7)> {
};
// __fastcall Function: Arity 7.
template <typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7>
template <typename R,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
class RunnableAdapter<R(__fastcall*)(A1, A2, A3, A4, A5, A6, A7)> {
public:
typedef R(RunType)(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,
typename CallbackParamTraits<A2>::ForwardType a2,

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

@ -115,15 +115,16 @@ class CallbackBase {
// 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
// destructive way.
template <typename T> struct IsMoveOnlyType {
template <typename T>
struct IsMoveOnlyType {
template <typename U>
static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
template <typename U>
static NoType Test(...);
static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
!is_const<T>::value;
static const bool 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

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

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

10
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
// more information.
//
// $hash=ade29136d75b33f63cf65db4b91de9cd66114562$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Implement this structure to receive accessibility notification when
// accessibility events have been registered. The functions of this structure
@ -61,17 +62,18 @@ typedef struct _cef_accessibility_handler_t {
// browser process.
///
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
// browser process.
///
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;
#ifdef __cplusplus
}
#endif

15
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
// more information.
//
// $hash=52ce63b881a6e3d2d13a39b81ad2626f366fc130$
//
#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@ -73,7 +75,8 @@ typedef struct _cef_app_t {
// in undefined behavior including crashes.
///
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);
///
@ -82,7 +85,8 @@ typedef struct _cef_app_t {
// each process and the registered schemes should be the same across all
// 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);
///
@ -109,7 +113,6 @@ typedef struct _cef_app_t {
CEF_CALLBACK* get_render_process_handler)(struct _cef_app_t* self);
} cef_app_t;
///
// 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
@ -123,7 +126,8 @@ typedef struct _cef_app_t {
// cef_sandbox_win.h for details).
///
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
@ -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).
///
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);
///

7
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
// more information.
//
// $hash=639d58245ecd39624d39ee8b49e0e4e056d1c4ed$
//
#ifndef CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Callback structure used for asynchronous continuation of authentication
// requests.
@ -59,7 +60,8 @@ typedef struct _cef_auth_callback_t {
// Continue the authentication request.
///
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.
@ -67,7 +69,6 @@ typedef struct _cef_auth_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_auth_callback_t* self);
} cef_auth_callback_t;
#ifdef __cplusplus
}
#endif

8
include/capi/cef_base_capi.h
View File

@ -27,7 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
@ -72,7 +71,6 @@ typedef struct _cef_base_ref_counted_t {
int(CEF_CALLBACK* has_one_ref)(struct _cef_base_ref_counted_t* self);
} cef_base_ref_counted_t;
///
// All scoped framework structures must include this structure first.
///
@ -89,16 +87,14 @@ typedef struct _cef_base_scoped_t {
} cef_base_scoped_t;
// 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|.
#define CEF_MEMBER_EXISTS(s, f) \
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \
*reinterpret_cast<size_t*>(s))
((intptr_t) & \
((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))
#ifdef __cplusplus
}
#endif

134
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
// more information.
//
// $hash=b6308ab5e97eb9f7af95f1f4c371fd6e7edbf852$
//
#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@ -150,7 +152,8 @@ typedef struct _cef_browser_t {
// Returns the frame with the specified identifier, or NULL if not found.
///
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.
@ -167,7 +170,8 @@ typedef struct _cef_browser_t {
// Returns the identifiers of all existing frames.
///
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.
@ -179,12 +183,12 @@ typedef struct _cef_browser_t {
// Send a message to the specified |target_process|. Returns true (1) if the
// 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,
struct _cef_process_message_t* message);
} cef_browser_t;
///
// Callback structure for cef_browser_host_t::RunFileDialog. The functions of
// this structure will be called on the browser process UI thread.
@ -203,11 +207,11 @@ typedef struct _cef_run_file_dialog_callback_t {
// dialog mode. If the selection was cancelled |file_paths| will be NULL.
///
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_run_file_dialog_callback_t;
///
// Callback structure for cef_browser_host_t::GetNavigationEntries. The
// functions of this structure will be called on the browser process UI thread.
@ -226,11 +230,12 @@ typedef struct _cef_navigation_entry_visitor_t {
// the total number of entries.
///
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);
} cef_navigation_entry_visitor_t;
///
// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
// structure will be called on the browser process UI thread.
@ -247,11 +252,11 @@ typedef struct _cef_pdf_print_callback_t {
// successfully or false (0) otherwise.
///
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);
} cef_pdf_print_callback_t;
///
// Callback structure for cef_browser_host_t::DownloadImage. The functions of
// this structure will be called on the browser process UI thread.
@ -270,11 +275,11 @@ typedef struct _cef_download_image_callback_t {
///
void(CEF_CALLBACK* on_download_image_finished)(
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);
} cef_download_image_callback_t;
///
// 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.
@ -385,9 +390,12 @@ typedef struct _cef_browser_host_t {
// dismissed or immediately if another dialog is already pending. The dialog
// will be initiated asynchronously on the UI thread.
///
void (CEF_CALLBACK *run_file_dialog)(struct _cef_browser_host_t* self,
cef_file_dialog_mode_t mode, const cef_string_t* title,
const cef_string_t* default_file_path, cef_string_list_t accept_filters,
void(CEF_CALLBACK* run_file_dialog)(
struct _cef_browser_host_t* self,
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_run_file_dialog_callback_t* callback);
@ -409,9 +417,13 @@ typedef struct _cef_browser_host_t {
// unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
// the server even if it is present in the browser cache.
///
void (CEF_CALLBACK *download_image)(struct _cef_browser_host_t* self,
const cef_string_t* image_url, int is_favicon, uint32 max_image_size,
int bypass_cache, struct _cef_download_image_callback_t* callback);
void(CEF_CALLBACK* download_image)(
struct _cef_browser_host_t* self,
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.
@ -424,7 +436,8 @@ typedef struct _cef_browser_host_t {
// |path| when done. For PDF printing to work on Linux you must implement the
// 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 struct _cef_pdf_print_settings_t* settings,
struct _cef_pdf_print_callback_t* callback);
@ -440,8 +453,11 @@ typedef struct _cef_browser_host_t {
// instance, if any, returned via cef_client_t::GetFindHandler will be called
// to report find results.
///
void (CEF_CALLBACK *find)(struct _cef_browser_host_t* self, int identifier,
const cef_string_t* searchText, int forward, int matchCase,
void(CEF_CALLBACK* find)(struct _cef_browser_host_t* self,
int identifier,
const cef_string_t* searchText,
int forward,
int matchCase,
int findNext);
///
@ -459,7 +475,8 @@ typedef struct _cef_browser_host_t {
// inspected. The |windowInfo| parameter will be ignored if this browser is
// 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,
struct _cef_client_t* client,
const struct _cef_browser_settings_t* settings,
@ -482,14 +499,17 @@ typedef struct _cef_browser_host_t {
// navigation entry will be sent, otherwise all navigation entries will be
// sent.
///
void (CEF_CALLBACK *get_navigation_entries)(struct _cef_browser_host_t* self,
struct _cef_navigation_entry_visitor_t* visitor, int current_only);
void(CEF_CALLBACK* get_navigation_entries)(
struct _cef_browser_host_t* self,
struct _cef_navigation_entry_visitor_t* visitor,
int current_only);
///
// Set whether mouse cursor change is 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.
@ -560,16 +580,21 @@ typedef struct _cef_browser_host_t {
// Send a mouse click event to the browser. The |x| and |y| coordinates are
// relative to the upper-left corner of the view.
///
void (CEF_CALLBACK *send_mouse_click_event)(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event, cef_mouse_button_type_t type,
int mouseUp, int clickCount);
void(CEF_CALLBACK* send_mouse_click_event)(
struct _cef_browser_host_t* self,
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
// relative to the upper-left corner of the view.
///
void (CEF_CALLBACK *send_mouse_move_event)(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event, int mouseLeave);
void(CEF_CALLBACK* send_mouse_move_event)(
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
@ -578,8 +603,11 @@ typedef struct _cef_browser_host_t {
// In order to scroll inside select popups with window rendering disabled
// cef_render_handler_t::GetScreenPoint should be implemented properly.
///
void (CEF_CALLBACK *send_mouse_wheel_event)(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event, int deltaX, int deltaY);
void(CEF_CALLBACK* send_mouse_wheel_event)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
int deltaX,
int deltaY);
///
// Send a focus event to the browser.
@ -590,8 +618,7 @@ typedef struct _cef_browser_host_t {
///
// Send a capture lost event to the browser.
///
void (CEF_CALLBACK *send_capture_lost_event)(
struct _cef_browser_host_t* self);
void(CEF_CALLBACK* send_capture_lost_event)(struct _cef_browser_host_t* self);
///
// Notify the browser that the window hosting it is about to be moved or
@ -618,7 +645,8 @@ typedef struct _cef_browser_host_t {
// set at browser creation via cef_browser_tSettings.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
@ -643,8 +671,10 @@ typedef struct _cef_browser_host_t {
//
// This function is only used when window rendering is disabled.
///
void (CEF_CALLBACK *ime_set_composition)(struct _cef_browser_host_t* self,
const cef_string_t* text, size_t underlinesCount,
void(CEF_CALLBACK* ime_set_composition)(
struct _cef_browser_host_t* self,
const cef_string_t* text,
size_t underlinesCount,
cef_composition_underline_t const* underlines,
const cef_range_t* replacement_range,
const cef_range_t* selection_range);
@ -659,7 +689,8 @@ typedef struct _cef_browser_host_t {
// used when window rendering is disabled.
///
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);
///
@ -669,7 +700,8 @@ typedef struct _cef_browser_host_t {
// function is only used when window rendering is disabled.
///
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
@ -687,7 +719,8 @@ typedef struct _cef_browser_host_t {
// cef_render_handler_t::StartDragging). This function is only used when
// 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,
const struct _cef_mouse_event_t* event,
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
// 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,
cef_drag_operations_mask_t allowed_ops);
@ -729,7 +763,9 @@ typedef struct _cef_browser_host_t {
// disabled.
///
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
@ -778,7 +814,6 @@ typedef struct _cef_browser_host_t {
cef_state_t accessibility_state);
} cef_browser_host_t;
///
// Create a new browser window using the window parameters specified by
// |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.
///
CEF_EXPORT int cef_browser_host_create_browser(
const cef_window_info_t* windowInfo, struct _cef_client_t* client,
const cef_string_t* url, const struct _cef_browser_settings_t* settings,
const cef_window_info_t* windowInfo,
struct _cef_client_t* client,
const cef_string_t* url,
const struct _cef_browser_settings_t* settings,
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.
///
CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
const cef_window_info_t* windowInfo, struct _cef_client_t* client,
const cef_string_t* url, const struct _cef_browser_settings_t* settings,
const cef_window_info_t* windowInfo,
struct _cef_client_t* client,
const cef_string_t* url,
const struct _cef_browser_settings_t* settings,
struct _cef_request_context_t* request_context);
#ifdef __cplusplus
}
#endif

7
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
// more information.
//
// $hash=0868c7d129e35c38b207b1066fd5eba0c1eef45c$
//
#ifndef 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" {
#endif
///
// Structure used to implement browser process callbacks. The functions of this
// structure will be called on the browser process main thread unless otherwise
@ -109,10 +110,10 @@ typedef struct _cef_browser_process_handler_t {
// cancelled.
///
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;
#ifdef __cplusplus
}
#endif

5
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
// more information.
//
// $hash=68de2255fd429696d62115786fc480f1d5f9882b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Generic callback structure used for asynchronous continuation.
///
@ -65,7 +66,6 @@ typedef struct _cef_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_callback_t* self);
} cef_callback_t;
///
// Generic callback structure used for asynchronous completion.
///
@ -81,7 +81,6 @@ typedef struct _cef_completion_callback_t {
void(CEF_CALLBACK* on_complete)(struct _cef_completion_callback_t* self);
} cef_completion_callback_t;
#ifdef __cplusplus
}
#endif

10
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
// more information.
//
// $hash=7f554250e73537ece3f8f67310c23e718f91d41b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
@ -59,7 +61,6 @@
extern "C" {
#endif
///
// Implement this structure to provide handler implementations.
///
@ -163,12 +164,13 @@ typedef struct _cef_client_t {
// (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.
///
int (CEF_CALLBACK *on_process_message_received)(struct _cef_client_t* self,
struct _cef_browser_t* browser, cef_process_id_t source_process,
int(CEF_CALLBACK* on_process_message_received)(
struct _cef_client_t* self,
struct _cef_browser_t* browser,
cef_process_id_t source_process,
struct _cef_process_message_t* message);
} cef_client_t;
#ifdef __cplusplus
}
#endif

15
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
// more information.
//
// $hash=b917030321dc11ddfc8d8939239dda7952d2f955$
//
#ifndef CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure used to create and/or parse command line arguments. Arguments with
// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
@ -85,7 +86,8 @@ typedef struct _cef_command_line_t {
// supported on non-Windows platforms.
///
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
@ -145,7 +147,8 @@ typedef struct _cef_command_line_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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
@ -164,8 +167,8 @@ typedef struct _cef_command_line_t {
///
// Add a switch with the specified value to the end of the command line.
///
void (CEF_CALLBACK *append_switch_with_value)(
struct _cef_command_line_t* self, const cef_string_t* name,
void(CEF_CALLBACK* append_switch_with_value)(struct _cef_command_line_t* self,
const cef_string_t* name,
const cef_string_t* value);
///
@ -193,7 +196,6 @@ typedef struct _cef_command_line_t {
const cef_string_t* wrapper);
} cef_command_line_t;
///
// 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();
#ifdef __cplusplus
}
#endif

35
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
// more information.
//
// $hash=2e295ba277083061103147a400bc30f78e6a94f5$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
@ -63,7 +65,8 @@ typedef struct _cef_run_context_menu_callback_t {
// |event_flags|.
///
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.
@ -71,7 +74,6 @@ typedef struct _cef_run_context_menu_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_run_context_menu_callback_t* self);
} cef_run_context_menu_callback_t;
///
// Implement this structure to handle context menu events. The functions of this
// structure will be called on the UI thread.
@ -90,8 +92,10 @@ typedef struct _cef_context_menu_handler_t {
// |model| outside of this callback.
///
void(CEF_CALLBACK* on_before_context_menu)(
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_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_context_menu_params_t* params,
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
// references to |params| or |model| outside of this callback.
///
int (CEF_CALLBACK *run_context_menu)(struct _cef_context_menu_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
int(CEF_CALLBACK* run_context_menu)(
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_menu_model_t* model,
struct _cef_run_context_menu_callback_t* callback);
@ -118,20 +124,23 @@ typedef struct _cef_context_menu_handler_t {
// this callback.
///
int(CEF_CALLBACK* on_context_menu_command)(
struct _cef_context_menu_handler_t* self, struct _cef_browser_t* browser,
struct _cef_frame_t* frame, struct _cef_context_menu_params_t* params,
int command_id, cef_event_flags_t event_flags);
struct _cef_context_menu_handler_t* self,
struct _cef_browser_t* browser,
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
// was NULL or a command was selected.
///
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);
} cef_context_menu_handler_t;
///
// Provides information about the context menu state. The ethods of this
// structure can only be accessed on browser process the UI thread.
@ -257,7 +266,8 @@ typedef struct _cef_context_menu_params_t {
// is one.
///
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.
@ -291,7 +301,6 @@ typedef struct _cef_context_menu_params_t {
int(CEF_CALLBACK* is_pepper_menu)(struct _cef_context_menu_params_t* self);
} cef_context_menu_params_t;
#ifdef __cplusplus
}
#endif

38
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
// more information.
//
// $hash=c2bf8084385f3c795ae7494da6970a0a61b96ac6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
@ -65,8 +67,10 @@ typedef struct _cef_cookie_manager_t {
// NULL it will be executed asnychronously on the IO thread after the change
// has been applied. Must be called before any cookies are accessed.
///
void (CEF_CALLBACK *set_supported_schemes)(struct _cef_cookie_manager_t* self,
cef_string_list_t schemes, struct _cef_completion_callback_t* callback);
void(CEF_CALLBACK* set_supported_schemes)(
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
@ -84,7 +88,8 @@ typedef struct _cef_cookie_manager_t {
// Returns false (0) if cookies cannot be accessed.
///
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);
///
@ -97,7 +102,8 @@ typedef struct _cef_cookie_manager_t {
// 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,
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);
///
@ -111,8 +117,10 @@ typedef struct _cef_cookie_manager_t {
// or if cookies cannot be accessed. Cookies can alternately be deleted using
// the Visit*Cookies() functions.
///
int (CEF_CALLBACK *delete_cookies)(struct _cef_cookie_manager_t* self,
const cef_string_t* url, const cef_string_t* cookie_name,
int(CEF_CALLBACK* delete_cookies)(
struct _cef_cookie_manager_t* self,
const cef_string_t* url,
const cef_string_t* cookie_name,
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
// initialized. Returns false (0) if cookies cannot be accessed.
///
int (CEF_CALLBACK *set_storage_path)(struct _cef_cookie_manager_t* self,
const cef_string_t* path, int persist_session_cookies,
int(CEF_CALLBACK* set_storage_path)(
struct _cef_cookie_manager_t* self,
const cef_string_t* path,
int persist_session_cookies,
struct _cef_completion_callback_t* callback);
///
@ -138,7 +148,6 @@ typedef struct _cef_cookie_manager_t {
struct _cef_completion_callback_t* callback);
} cef_cookie_manager_t;
///
// Returns the global cookie manager. By default data will be stored at
// 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.
///
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);
///
// Structure to implement for visiting cookie values. The functions of this
// structure will always be called on the IO thread.
@ -182,11 +191,12 @@ typedef struct _cef_cookie_visitor_t {
// called if no cookies are found.
///
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);
} cef_cookie_visitor_t;
///
// Structure to implement to be notified of asynchronous completion via
// cef_cookie_manager_t::set_cookie().
@ -205,7 +215,6 @@ typedef struct _cef_set_cookie_callback_t {
int success);
} cef_set_cookie_callback_t;
///
// Structure to implement to be notified of asynchronous completion via
// cef_cookie_manager_t::delete_cookies().
@ -224,7 +233,6 @@ typedef struct _cef_delete_cookies_callback_t {
int num_deleted);
} cef_delete_cookies_callback_t;
#ifdef __cplusplus
}
#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
// more information.
//
// $hash=8b7354f5a1ad6b255d77e477c64374b927f4fe28$
//
#ifndef CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// 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

20
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
// more information.
//
// $hash=b8a44f4f624ba51107d06ff3d1a7934e83765786$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Callback structure for asynchronous continuation of file dialog requests.
///
@ -63,7 +64,8 @@ typedef struct _cef_file_dialog_callback_t {
// value is treated the same as calling cancel().
///
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.
@ -71,7 +73,6 @@ typedef struct _cef_file_dialog_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_file_dialog_callback_t* self);
} cef_file_dialog_callback_t;
///
// Implement this structure to handle dialog events. The functions of this
// 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
// display the default dialog return false (0).
///
int (CEF_CALLBACK *on_file_dialog)(struct _cef_dialog_handler_t* self,
struct _cef_browser_t* browser, 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(CEF_CALLBACK* on_file_dialog)(
struct _cef_dialog_handler_t* self,
struct _cef_browser_t* browser,
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);
} cef_dialog_handler_t;
#ifdef __cplusplus
}
#endif

28
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
// more information.
//
// $hash=f0f3fd4cab00c0eb11956e674a111cb30d3af100$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events related to browser display state.
// The functions of this structure will be called on the UI thread.
@ -61,20 +62,23 @@ typedef struct _cef_display_handler_t {
// Called when a frame's address has changed.
///
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);
///
// Called when the page title changes.
///
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.
///
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
@ -84,7 +88,8 @@ typedef struct _cef_display_handler_t {
// responsible for resizing the browser if desired.
///
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);
///
@ -96,25 +101,28 @@ typedef struct _cef_display_handler_t {
// for drawing tooltips and the return value is ignored.
///
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
// text that will be displayed in the status message.
///
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
// from being output to the console.
///
int(CEF_CALLBACK* on_console_message)(struct _cef_display_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* message,
const cef_string_t* source, int line);
struct _cef_browser_t* browser,
const cef_string_t* message,
const cef_string_t* source,
int line);
} cef_display_handler_t;
#ifdef __cplusplus
}
#endif

21
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
// more information.
//
// $hash=db82ff508cb1b4a03001b8b30bc5126186ee1bd2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
@ -68,7 +70,6 @@ typedef struct _cef_domvisitor_t {
struct _cef_domdocument_t* document);
} cef_domvisitor_t;
///
// Structure used to represent a DOM document. The functions of this structure
// should only be called on the render process main thread thread.
@ -114,7 +115,8 @@ typedef struct _cef_domdocument_t {
// Returns the document element with the specified ID value.
///
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.
@ -165,10 +167,10 @@ typedef struct _cef_domdocument_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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;
///
// Structure used to represent a DOM node. The functions of this structure
// should only be called on the render process main thread.
@ -252,8 +254,7 @@ typedef struct _cef_domnode_t {
///
// Returns the parent node.
///
struct _cef_domnode_t* (CEF_CALLBACK *get_parent)(
struct _cef_domnode_t* self);
struct _cef_domnode_t*(CEF_CALLBACK* get_parent)(struct _cef_domnode_t* self);
///
// Returns the previous sibling node.
@ -284,7 +285,6 @@ typedef struct _cef_domnode_t {
struct _cef_domnode_t*(CEF_CALLBACK* get_last_child)(
struct _cef_domnode_t* self);
// The following functions are valid only for element nodes.
///
@ -310,7 +310,8 @@ typedef struct _cef_domnode_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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.
@ -323,7 +324,8 @@ typedef struct _cef_domnode_t {
// on success.
///
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.
@ -338,7 +340,6 @@ typedef struct _cef_domnode_t {
cef_rect_t(CEF_CALLBACK* get_element_bounds)(struct _cef_domnode_t* self);
} cef_domnode_t;
#ifdef __cplusplus
}
#endif

15
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
// more information.
//
// $hash=4475f7e48898bdef8051c849873fb2528320cd9c$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Callback structure used to asynchronously continue a download.
///
@ -63,10 +64,10 @@ typedef struct _cef_before_download_callback_t {
// (1) if you do wish to show the default "Save As" dialog.
///
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;
///
// Callback structure used to asynchronously cancel a download.
///
@ -92,7 +93,6 @@ typedef struct _cef_download_item_callback_t {
void(CEF_CALLBACK* resume)(struct _cef_download_item_callback_t* self);
} cef_download_item_callback_t;
///
// Structure used to handle file downloads. The functions of this structure will
// 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
// 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_download_item_t* download_item,
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
// 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_download_item_t* download_item,
struct _cef_download_item_callback_t* callback);
} cef_download_handler_t;
#ifdef __cplusplus
}
#endif

4
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
// more information.
//
// $hash=cc669703d613f5a6a5bae95030835dc99f55a6fa$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure used to represent a download item.
///
@ -154,7 +155,6 @@ typedef struct _cef_download_item_t {
struct _cef_download_item_t* self);
} cef_download_item_t;
#ifdef __cplusplus
}
#endif

8
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
// more information.
//
// $hash=a4b5264c1e685cad86203772631460684ee7820d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Structure used to represent drag data. The functions of this structure may be
// called on any thread.
@ -195,7 +196,8 @@ typedef struct _cef_drag_data_t {
// Add a file that is being dragged into the webview.
///
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
@ -214,13 +216,11 @@ typedef struct _cef_drag_data_t {
int(CEF_CALLBACK* has_image)(struct _cef_drag_data_t* self);
} cef_drag_data_t;
///
// Create a new cef_drag_data_t object.
///
CEF_EXPORT cef_drag_data_t* cef_drag_data_create();
#ifdef __cplusplus
}
#endif

13
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
// more information.
//
// $hash=c557dad9522f4bd4c6b3295d149c6b893fc18d52$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events related to dragging. The functions
// of this structure will be called on the UI thread.
@ -64,7 +65,8 @@ typedef struct _cef_drag_handler_t {
// to cancel the drag event.
///
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);
///
@ -75,11 +77,12 @@ typedef struct _cef_drag_handler_t {
// this function will be called with an NULL vector.
///
void(CEF_CALLBACK* on_draggable_regions_changed)(
struct _cef_drag_handler_t* self, struct _cef_browser_t* browser,
size_t regionsCount, cef_draggable_region_t const* regions);
struct _cef_drag_handler_t* self,
struct _cef_browser_t* browser,
size_t regionsCount,
cef_draggable_region_t const* regions);
} cef_drag_handler_t;
#ifdef __cplusplus
}
#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
// more information.
//
// $hash=4601edefadfafea031f2c5df498262fc2142252b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// 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.
@ -82,7 +83,8 @@ CEF_EXPORT int cef_create_new_temp_directory(const cef_string_t* prefix,
// or IO threads is not allowed.
///
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);
///
@ -109,7 +111,8 @@ CEF_EXPORT int cef_delete_file(const cef_string_t* path, int recursive);
// or IO threads is not allowed.
///
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
}

11
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
// more information.
//
// $hash=975114b079fa271fecbf31ef160974941faed8a4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events related to find results. The
// functions of this structure will be called on the UI thread.
@ -65,12 +66,14 @@ typedef struct _cef_find_handler_t {
// this is the last find notification.
///
void(CEF_CALLBACK* on_find_result)(struct _cef_find_handler_t* self,
struct _cef_browser_t* browser, int identifier, int count,
const cef_rect_t* selectionRect, int activeMatchOrdinal,
struct _cef_browser_t* browser,
int identifier,
int count,
const cef_rect_t* selectionRect,
int activeMatchOrdinal,
int finalUpdate);
} cef_find_handler_t;
#ifdef __cplusplus
}
#endif

10
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
// more information.
//
// $hash=bed1f7b94e060b83e3f22eb84ce1274f2d10b3e6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
@ -47,7 +49,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events related to focus. The functions of
// this structure will be called on the UI thread.
@ -65,7 +66,8 @@ typedef struct _cef_focus_handler_t {
// false (0) if the browser is giving focus to the previous component.
///
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
@ -73,7 +75,8 @@ typedef struct _cef_focus_handler_t {
// focus to be set or true (1) to cancel setting the focus.
///
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.
@ -82,7 +85,6 @@ typedef struct _cef_focus_handler_t {
struct _cef_browser_t* browser);
} cef_focus_handler_t;
#ifdef __cplusplus
}
#endif

9
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
// more information.
//
// $hash=c1457ef21c14c40422b19b681121283eae3e9d70$
//
#ifndef CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
@ -142,7 +144,8 @@ typedef struct _cef_frame_t {
// link clicks and web security restrictions may not behave as expected.
///
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|
@ -152,7 +155,8 @@ typedef struct _cef_frame_t {
// reporting.
///
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);
///
@ -213,7 +217,6 @@ typedef struct _cef_frame_t {
struct _cef_domvisitor_t* visitor);
} cef_frame_t;
#ifdef __cplusplus
}
#endif

4
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
// more information.
//
// $hash=3ae57ba897d73f3fcccc955c827379746b6203af$
//
#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Implement this structure to receive geolocation updates. The functions of
// this structure will be called on the browser process UI thread.
@ -64,7 +65,6 @@ typedef struct _cef_get_geolocation_callback_t {
const struct _cef_geoposition_t* position);
} cef_get_geolocation_callback_t;
///
// 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

17
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
// more information.
//
// $hash=ec60811fcefbe02348f14ecddbe5778ce836bf53$
//
#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Callback structure used for asynchronous continuation of geolocation
// permission requests.
@ -59,11 +60,9 @@ typedef struct _cef_geolocation_callback_t {
///
// Call to allow or deny geolocation access.
///
void (CEF_CALLBACK *cont)(struct _cef_geolocation_callback_t* self,
int allow);
void(CEF_CALLBACK* cont)(struct _cef_geolocation_callback_t* self, int allow);
} cef_geolocation_callback_t;
///
// Implement this structure to handle events related to geolocation permission
// requests. The functions of this structure will be called on the browser
@ -84,8 +83,10 @@ typedef struct _cef_geolocation_handler_t {
// request immediately.
///
int(CEF_CALLBACK* on_request_geolocation_permission)(
struct _cef_geolocation_handler_t* self, struct _cef_browser_t* browser,
const cef_string_t* requesting_url, int request_id,
struct _cef_geolocation_handler_t* self,
struct _cef_browser_t* browser,
const cef_string_t* requesting_url,
int request_id,
struct _cef_geolocation_callback_t* callback);
///
@ -93,11 +94,11 @@ typedef struct _cef_geolocation_handler_t {
// unique ID for the permission request.
///
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);
} cef_geolocation_handler_t;
#ifdef __cplusplus
}
#endif

54
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
// more information.
//
// $hash=60f904f2f77ce6d89f9fceeeda0050273a3c9e6d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Container for a single image represented at different scale factors. All
// image representations should be the same size in density independent pixel
@ -79,9 +80,13 @@ typedef struct _cef_image_t {
// 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.
///
int (CEF_CALLBACK *add_bitmap)(struct _cef_image_t* self, float scale_factor,
int pixel_width, int pixel_height, cef_color_type_t color_type,
cef_alpha_type_t alpha_type, const void* pixel_data,
int(CEF_CALLBACK* add_bitmap)(struct _cef_image_t* self,
float scale_factor,
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);
///
@ -89,16 +94,20 @@ typedef struct _cef_image_t {
// data of size |png_data_size|. Any alpha transparency in the PNG data will
// be maintained.
///
int (CEF_CALLBACK *add_png)(struct _cef_image_t* self, float scale_factor,
const void* png_data, size_t png_data_size);
int(CEF_CALLBACK* add_png)(struct _cef_image_t* self,
float scale_factor,
const void* png_data,
size_t png_data_size);
///
// 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
// 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,
const void* jpeg_data, size_t jpeg_data_size);
int(CEF_CALLBACK* add_jpeg)(struct _cef_image_t* self,
float scale_factor,
const void* jpeg_data,
size_t jpeg_data_size);
///
// Returns the image width in density independent pixel (DIP) units.
@ -130,7 +139,9 @@ typedef struct _cef_image_t {
// size in pixel coordinates. Returns true (1) on success.
///
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);
///
@ -142,9 +153,12 @@ typedef struct _cef_image_t {
// on failure.
///
struct _cef_binary_value_t*(CEF_CALLBACK* get_as_bitmap)(
struct _cef_image_t* self, float scale_factor,
cef_color_type_t color_type, cef_alpha_type_t alpha_type,
int* pixel_width, int* pixel_height);
struct _cef_image_t* self,
float scale_factor,
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
@ -155,8 +169,11 @@ typedef struct _cef_image_t {
// failure.
///
struct _cef_binary_value_t*(CEF_CALLBACK* get_as_png)(
struct _cef_image_t* self, float scale_factor, int with_transparency,
int* pixel_width, int* pixel_height);
struct _cef_image_t* self,
float scale_factor,
int with_transparency,
int* pixel_width,
int* pixel_height);
///
// Returns the JPEG representation that most closely matches |scale_factor|.
@ -168,18 +185,19 @@ typedef struct _cef_image_t {
// failure.
///
struct _cef_binary_value_t*(CEF_CALLBACK* get_as_jpeg)(
struct _cef_image_t* self, float scale_factor, int quality,
int* pixel_width, int* pixel_height);
struct _cef_image_t* self,
float scale_factor,
int quality,
int* pixel_width,
int* pixel_height);
} cef_image_t;
///
// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
// to add representations at different scale factors.
///
CEF_EXPORT cef_image_t* cef_image_create();
#ifdef __cplusplus
}
#endif

26
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
// more information.
//
// $hash=351cff5a52f29b54d1854d5dfbb1733c8a62797d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Callback structure used for asynchronous continuation of JavaScript dialog
// 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
// 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);
} cef_jsdialog_callback_t;
///
// Implement this structure to handle events related to JavaScript dialogs. The
// functions of this structure will be called on the UI thread.
@ -93,10 +94,13 @@ typedef struct _cef_jsdialog_handler_t {
// dismissed.
///
int(CEF_CALLBACK* on_jsdialog)(struct _cef_jsdialog_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* origin_url,
cef_jsdialog_type_t dialog_type, const cef_string_t* message_text,
struct _cef_browser_t* browser,
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,
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
@ -107,8 +111,10 @@ typedef struct _cef_jsdialog_handler_t {
// dialog is dismissed.
///
int(CEF_CALLBACK* on_before_unload_dialog)(
struct _cef_jsdialog_handler_t* self, struct _cef_browser_t* browser,
const cef_string_t* message_text, int is_reload,
struct _cef_jsdialog_handler_t* self,
struct _cef_browser_t* browser,
const cef_string_t* message_text,
int is_reload,
struct _cef_jsdialog_callback_t* callback);
///
@ -117,7 +123,8 @@ typedef struct _cef_jsdialog_handler_t {
// dialogs are currently pending.
///
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.
@ -126,7 +133,6 @@ typedef struct _cef_jsdialog_handler_t {
struct _cef_browser_t* browser);
} cef_jsdialog_handler_t;
#ifdef __cplusplus
}
#endif

13
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
// more information.
//
// $hash=07c2a01bb9975fa52fdb287712f8f369557ba755$
//
#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events related to keyboard input. The
// functions of this structure will be called on the UI thread.
@ -64,8 +65,10 @@ typedef struct _cef_keyboard_handler_t {
// 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,
struct _cef_browser_t* browser, const struct _cef_key_event_t* event,
cef_event_handle_t os_event, int* is_keyboard_shortcut);
struct _cef_browser_t* browser,
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
@ -74,11 +77,11 @@ typedef struct _cef_keyboard_handler_t {
// if the keyboard event was handled or false (0) otherwise.
///
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_keyboard_handler_t;
#ifdef __cplusplus
}
#endif

21
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
// more information.
//
// $hash=7894d507f337ebe5f9296770e10773a4e6458f00$
//
#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@ -80,13 +82,19 @@ typedef struct _cef_life_span_handler_t {
// the parent browser is destroyed before the popup browser creation completes
// (indicated by a call to OnAfterCreated for the popup browser).
///
int (CEF_CALLBACK *on_before_popup)(struct _cef_life_span_handler_t* self,
struct _cef_browser_t* browser, 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,
int(CEF_CALLBACK* on_before_popup)(
struct _cef_life_span_handler_t* self,
struct _cef_browser_t* browser,
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,
struct _cef_window_info_t* windowInfo, struct _cef_client_t** client,
struct _cef_browser_settings_t* settings, int* no_javascript_access);
struct _cef_window_info_t* windowInfo,
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
@ -198,7 +206,6 @@ typedef struct _cef_life_span_handler_t {
struct _cef_browser_t* browser);
} cef_life_span_handler_t;
#ifdef __cplusplus
}
#endif

20
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
// more information.
//
// $hash=d8fa87bb47ec889cab864fe96f94e07bf1deb0f6$
//
#ifndef CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// 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
@ -66,7 +67,9 @@ typedef struct _cef_load_handler_t {
// calls to OnLoadError and/or OnLoadEnd.
///
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);
///
@ -82,7 +85,8 @@ typedef struct _cef_load_handler_t {
// overall browser load status use OnLoadingStateChange instead.
///
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);
///
@ -96,7 +100,8 @@ typedef struct _cef_load_handler_t {
// instead.
///
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);
///
@ -107,12 +112,13 @@ typedef struct _cef_load_handler_t {
// 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,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
cef_errorcode_t errorCode, const cef_string_t* errorText,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
cef_errorcode_t errorCode,
const cef_string_t* errorText,
const cef_string_t* failedUrl);
} cef_load_handler_t;
#ifdef __cplusplus
}
#endif

151
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
// more information.
//
// $hash=295f7f55ebe6d548aba1476e67efb2c88ab10ca5$
//
#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Supports creation and modification of menus. See cef_menu_id_t for the
// command ids that have default implementations. All user-defined command ids
@ -81,27 +82,32 @@ typedef struct _cef_menu_model_t {
///
// 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);
///
// 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 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
// |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 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.
///
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);
///
@ -115,15 +121,19 @@ typedef struct _cef_menu_model_t {
// Insert an item in the menu at the specified |index|. Returns true (1) on
// success.
///
int (CEF_CALLBACK *insert_item_at)(struct _cef_menu_model_t* self, int index,
int command_id, const cef_string_t* label);
int(CEF_CALLBACK* insert_item_at)(struct _cef_menu_model_t* self,
int index,
int command_id,
const cef_string_t* label);
///
// Insert a check item in the menu at the specified |index|. Returns true (1)
// on success.
///
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
@ -131,14 +141,19 @@ typedef struct _cef_menu_model_t {
// (1) on success.
///
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
// returned.
///
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);
///
@ -170,33 +185,36 @@ typedef struct _cef_menu_model_t {
// 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 index, int command_id);
int index,
int command_id);
///
// 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().
cef_string_userfree_t (CEF_CALLBACK *get_label)(
struct _cef_menu_model_t* self, int command_id);
cef_string_userfree_t(CEF_CALLBACK* get_label)(struct _cef_menu_model_t* self,
int command_id);
///
// Returns the label at the specified |index| or NULL if not found due to
// invalid range or the index being a separator.
///
// The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_label_at)(
struct _cef_menu_model_t* self, int index);
cef_string_userfree_t(
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.
///
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);
///
// 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);
///
@ -208,8 +226,8 @@ typedef struct _cef_menu_model_t {
///
// Returns the item type at the specified |index|.
///
cef_menu_item_type_t (CEF_CALLBACK *get_type_at)(
struct _cef_menu_model_t* self, int index);
cef_menu_item_type_t(
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.
@ -220,39 +238,40 @@ typedef struct _cef_menu_model_t {
///
// 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 index);
int(CEF_CALLBACK* get_group_id_at)(struct _cef_menu_model_t* self, int index);
///
// Sets the group id for the specified |command_id|. Returns true (1) on
// success.
///
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.
///
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);
///
// 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* self, int command_id);
struct _cef_menu_model_t* self,
int command_id);
///
// 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* self, int index);
struct _cef_menu_model_t*(
CEF_CALLBACK* get_sub_menu_at)(struct _cef_menu_model_t* self, int index);
///
// Returns true (1) if the specified |command_id| is visible.
///
int (CEF_CALLBACK *is_visible)(struct _cef_menu_model_t* self,
int command_id);
int(CEF_CALLBACK* is_visible)(struct _cef_menu_model_t* self, int command_id);
///
// Returns true (1) if the specified |index| is visible.
@ -264,20 +283,21 @@ typedef struct _cef_menu_model_t {
// success.
///
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
// 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);
///
// Returns true (1) if the specified |command_id| is enabled.
///
int (CEF_CALLBACK *is_enabled)(struct _cef_menu_model_t* self,
int command_id);
int(CEF_CALLBACK* is_enabled)(struct _cef_menu_model_t* self, int command_id);
///
// Returns true (1) if the specified |index| is enabled.
@ -289,21 +309,22 @@ typedef struct _cef_menu_model_t {
// on success.
///
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
// 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);
///
// Returns true (1) if the specified |command_id| is checked. Only applies to
// check and radio items.
///
int (CEF_CALLBACK *is_checked)(struct _cef_menu_model_t* self,
int command_id);
int(CEF_CALLBACK* is_checked)(struct _cef_menu_model_t* self, int command_id);
///
// Returns true (1) if the specified |index| is checked. Only applies to check
@ -316,13 +337,15 @@ typedef struct _cef_menu_model_t {
// Returns true (1) on success.
///
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
// 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);
///
@ -344,7 +367,10 @@ typedef struct _cef_menu_model_t {
// be any virtual key or character value. Returns true (1) on success.
///
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);
///
@ -352,7 +378,10 @@ typedef struct _cef_menu_model_t {
// any virtual key or character value. Returns true (1) on success.
///
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);
///
@ -374,7 +403,10 @@ typedef struct _cef_menu_model_t {
// true (1) on success.
///
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);
///
@ -382,7 +414,10 @@ typedef struct _cef_menu_model_t {
// (1) on success.
///
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);
///
@ -391,8 +426,10 @@ typedef struct _cef_menu_model_t {
// color or default color is set for |color_type| then the system color will
// be used. Returns true (1) on success.
///
int (CEF_CALLBACK *set_color)(struct _cef_menu_model_t* self, int command_id,
cef_menu_color_type_t color_type, cef_color_t color);
int(CEF_CALLBACK* set_color)(struct _cef_menu_model_t* self,
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
@ -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
// system color will be used. Returns true (1) on success.
///
int (CEF_CALLBACK *set_color_at)(struct _cef_menu_model_t* self, int index,
cef_menu_color_type_t color_type, cef_color_t color);
int(CEF_CALLBACK* set_color_at)(struct _cef_menu_model_t* self,
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
// |color_type|. If a color was not set then 0 will be returned in |color|.
// Returns true (1) on success.
///
int (CEF_CALLBACK *get_color)(struct _cef_menu_model_t* self, int command_id,
cef_menu_color_type_t color_type, cef_color_t* color);
int(CEF_CALLBACK* get_color)(struct _cef_menu_model_t* self,
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
@ -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
// true (1) on success.
///
int (CEF_CALLBACK *get_color_at)(struct _cef_menu_model_t* self, int index,
cef_menu_color_type_t color_type, cef_color_t* color);
int(CEF_CALLBACK* get_color_at)(struct _cef_menu_model_t* self,
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
@ -434,7 +477,8 @@ typedef struct _cef_menu_model_t {
// Bold Italic 14px" - "Arial, 14px"
///
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
@ -450,17 +494,16 @@ typedef struct _cef_menu_model_t {
// Bold Italic 14px" - "Arial, 14px"
///
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;
///
// Create a new MenuModel with the specified |delegate|.
///
CEF_EXPORT cef_menu_model_t* cef_menu_model_create(
struct _cef_menu_model_delegate_t* delegate);
#ifdef __cplusplus
}
#endif

18
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
// more information.
//
// $hash=74f40f20f94ce3a6e7f3c879a3834a7108099ed4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
@ -62,7 +64,8 @@ typedef struct _cef_menu_model_delegate_t {
// |event_flags|.
///
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);
///
@ -71,7 +74,8 @@ typedef struct _cef_menu_model_delegate_t {
///
void(CEF_CALLBACK* mouse_outside_menu)(
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
@ -79,7 +83,8 @@ typedef struct _cef_menu_model_delegate_t {
///
void(CEF_CALLBACK* unhandled_open_submenu)(
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
@ -87,7 +92,8 @@ typedef struct _cef_menu_model_delegate_t {
///
void(CEF_CALLBACK* unhandled_close_submenu)(
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.
@ -106,10 +112,10 @@ typedef struct _cef_menu_model_delegate_t {
// modified.
///
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;
#ifdef __cplusplus
}
#endif

7
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
// more information.
//
// $hash=a862d0004de2a1bdf4c214fe87278badd90562a7$
//
#ifndef CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Structure used to represent an entry in navigation history.
///
@ -115,8 +116,7 @@ typedef struct _cef_navigation_entry_t {
// response. May be 0 if the response has not yet been received or if the
// navigation has not yet completed.
///
int (CEF_CALLBACK *get_http_status_code)(
struct _cef_navigation_entry_t* self);
int(CEF_CALLBACK* get_http_status_code)(struct _cef_navigation_entry_t* self);
///
// Returns the SSL information for this navigation entry.
@ -125,7 +125,6 @@ typedef struct _cef_navigation_entry_t {
struct _cef_navigation_entry_t* self);
} cef_navigation_entry_t;
#ifdef __cplusplus
}
#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
// more information.
//
// $hash=2e5afff3277384ea9f3f74ef509c018f6d307dc4$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// 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.
///
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* target_domain, int allow_target_subdomains);
const cef_string_t* source_origin,
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
// |source_origin| is invalid or the whitelist cannot be accessed.
///
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* target_domain, int allow_target_subdomains);
const cef_string_t* source_origin,
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)

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
// more information.
//
// $hash=d2f01fbfc3ae72a86c03399606088054b3a9337f$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Parse the specified |url| into its component parts. Returns false (0) if the
// 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.
///
// The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_format_url_for_security_display(
const cef_string_t* origin_url);
CEF_EXPORT cef_string_userfree_t
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
// unknown.
///
// The resulting string must be freed by calling cef_string_userfree_free().
CEF_EXPORT cef_string_userfree_t cef_get_mime_type(
const cef_string_t* extension);
CEF_EXPORT cef_string_userfree_t
cef_get_mime_type(const cef_string_t* extension);
///
// 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.
///
// 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,
int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule);
CEF_EXPORT cef_string_userfree_t
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
// 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);
///
@ -143,8 +147,10 @@ CEF_EXPORT struct _cef_value_t* cef_parse_json(const cef_string_t* json_string,
// formatted error message respectively.
///
CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
const cef_string_t* json_string, cef_json_parser_options_t options,
cef_json_parser_error_t* error_code_out, cef_string_t* error_msg_out);
const cef_string_t* json_string,
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
@ -152,8 +158,8 @@ CEF_EXPORT struct _cef_value_t* cef_parse_jsonand_return_error(
// requires exclusive access to |node| including any underlying data.
///
// 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_json_writer_options_t options);
CEF_EXPORT cef_string_userfree_t
cef_write_json(struct _cef_value_t* node, cef_json_writer_options_t options);
#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
// more information.
//
// $hash=fbb817705137a12b4718950ff696396c30057007$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Retrieve the path associated with the specified |key|. Returns true (1) on
// success. Can be called on any thread in the browser process.

21
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
// more information.
//
// $hash=e8f6bdc822cf4f5c32b22ba8b5cacb25823d8971$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Callback structure for asynchronous continuation of print dialog requests.
///
@ -68,7 +69,6 @@ typedef struct _cef_print_dialog_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_print_dialog_callback_t* self);
} cef_print_dialog_callback_t;
///
// Callback structure for asynchronous continuation of print job requests.
///
@ -84,7 +84,6 @@ typedef struct _cef_print_job_callback_t {
void(CEF_CALLBACK* cont)(struct _cef_print_job_callback_t* self);
} cef_print_job_callback_t;
///
// Implement this structure to handle printing on Linux. The functions of this
// structure will be called on the browser process UI thread.
@ -110,15 +109,18 @@ typedef struct _cef_print_handler_t {
// reference to |settings| outside of this callback.
///
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.
// Return true (1) if the dialog will be displayed or false (0) to cancel the
// printing immediately.
///
int (CEF_CALLBACK *on_print_dialog)(struct _cef_print_handler_t* self,
int has_selection, struct _cef_print_dialog_callback_t* callback);
int(CEF_CALLBACK* on_print_dialog)(
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
@ -126,7 +128,8 @@ typedef struct _cef_print_handler_t {
// the job immediately.
///
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);
///
@ -139,10 +142,10 @@ typedef struct _cef_print_handler_t {
// cef_browser_host_t::print_to_pdf().
///
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;
#ifdef __cplusplus
}
#endif

11
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
// more information.
//
// $hash=5b26ebd2d8e1e65a25fa0c08317b8994887c0498$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure representing print settings.
///
@ -121,7 +122,8 @@ typedef struct _cef_print_settings_t {
// Set the page ranges.
///
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.
@ -133,7 +135,8 @@ typedef struct _cef_print_settings_t {
// Retrieve the page ranges.
///
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.
@ -193,13 +196,11 @@ typedef struct _cef_print_settings_t {
struct _cef_print_settings_t* self);
} cef_print_settings_t;
///
// Create a new cef_print_settings_t object.
///
CEF_EXPORT cef_print_settings_t* cef_print_settings_create();
#ifdef __cplusplus
}
#endif

5
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
// more information.
//
// $hash=c2ee22474637f9aed7673670fb10c960ae621535$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Structure representing a message. Can be used on any process and thread.
///
@ -87,14 +88,12 @@ typedef struct _cef_process_message_t {
struct _cef_process_message_t* self);
} cef_process_message_t;
///
// Create a new cef_process_message_t object with the specified name.
///
CEF_EXPORT cef_process_message_t* cef_process_message_create(
const cef_string_t* name);
#ifdef __cplusplus
}
#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
// more information.
//
// $hash=aad07da2d500b8d31e02a75331bdb68f16d4c662$
//
#ifndef CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Launches the process specified via |command_line|. Returns true (1) upon
// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.

65
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
// more information.
//
// $hash=5d20fc88dea8dad8691f05bfb7e8c1ce5cf2bbc1$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
@ -47,7 +49,6 @@
extern "C" {
#endif
///
// Implement this structure to handle events when window rendering is disabled.
// The functions of this structure will be called on the UI thread.
@ -62,8 +63,7 @@ typedef struct _cef_render_handler_t {
// Return the handler for accessibility notifications. If no handler is
// provided the default implementation will be used.
///
struct _cef_accessibility_handler_t* (
CEF_CALLBACK *get_accessibility_handler)(
struct _cef_accessibility_handler_t*(CEF_CALLBACK* get_accessibility_handler)(
struct _cef_render_handler_t* self);
///
@ -71,21 +71,26 @@ typedef struct _cef_render_handler_t {
// true (1) if the rectangle was provided.
///
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
// coordinates. Return true (1) if the rectangle was provided.
///
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
// coordinates. Return true (1) if the screen coordinates were provided.
///
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);
///
@ -98,21 +103,24 @@ typedef struct _cef_render_handler_t {
// drawn correctly.
///
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
// 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,
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|
// contains the new location and size in view coordinates.
///
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
@ -125,16 +133,22 @@ typedef struct _cef_render_handler_t {
// upper-left origin.
///
void(CEF_CALLBACK* on_paint)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_paint_element_type_t type,
size_t dirtyRectsCount, cef_rect_t const* dirtyRects, const void* buffer,
int width, int height);
struct _cef_browser_t* browser,
cef_paint_element_type_t type,
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
// |custom_cursor_info| will be populated with the custom cursor information.
///
void (CEF_CALLBACK *on_cursor_change)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, cef_cursor_handle_t cursor,
void(CEF_CALLBACK* on_cursor_change)(
struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
cef_cursor_handle_t cursor,
cef_cursor_type_t type,
const struct _cef_cursor_info_t* custom_cursor_info);
@ -153,8 +167,11 @@ typedef struct _cef_render_handler_t {
// operation has ended.
///
int(CEF_CALLBACK* start_dragging)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser, struct _cef_drag_data_t* drag_data,
cef_drag_operations_mask_t allowed_ops, int x, int y);
struct _cef_browser_t* browser,
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 &
@ -162,14 +179,17 @@ typedef struct _cef_render_handler_t {
// copy, link).
///
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.
///
void(CEF_CALLBACK* on_scroll_offset_changed)(
struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
double x, double y);
struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
double x,
double y);
///
// Called when the IME composition range has changed. |selected_range| is the
@ -177,12 +197,13 @@ typedef struct _cef_render_handler_t {
// bounds of each character in view coordinates.
///
void(CEF_CALLBACK* on_ime_composition_range_changed)(
struct _cef_render_handler_t* self, struct _cef_browser_t* browser,
const cef_range_t* selected_range, size_t character_boundsCount,
struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
const cef_range_t* selected_range,
size_t character_boundsCount,
cef_rect_t const* character_bounds);
} cef_render_handler_t;
#ifdef __cplusplus
}
#endif

28
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
// more information.
//
// $hash=04ddf8c8cc5e09610a6cd6dbee96194eb6567b41$
//
#ifndef 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" {
#endif
///
// Structure used to implement render process callbacks. The functions of this
// structure will be called on the render process main thread (TID_RENDERER)
@ -108,8 +109,10 @@ typedef struct _cef_render_process_handler_t {
///
int(CEF_CALLBACK* on_before_navigation)(
struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
struct _cef_request_t* request, cef_navigation_type_t navigation_type,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
cef_navigation_type_t navigation_type,
int is_redirect);
///
@ -122,7 +125,8 @@ typedef struct _cef_render_process_handler_t {
///
void(CEF_CALLBACK* on_context_created)(
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);
///
@ -131,7 +135,8 @@ typedef struct _cef_render_process_handler_t {
///
void(CEF_CALLBACK* on_context_released)(
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);
///
@ -141,8 +146,10 @@ typedef struct _cef_render_process_handler_t {
///
void(CEF_CALLBACK* on_uncaught_exception)(
struct _cef_render_process_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
struct _cef_v8context_t* context, struct _cef_v8exception_t* exception,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_v8context_t* context,
struct _cef_v8exception_t* exception,
struct _cef_v8stack_trace_t* stackTrace);
///
@ -155,7 +162,8 @@ typedef struct _cef_render_process_handler_t {
///
void(CEF_CALLBACK* on_focused_node_changed)(
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);
///
@ -165,11 +173,11 @@ typedef struct _cef_render_process_handler_t {
///
int(CEF_CALLBACK* on_process_message_received)(
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);
} cef_render_process_handler_t;
#ifdef __cplusplus
}
#endif

26
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
// more information.
//
// $hash=e4d28f171862beea61f00e46d7acb8ee4154b077$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
@ -93,7 +95,8 @@ typedef struct _cef_request_t {
// ref component will be removed.
///
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.
@ -136,8 +139,10 @@ typedef struct _cef_request_t {
///
// Set all values at one time.
///
void (CEF_CALLBACK *set)(struct _cef_request_t* self, const cef_string_t* url,
const cef_string_t* method, struct _cef_post_data_t* postData,
void(CEF_CALLBACK* set)(struct _cef_request_t* self,
const cef_string_t* url,
const cef_string_t* method,
struct _cef_post_data_t* postData,
cef_string_multimap_t headerMap);
///
@ -190,13 +195,11 @@ typedef struct _cef_request_t {
uint64(CEF_CALLBACK* get_identifier)(struct _cef_request_t* self);
} cef_request_t;
///
// Create a new cef_request_t object.
///
CEF_EXPORT cef_request_t* cef_request_create();
///
// Structure used to represent post data for a web request. The functions of
// this structure may be called on any thread.
@ -229,7 +232,8 @@ typedef struct _cef_post_data_t {
// Retrieve the post data elements.
///
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
@ -250,13 +254,11 @@ typedef struct _cef_post_data_t {
void(CEF_CALLBACK* remove_elements)(struct _cef_post_data_t* self);
} cef_post_data_t;
///
// Create a new cef_post_data_t object.
///
CEF_EXPORT cef_post_data_t* cef_post_data_create();
///
// Structure used to represent a single element in the request post data. The
// functions of this structure may be called on any thread.
@ -288,7 +290,8 @@ typedef struct _cef_post_data_element_t {
// copied.
///
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.
@ -313,16 +316,15 @@ typedef struct _cef_post_data_element_t {
// actually read.
///
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;
///
// Create a new cef_post_data_element_t object.
///
CEF_EXPORT cef_post_data_element_t* cef_post_data_element_create();
#ifdef __cplusplus
}
#endif

30
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
// more information.
//
// $hash=791231acc78a2b601257fb0b86d904eace796d63$
//
#ifndef 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
// NULL if the resolution failed.
///
void (CEF_CALLBACK *on_resolve_completed)(
struct _cef_resolve_callback_t* self, cef_errorcode_t result,
void(CEF_CALLBACK* on_resolve_completed)(struct _cef_resolve_callback_t* self,
cef_errorcode_t result,
cef_string_list_t resolved_ips);
} cef_resolve_callback_t;
///
// 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
@ -152,7 +153,8 @@ typedef struct _cef_request_context_t {
// may be called on any thread in the browser process.
///
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,
struct _cef_scheme_handler_factory_t* factory);
@ -171,7 +173,8 @@ typedef struct _cef_request_context_t {
// the 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
@ -188,7 +191,8 @@ typedef struct _cef_request_context_t {
// called on the browser process UI thread.
///
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)
@ -199,7 +203,8 @@ typedef struct _cef_request_context_t {
// thread.
///
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
@ -218,7 +223,8 @@ typedef struct _cef_request_context_t {
// problem. This function must be called on the browser process UI thread.
///
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);
///
@ -248,7 +254,8 @@ typedef struct _cef_request_context_t {
// |callback| will be executed on the UI thread after completion.
///
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
@ -257,11 +264,11 @@ typedef struct _cef_request_context_t {
// success. This function must be called on the browser process IO thread.
///
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_request_context_t;
///
// Returns the global context object.
///
@ -283,7 +290,6 @@ CEF_EXPORT cef_request_context_t* cef_create_context_shared(
cef_request_context_t* other,
struct _cef_request_context_handler_t* handler);
#ifdef __cplusplus
}
#endif

10
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
// more information.
//
// $hash=9359e227c9d534c9c612d2ede790136461836501$
//
#ifndef 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" {
#endif
///
// Implement this structure to provide handler implementations. The handler
// instance will not be released until all objects related to the context have
@ -87,13 +88,14 @@ typedef struct _cef_request_context_handler_t {
///
int(CEF_CALLBACK* on_before_plugin_load)(
struct _cef_request_context_handler_t* self,
const cef_string_t* mime_type, const cef_string_t* plugin_url,
int is_main_frame, const cef_string_t* top_origin_url,
const cef_string_t* mime_type,
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,
cef_plugin_policy_t* plugin_policy);
} cef_request_context_handler_t;
#ifdef __cplusplus
}
#endif

109
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
// more information.
//
// $hash=b6cbe39a8124a961036205864e7e6b2e1eb0bf6b$
//
#ifndef CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
@ -53,7 +55,6 @@
extern "C" {
#endif
///
// Callback structure used for asynchronous continuation of url requests.
///
@ -75,7 +76,6 @@ typedef struct _cef_request_callback_t {
void(CEF_CALLBACK* cancel)(struct _cef_request_callback_t* self);
} cef_request_callback_t;
///
// Callback structure used to select a client certificate for authentication.
///
@ -94,7 +94,6 @@ typedef struct _cef_select_client_certificate_callback_t {
struct _cef_x509certificate_t* cert);
} cef_select_client_certificate_callback_t;
///
// Implement this structure to handle events related to browser requests. The
// functions of this structure will be called on the thread indicated.
@ -116,8 +115,10 @@ typedef struct _cef_request_handler_t {
// ERR_ABORTED.
///
int(CEF_CALLBACK* on_before_browse)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
struct _cef_request_t* request, int is_redirect);
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
int is_redirect);
///
// 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
// proceed in the source browser's top-level frame.
///
int (CEF_CALLBACK *on_open_urlfrom_tab)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
int(CEF_CALLBACK* on_open_urlfrom_tab)(
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
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|
@ -149,8 +153,10 @@ typedef struct _cef_request_handler_t {
//
///
cef_return_value_t(CEF_CALLBACK* on_before_resource_load)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
struct _cef_frame_t* frame, struct _cef_request_t* request,
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_request_callback_t* callback);
///
@ -160,8 +166,10 @@ typedef struct _cef_request_handler_t {
// modified in this callback.
///
struct _cef_resource_handler_t*(CEF_CALLBACK* get_resource_handler)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
struct _cef_frame_t* frame, struct _cef_request_t* request);
struct _cef_request_handler_t* self,
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|
@ -172,8 +180,10 @@ typedef struct _cef_request_handler_t {
// callback.
///
void(CEF_CALLBACK* on_resource_redirect)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
struct _cef_request_t* request, struct _cef_response_t* response,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response,
cef_string_t* new_url);
///
@ -183,8 +193,10 @@ typedef struct _cef_request_handler_t {
// The |response| object cannot be modified in this callback.
///
int(CEF_CALLBACK* on_resource_response)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
struct _cef_request_t* request, struct _cef_response_t* response);
struct _cef_browser_t* browser,
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.
@ -192,8 +204,10 @@ typedef struct _cef_request_handler_t {
// and cannot be modified in this callback.
///
struct _cef_response_filter_t*(CEF_CALLBACK* get_resource_response_filter)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
struct _cef_frame_t* frame, struct _cef_request_t* request,
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response);
///
@ -203,9 +217,12 @@ typedef struct _cef_request_handler_t {
// |received_content_length| is the number of response bytes actually read.
///
void(CEF_CALLBACK* on_resource_load_complete)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
struct _cef_frame_t* frame, struct _cef_request_t* request,
struct _cef_response_t* response, cef_urlrequest_status_t status,
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
struct _cef_request_t* request,
struct _cef_response_t* response,
cef_urlrequest_status_t status,
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
// request immediately.
///
int (CEF_CALLBACK *get_auth_credentials)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, 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);
int(CEF_CALLBACK* get_auth_credentials)(
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
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
@ -234,8 +257,10 @@ typedef struct _cef_request_handler_t {
// immediately.
///
int(CEF_CALLBACK* on_quota_request)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, const cef_string_t* origin_url,
int64 new_size, struct _cef_request_callback_t* callback);
struct _cef_browser_t* browser,
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
@ -244,9 +269,10 @@ typedef struct _cef_request_handler_t {
// YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR
// OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
///
void (CEF_CALLBACK *on_protocol_execution)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
const cef_string_t* url, int* allow_os_execution);
void(CEF_CALLBACK* on_protocol_execution)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
const cef_string_t* url,
int* allow_os_execution);
///
// 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
// be accepted without calling this function.
///
int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self,
struct _cef_browser_t* browser, cef_errorcode_t cert_error,
const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info,
int(CEF_CALLBACK* on_certificate_error)(
struct _cef_request_handler_t* self,
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);
///
@ -275,8 +304,11 @@ typedef struct _cef_request_handler_t {
// the server trusts.
///
int(CEF_CALLBACK* on_select_client_certificate)(
struct _cef_request_handler_t* self, struct _cef_browser_t* browser,
int isProxy, const cef_string_t* host, int port,
struct _cef_request_handler_t* self,
struct _cef_browser_t* browser,
int isProxy,
const cef_string_t* host,
int port,
size_t certificatesCount,
struct _cef_x509certificate_t* const* certificates,
struct _cef_select_client_certificate_callback_t* callback);
@ -286,7 +318,8 @@ typedef struct _cef_request_handler_t {
// |plugin_path| is the path of the plugin that crashed.
///
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
@ -301,11 +334,11 @@ typedef struct _cef_request_handler_t {
// unexpectedly. |status| indicates how the 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_request_handler_t;
#ifdef __cplusplus
}
#endif

19
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
// more information.
//
// $hash=82f2ce6f2ea3a8268ac69e33d304ace1a0e192b2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure used for retrieving resources from the resource bundle (*.pak)
// files loaded by CEF during startup or via the cef_resource_bundle_tHandler
@ -65,7 +66,8 @@ typedef struct _cef_resource_bundle_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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
@ -76,7 +78,9 @@ typedef struct _cef_resource_bundle_t {
// of valid resource ID values.
///
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
@ -89,17 +93,18 @@ typedef struct _cef_resource_bundle_t {
// of valid resource ID values.
///
int(CEF_CALLBACK* get_data_resource_for_scale)(
struct _cef_resource_bundle_t* self, int resource_id,
cef_scale_factor_t scale_factor, void** data, size_t* data_size);
struct _cef_resource_bundle_t* self,
int resource_id,
cef_scale_factor_t scale_factor,
void** data,
size_t* data_size);
} cef_resource_bundle_t;
///
// Returns the global resource bundle instance.
///
CEF_EXPORT cef_resource_bundle_t* cef_resource_bundle_get_global();
#ifdef __cplusplus
}
#endif

18
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
// more information.
//
// $hash=cd94d8670c26bf17082629e5297407a716f01503$
//
#ifndef 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" {
#endif
///
// Structure used to implement a custom resource bundle structure. See
// CefSettings for additional options related to resource bundle loading. The
@ -63,7 +64,8 @@ typedef struct _cef_resource_bundle_handler_t {
// cef_pack_strings.h for a listing of valid string ID values.
///
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);
///
@ -75,7 +77,9 @@ typedef struct _cef_resource_bundle_handler_t {
// resource ID values.
///
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);
///
@ -87,11 +91,13 @@ typedef struct _cef_resource_bundle_handler_t {
// cef_pack_resources.h for a listing of valid resource ID values.
///
int(CEF_CALLBACK* get_data_resource_for_scale)(
struct _cef_resource_bundle_handler_t* self, int resource_id,
cef_scale_factor_t scale_factor, void** data, size_t* data_size);
struct _cef_resource_bundle_handler_t* self,
int resource_id,
cef_scale_factor_t scale_factor,
void** data,
size_t* data_size);
} cef_resource_bundle_handler_t;
#ifdef __cplusplus
}
#endif

18
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
// more information.
//
// $hash=cd9c4ed153ad4425ff43d640a81693e3c83817d2$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
@ -49,7 +51,6 @@
extern "C" {
#endif
///
// Structure used to implement a custom request handler structure. The functions
// of this structure will always be called on the IO thread.
@ -68,7 +69,8 @@ typedef struct _cef_resource_handler_t {
// request return false (0).
///
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
@ -81,9 +83,10 @@ typedef struct _cef_resource_handler_t {
// URL. If an error occured while setting up the request you can call
// set_error() on |response| to indicate the error condition.
///
void (CEF_CALLBACK *get_response_headers)(
struct _cef_resource_handler_t* self, struct _cef_response_t* response,
int64* response_length, cef_string_t* redirectUrl);
void(CEF_CALLBACK* get_response_headers)(struct _cef_resource_handler_t* self,
struct _cef_response_t* response,
int64* response_length,
cef_string_t* redirectUrl);
///
// Read response data. If data is available immediately copy up to
@ -93,7 +96,9 @@ typedef struct _cef_resource_handler_t {
// data is available. To indicate response completion return false (0).
///
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);
///
@ -117,7 +122,6 @@ typedef struct _cef_resource_handler_t {
void(CEF_CALLBACK* cancel)(struct _cef_resource_handler_t* self);
} cef_resource_handler_t;
#ifdef __cplusplus
}
#endif

5
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
// more information.
//
// $hash=3f0ed89d2320677780c2fd526be7fe6312580cd8$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure used to represent a web response. The functions of this structure
// may be called on any thread.
@ -128,13 +129,11 @@ typedef struct _cef_response_t {
cef_string_multimap_t headerMap);
} cef_response_t;
///
// Create a new cef_response_t object.
///
CEF_EXPORT cef_response_t* cef_response_create();
#ifdef __cplusplus
}
#endif

12
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
// more information.
//
// $hash=c7126418fc448f9f75e770fda8434613eed0930d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Implement this structure to filter resource response content. The functions
// of this structure will be called on the browser process IO thread.
@ -93,12 +94,15 @@ typedef struct _cef_response_filter_t {
// Do not keep a reference to the buffers passed to this function.
///
cef_response_filter_status_t(CEF_CALLBACK* filter)(
struct _cef_response_filter_t* self, void* data_in, size_t data_in_size,
size_t* data_in_read, void* data_out, size_t data_out_size,
struct _cef_response_filter_t* self,
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);
} cef_response_filter_t;
#ifdef __cplusplus
}
#endif

21
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
// more information.
//
// $hash=a920e25c5ca348dcc45965d53389c16a8a29b0ed$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
@ -120,12 +122,15 @@ typedef struct _cef_scheme_registrar_t {
// if an error occurs this function will return false (0).
///
int(CEF_CALLBACK* add_custom_scheme)(struct _cef_scheme_registrar_t* self,
const cef_string_t* scheme_name, int is_standard, int is_local,
int is_display_isolated, int is_secure, int is_cors_enabled,
const cef_string_t* scheme_name,
int is_standard,
int is_local,
int is_display_isolated,
int is_secure,
int is_cors_enabled,
int is_csp_bypassing);
} cef_scheme_registrar_t;
///
// Structure that creates cef_resource_handler_t instances for handling scheme
// requests. The functions of this structure will always be called on the IO
@ -147,11 +152,12 @@ typedef struct _cef_scheme_handler_factory_t {
///
struct _cef_resource_handler_t*(CEF_CALLBACK* create)(
struct _cef_scheme_handler_factory_t* self,
struct _cef_browser_t* browser, struct _cef_frame_t* frame,
const cef_string_t* scheme_name, struct _cef_request_t* request);
struct _cef_browser_t* browser,
struct _cef_frame_t* frame,
const cef_string_t* scheme_name,
struct _cef_request_t* request);
} cef_scheme_handler_factory_t;
///
// 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
@ -168,7 +174,8 @@ typedef struct _cef_scheme_handler_factory_t {
// ory().
///
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);
///

7
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
// more information.
//
// $hash=7489f3078e15407c3984f0b2393df3b0ddc045b0$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Structure representing SSL information.
///
@ -60,8 +61,7 @@ typedef struct _cef_sslinfo_t {
// Returns a bitmask containing any and all problems verifying the server
// certificate.
///
cef_cert_status_t (CEF_CALLBACK *get_cert_status)(
struct _cef_sslinfo_t* self);
cef_cert_status_t(CEF_CALLBACK* get_cert_status)(struct _cef_sslinfo_t* self);
///
// Returns the X.509 certificate.
@ -70,7 +70,6 @@ typedef struct _cef_sslinfo_t {
struct _cef_sslinfo_t* self);
} cef_sslinfo_t;
///
// Returns true (1) if the certificate status has any error, major or minor.
///

4
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
// more information.
//
// $hash=2aa604a0520a802ae3b10f5922d4a7ca48078785$
//
#ifndef CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
@ -46,7 +48,6 @@
extern "C" {
#endif
///
// Structure representing the SSL information for a navigation entry.
///
@ -87,7 +88,6 @@ typedef struct _cef_sslstatus_t {
struct _cef_sslstatus_t* self);
} cef_sslstatus_t;
#ifdef __cplusplus
}
#endif

41
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
// more information.
//
// $hash=4e127106e9b5fada6bf05ea6e29bc502bb2a1e0d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Structure the client can implement to provide a custom stream reader. The
// functions of this structure may be called on any thread.
@ -58,14 +59,17 @@ typedef struct _cef_read_handler_t {
///
// Read raw binary data.
///
size_t (CEF_CALLBACK *read)(struct _cef_read_handler_t* self, void* ptr,
size_t size, size_t n);
size_t(CEF_CALLBACK* read)(struct _cef_read_handler_t* self,
void* ptr,
size_t size,
size_t n);
///
// 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.
///
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);
///
@ -86,7 +90,6 @@ typedef struct _cef_read_handler_t {
int(CEF_CALLBACK* may_block)(struct _cef_read_handler_t* self);
} cef_read_handler_t;
///
// Structure used to read data from a stream. The functions of this structure
// may be called on any thread.
@ -100,14 +103,17 @@ typedef struct _cef_stream_reader_t {
///
// Read raw binary data.
///
size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr,
size_t size, size_t n);
size_t(CEF_CALLBACK* read)(struct _cef_stream_reader_t* self,
void* ptr,
size_t size,
size_t n);
///
// 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.
///
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);
///
@ -128,7 +134,6 @@ typedef struct _cef_stream_reader_t {
int(CEF_CALLBACK* may_block)(struct _cef_stream_reader_t* self);
} cef_stream_reader_t;
///
// 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_read_handler_t* handler);
///
// Structure the client can implement to provide a custom stream writer. The
// functions of this structure may be called on any thread.
@ -162,13 +166,16 @@ typedef struct _cef_write_handler_t {
// Write raw binary data.
///
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_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);
///
@ -189,7 +196,6 @@ typedef struct _cef_write_handler_t {
int(CEF_CALLBACK* may_block)(struct _cef_write_handler_t* self);
} cef_write_handler_t;
///
// Structure used to write data to a stream. The functions of this structure may
// be called on any thread.
@ -204,13 +210,16 @@ typedef struct _cef_stream_writer_t {
// Write raw binary data.
///
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_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);
///
@ -231,7 +240,6 @@ typedef struct _cef_stream_writer_t {
int(CEF_CALLBACK* may_block)(struct _cef_stream_writer_t* self);
} cef_stream_writer_t;
///
// 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_write_handler_t* handler);
#ifdef __cplusplus
}
#endif

4
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
// more information.
//
// $hash=2e8edddfd49aea615c7adf8d0d092a4865b79229$
//
#ifndef CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Implement this structure to receive string values asynchronously.
///
@ -61,7 +62,6 @@ typedef struct _cef_string_visitor_t {
const cef_string_t* string);
} cef_string_visitor_t;
#ifdef __cplusplus
}
#endif

15
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
// more information.
//
// $hash=344ba415349b4cc305f51cb9e22563b232433e25$
//
#ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// Implement this structure for asynchronous task execution. If the task is
// posted successfully and if the associated message loop is still running then
@ -65,7 +66,6 @@ typedef struct _cef_task_t {
void(CEF_CALLBACK* execute)(struct _cef_task_t* self);
} cef_task_t;
///
// Structure that asynchronously executes tasks on the associated thread. It is
// safe to call the functions of this structure on any thread.
@ -91,8 +91,7 @@ typedef struct _cef_task_runner_t {
///
// Returns true (1) if this task runner belongs to the current thread.
///
int (CEF_CALLBACK *belongs_to_current_thread)(
struct _cef_task_runner_t* self);
int(CEF_CALLBACK* belongs_to_current_thread)(struct _cef_task_runner_t* self);
///
// Returns true (1) if this task runner is for the specified CEF thread.
@ -114,10 +113,10 @@ typedef struct _cef_task_runner_t {
// specified delay.
///
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;
///
// 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
@ -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_thread_id_t threadId);
///
// Returns true (1) if called on the specified thread. Equivalent to using
// 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,
// 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);
#ifdef __cplusplus

14
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
// more information.
//
// $hash=d844086fc675680bfae12c3fa12a6886cc804816$
//
#ifndef CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// 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
@ -91,7 +92,6 @@ typedef struct _cef_thread_t {
int(CEF_CALLBACK* is_running)(struct _cef_thread_t* self);
} cef_thread_t;
///
// 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
@ -103,10 +103,12 @@ typedef struct _cef_thread_t {
// 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.
///
CEF_EXPORT cef_thread_t* cef_thread_create(const cef_string_t* display_name,
cef_thread_priority_t priority, cef_message_loop_type_t message_loop_type,
int stoppable, cef_com_init_mode_t com_init_mode);
CEF_EXPORT cef_thread_t* cef_thread_create(
const cef_string_t* display_name,
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
}

4
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
// more information.
//
// $hash=2684497985a960a8699e6c24aeb17370cf318e88$
//
#ifndef CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Implement this structure to receive notification when tracing has completed.
// The functions of this structure will be called on the browser process UI
@ -67,7 +68,6 @@ typedef struct _cef_end_tracing_callback_t {
const cef_string_t* tracing_file);
} cef_end_tracing_callback_t;
///
// Start tracing events on all processes. Tracing is initialized asynchronously
// and |callback| will be executed on the UI thread after initialization is

34
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
// more information.
//
// $hash=d0ac53d1df275f9ea9cf19a6a07f8dce88f2b151$
//
#ifndef CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
@ -103,7 +105,6 @@ typedef struct _cef_urlrequest_t {
void(CEF_CALLBACK* cancel)(struct _cef_urlrequest_t* self);
} cef_urlrequest_t;
///
// Create a new URL request. Only GET, POST, HEAD, DELETE and PUT request
// 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.
///
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);
///
// 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
@ -140,8 +141,7 @@ typedef struct _cef_urlrequest_client_t {
// cef_urlrequest_t::GetRequestStatus function to determine if the request was
// successful or not.
///
void (CEF_CALLBACK *on_request_complete)(
struct _cef_urlrequest_client_t* self,
void(CEF_CALLBACK* on_request_complete)(struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_t* request);
///
@ -151,7 +151,9 @@ typedef struct _cef_urlrequest_client_t {
// UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
///
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
@ -159,8 +161,10 @@ typedef struct _cef_urlrequest_client_t {
// response (or -1 if not determined).
///
void(CEF_CALLBACK* on_download_progress)(
struct _cef_urlrequest_client_t* self, struct _cef_urlrequest_t* request,
int64 current, int64 total);
struct _cef_urlrequest_client_t* self,
struct _cef_urlrequest_t* request,
int64 current,
int64 total);
///
// Called when some part of the response is read. |data| contains the current
@ -168,7 +172,8 @@ typedef struct _cef_urlrequest_client_t {
// UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
///
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);
///
@ -181,12 +186,15 @@ typedef struct _cef_urlrequest_client_t {
// process.
///
int(CEF_CALLBACK* get_auth_credentials)(
struct _cef_urlrequest_client_t* self, 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);
struct _cef_urlrequest_client_t* self,
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);
} cef_urlrequest_client_t;
#ifdef __cplusplus
}
#endif

109
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
// more information.
//
// $hash=aecaacd4f1b5294258f4e78883bcfec0a5c5677f$
//
#ifndef CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
@ -131,11 +133,13 @@ typedef struct _cef_v8context_t {
// exception, if any, and the function will return false (0).
///
int(CEF_CALLBACK* eval)(struct _cef_v8context_t* self,
const cef_string_t* code, const cef_string_t* script_url, int start_line,
struct _cef_v8value_t** retval, struct _cef_v8exception_t** exception);
const cef_string_t* code,
const cef_string_t* script_url,
int start_line,
struct _cef_v8value_t** retval,
struct _cef_v8exception_t** exception);
} cef_v8context_t;
///
// 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();
///
// Structure that should be implemented to handle V8 function calls. The
// functions of this structure will be called on the thread associated with the
@ -171,12 +174,14 @@ typedef struct _cef_v8handler_t {
// that will be thrown. Return true (1) if execution was handled.
///
int(CEF_CALLBACK* execute)(struct _cef_v8handler_t* self,
const cef_string_t* name, struct _cef_v8value_t* object,
size_t argumentsCount, struct _cef_v8value_t* const* arguments,
struct _cef_v8value_t** retval, cef_string_t* exception);
const cef_string_t* name,
struct _cef_v8value_t* object,
size_t argumentsCount,
struct _cef_v8value_t* const* arguments,
struct _cef_v8value_t** retval,
cef_string_t* exception);
} cef_v8handler_t;
///
// Structure that should be implemented to handle V8 accessor calls. Accessor
// identifiers are registered by calling cef_v8value_t::set_value(). The
@ -197,8 +202,10 @@ typedef struct _cef_v8accessor_t {
// handled.
///
int(CEF_CALLBACK* get)(struct _cef_v8accessor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object,
struct _cef_v8value_t** retval, cef_string_t* exception);
const cef_string_t* name,
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
@ -208,11 +215,12 @@ typedef struct _cef_v8accessor_t {
// handled.
///
int(CEF_CALLBACK* set)(struct _cef_v8accessor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object,
struct _cef_v8value_t* value, cef_string_t* exception);
const cef_string_t* name,
struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception);
} cef_v8accessor_t;
///
// Structure that should be implemented to handle V8 interceptor calls. The
// functions of this structure will be called on the thread associated with the
@ -237,8 +245,10 @@ typedef struct _cef_v8interceptor_t {
// if interceptor retrieval was handled, false (0) otherwise.
///
int(CEF_CALLBACK* get_byname)(struct _cef_v8interceptor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object,
struct _cef_v8value_t** retval, cef_string_t* exception);
const cef_string_t* name,
struct _cef_v8value_t* object,
struct _cef_v8value_t** retval,
cef_string_t* exception);
///
// 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
// interceptor retrieval was handled, false (0) otherwise.
///
int (CEF_CALLBACK *get_byindex)(struct _cef_v8interceptor_t* self, int index,
struct _cef_v8value_t* object, struct _cef_v8value_t** retval,
int(CEF_CALLBACK* get_byindex)(struct _cef_v8interceptor_t* self,
int index,
struct _cef_v8value_t* object,
struct _cef_v8value_t** retval,
cef_string_t* exception);
///
@ -261,8 +273,10 @@ typedef struct _cef_v8interceptor_t {
// (1) if interceptor assignment was handled, false (0) otherwise.
///
int(CEF_CALLBACK* set_byname)(struct _cef_v8interceptor_t* self,
const cef_string_t* name, struct _cef_v8value_t* object,
struct _cef_v8value_t* value, cef_string_t* exception);
const cef_string_t* name,
struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception);
///
// 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
// interceptor assignment was handled, false (0) otherwise.
///
int (CEF_CALLBACK *set_byindex)(struct _cef_v8interceptor_t* self, int index,
struct _cef_v8value_t* object, struct _cef_v8value_t* value,
int(CEF_CALLBACK* set_byindex)(struct _cef_v8interceptor_t* self,
int index,
struct _cef_v8value_t* object,
struct _cef_v8value_t* value,
cef_string_t* exception);
} cef_v8interceptor_t;
///
// Structure representing a V8 exception. The functions of this structure may be
// called on any render process thread.
@ -340,7 +355,6 @@ typedef struct _cef_v8exception_t {
int(CEF_CALLBACK* get_end_column)(struct _cef_v8exception_t* self);
} cef_v8exception_t;
///
// 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
@ -455,7 +469,6 @@ typedef struct _cef_v8value_t {
cef_string_userfree_t(CEF_CALLBACK* get_string_value)(
struct _cef_v8value_t* self);
// OBJECT METHODS - These functions are only available on objects. Arrays and
// functions are also objects. String- and integer-based keys can be used
// interchangably with the framework converting between them as necessary.
@ -533,14 +546,15 @@ typedef struct _cef_v8value_t {
// this function is called incorrectly or an exception is thrown.
///
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
// this function is called incorrectly or an exception is thrown.
///
struct _cef_v8value_t* (CEF_CALLBACK *get_value_byindex)(
struct _cef_v8value_t* self, int index);
struct _cef_v8value_t*(
CEF_CALLBACK* get_value_byindex)(struct _cef_v8value_t* self, int index);
///
// Associates a value with the specified identifier and returns true (1) on
@ -549,7 +563,8 @@ typedef struct _cef_v8value_t {
// (1) even though assignment failed.
///
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);
///
@ -558,7 +573,8 @@ typedef struct _cef_v8value_t {
// exception is thrown. For read-only values this function will return true
// (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);
///
@ -569,7 +585,8 @@ typedef struct _cef_v8value_t {
// values this function will return true (1) even though assignment failed.
///
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);
///
@ -612,8 +629,8 @@ typedef struct _cef_v8value_t {
// adjustment. This function can only be called on user created objects.
///
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.
@ -622,7 +639,6 @@ typedef struct _cef_v8value_t {
///
int(CEF_CALLBACK* get_array_length)(struct _cef_v8value_t* self);
// FUNCTION METHODS - These functions are only available on functions.
///
@ -650,8 +666,10 @@ typedef struct _cef_v8value_t {
// thrown.
///
struct _cef_v8value_t*(CEF_CALLBACK* execute_function)(
struct _cef_v8value_t* self, struct _cef_v8value_t* object,
size_t argumentsCount, struct _cef_v8value_t* const* arguments);
struct _cef_v8value_t* self,
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
@ -662,12 +680,13 @@ typedef struct _cef_v8value_t {
// exception is thrown.
///
struct _cef_v8value_t*(CEF_CALLBACK* execute_function_with_context)(
struct _cef_v8value_t* self, struct _cef_v8context_t* context,
struct _cef_v8value_t* object, size_t argumentsCount,
struct _cef_v8value_t* self,
struct _cef_v8context_t* context,
struct _cef_v8value_t* object,
size_t argumentsCount,
struct _cef_v8value_t* const* arguments);
} cef_v8value_t;
///
// 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
// 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);
///
@ -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_v8handler_t* handler);
///
// Structure representing a V8 stack trace handle. V8 handles can only be
// accessed from the thread on which they are created. Valid threads for
@ -769,18 +788,16 @@ typedef struct _cef_v8stack_trace_t {
///
// Returns the stack frame at the specified 0-based index.
///
struct _cef_v8stack_frame_t* (CEF_CALLBACK *get_frame)(
struct _cef_v8stack_trace_t* self, int index);
struct _cef_v8stack_frame_t*(
CEF_CALLBACK* get_frame)(struct _cef_v8stack_trace_t* self, int index);
} cef_v8stack_trace_t;
///
// Returns the stack trace for the currently active context. |frame_limit| is
// the maximum number of frames that will be captured.
///
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
// accessed from the thread on which they are created. Valid threads for
@ -846,7 +863,6 @@ typedef struct _cef_v8stack_frame_t {
int(CEF_CALLBACK* is_constructor)(struct _cef_v8stack_frame_t* self);
} cef_v8stack_frame_t;
///
// Register a new V8 extension with the specified JavaScript extension code and
// handler. Functions implemented by the handler are prototyped using the
@ -904,7 +920,8 @@ typedef struct _cef_v8stack_frame_t {
// </pre>
///
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
}

102
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
// more information.
//
// $hash=4119ecd62e8c308a5876e6a7ac92cf3ff7df6425$
//
#ifndef CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
@ -214,13 +216,11 @@ typedef struct _cef_value_t {
struct _cef_list_value_t* value);
} cef_value_t;
///
// Creates a new object.
///
CEF_EXPORT cef_value_t* cef_value_create();
///
// Structure representing a binary value. Can be used on any process and thread.
///
@ -273,10 +273,11 @@ typedef struct _cef_binary_value_t {
// the specified byte |data_offset|. Returns the number of bytes read.
///
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;
///
// Creates a new object that is not owned by any other object. The specified
// |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,
size_t data_size);
///
// Structure representing a dictionary value. Can be used on any process and
// thread.
@ -334,7 +334,8 @@ typedef struct _cef_dictionary_value_t {
// (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* self, int exclude_empty_children);
struct _cef_dictionary_value_t* self,
int exclude_empty_children);
///
// Returns the number of values.
@ -368,8 +369,8 @@ typedef struct _cef_dictionary_value_t {
///
// Returns the value type for the specified key.
///
cef_value_type_t (CEF_CALLBACK *get_type)(
struct _cef_dictionary_value_t* self, const cef_string_t* key);
cef_value_type_t(CEF_CALLBACK* get_type)(struct _cef_dictionary_value_t* self,
const cef_string_t* key);
///
// Returns the value at the specified key. For simple types the returned value
@ -379,7 +380,8 @@ typedef struct _cef_dictionary_value_t {
// this object.
///
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.
@ -404,14 +406,16 @@ typedef struct _cef_dictionary_value_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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
// will reference existing data.
///
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
@ -419,7 +423,8 @@ typedef struct _cef_dictionary_value_t {
// modify this object.
///
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
@ -427,7 +432,8 @@ typedef struct _cef_dictionary_value_t {
// this object.
///
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
@ -438,7 +444,8 @@ typedef struct _cef_dictionary_value_t {
// this object.
///
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
@ -452,28 +459,32 @@ typedef struct _cef_dictionary_value_t {
// value was set successfully.
///
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
// value was set successfully.
///
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
// value was set successfully.
///
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
// value was set successfully.
///
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
@ -483,7 +494,8 @@ typedef struct _cef_dictionary_value_t {
// reference will be invalidated.
///
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
@ -493,7 +505,8 @@ typedef struct _cef_dictionary_value_t {
// reference will be invalidated.
///
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
@ -503,16 +516,15 @@ typedef struct _cef_dictionary_value_t {
// reference will be invalidated.
///
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;
///
// Creates a new object that is not owned by any other object.
///
CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create();
///
// Structure representing a list value. Can be used on any process and thread.
///
@ -559,8 +571,7 @@ typedef struct _cef_list_value_t {
///
// Returns a writable copy of this object.
///
struct _cef_list_value_t* (CEF_CALLBACK *copy)(
struct _cef_list_value_t* self);
struct _cef_list_value_t*(CEF_CALLBACK* copy)(struct _cef_list_value_t* self);
///
// Sets the number of values. If the number of values is expanded all new
@ -619,15 +630,15 @@ typedef struct _cef_list_value_t {
// Returns the value at the specified index as type string.
///
// The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)(
struct _cef_list_value_t* self, size_t index);
cef_string_userfree_t(
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
// will reference existing data.
///
struct _cef_binary_value_t* (CEF_CALLBACK *get_binary)(
struct _cef_list_value_t* self, size_t index);
struct _cef_binary_value_t*(
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
@ -635,15 +646,16 @@ typedef struct _cef_list_value_t {
// modify this object.
///
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
// will reference existing data and modifications to the value will modify
// this object.
///
struct _cef_list_value_t* (CEF_CALLBACK *get_list)(
struct _cef_list_value_t* self, size_t index);
struct _cef_list_value_t*(
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
@ -653,7 +665,8 @@ typedef struct _cef_list_value_t {
// then the underlying data will be referenced and modifications to |value|
// 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);
///
@ -666,28 +679,32 @@ typedef struct _cef_list_value_t {
// Sets the value at the specified index as type bool. Returns true (1) if the
// 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);
///
// Sets the value at the specified index as type int. Returns true (1) if the
// 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);
///
// Sets the value at the specified index as type double. Returns true (1) if
// 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);
///
// Sets the value at the specified index as type string. Returns true (1) if
// 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);
///
@ -697,7 +714,8 @@ typedef struct _cef_list_value_t {
// change. Otherwise, ownership will be transferred to this object and the
// |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);
///
@ -708,7 +726,8 @@ typedef struct _cef_list_value_t {
// reference will be invalidated.
///
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
@ -717,17 +736,16 @@ typedef struct _cef_list_value_t {
// Otherwise, ownership will be transferred to this object and the |value|
// 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);
} cef_list_value_t;
///
// Creates a new object that is not owned by any other object.
///
CEF_EXPORT cef_list_value_t* cef_list_value_create();
#ifdef __cplusplus
}
#endif

8
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
// more information.
//
// $hash=a8fdbd327fff7769353b0aba47c74cba61333144$
//
#ifndef CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
@ -44,7 +46,6 @@
extern "C" {
#endif
///
// 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
@ -98,7 +99,6 @@ typedef struct _cef_waitable_event_t {
int64 max_ms);
} cef_waitable_event_t;
///
// 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
@ -106,10 +106,10 @@ typedef struct _cef_waitable_event_t {
// manually. If |initially_signaled| is true (1) then the event will start in
// 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);
#ifdef __cplusplus
}
#endif

22
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
// more information.
//
// $hash=95dbecaa1c2b67c99e32d29e7bcd3aff4d126baf$
//
#ifndef CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
@ -84,7 +86,6 @@ typedef struct _cef_web_plugin_info_t {
struct _cef_web_plugin_info_t* self);
} cef_web_plugin_info_t;
///
// Structure to implement for visiting web plugin information. The functions of
// this structure will be called on the browser process UI thread.
@ -102,10 +103,11 @@ typedef struct _cef_web_plugin_info_visitor_t {
// called if no plugins are found.
///
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;
///
// Structure to implement for receiving unstable plugin information. The
// functions of this structure will be called on the browser process IO thread.
@ -123,10 +125,10 @@ typedef struct _cef_web_plugin_unstable_callback_t {
///
void(CEF_CALLBACK* is_unstable)(
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;
///
// Implement this structure to receive notification when CDM registration is
// complete. The functions of this structure will be called on the browser
@ -146,10 +148,10 @@ typedef struct _cef_register_cdm_callback_t {
///
void(CEF_CALLBACK* on_cdm_registration_complete)(
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;
///
// Visit web plugin information. Can be called on any thread in the browser
// 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
// 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);
///
@ -229,7 +232,8 @@ CEF_EXPORT void cef_is_web_plugin_unstable(const cef_string_t* path,
// |callback| will receive a |result| value of
// 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);
#ifdef __cplusplus

23
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
// more information.
//
// $hash=9eccfa7e4ebd9ccd0d3d7e0424a9595053e6febe$
//
#ifndef CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// Structure representing the issuer or subject field of an X.509 certificate.
///
@ -96,28 +97,31 @@ typedef struct _cef_x509cert_principal_t {
// Retrieve the list of 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.
///
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.
///
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.
///
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;
///
// Structure representing a X.509 certificate.
///
@ -187,7 +191,8 @@ typedef struct _cef_x509certificate_t {
// is an NULL string.
///
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);
///
@ -196,11 +201,11 @@ typedef struct _cef_x509certificate_t {
// is an NULL string.
///
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);
} cef_x509certificate_t;
#ifdef __cplusplus
}
#endif

28
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
// more information.
//
// $hash=8356c87c40363434391cc18f509b580860db4404$
//
#ifndef CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// 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
@ -82,7 +83,6 @@ typedef struct _cef_xml_reader_t {
cef_string_userfree_t(CEF_CALLBACK* get_error)(
struct _cef_xml_reader_t* self);
// The below functions retrieve data for the node at the current cursor
// position.
@ -177,14 +177,16 @@ typedef struct _cef_xml_reader_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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.
///
// The resulting string must be freed by calling cef_string_userfree_free().
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
@ -192,7 +194,8 @@ typedef struct _cef_xml_reader_t {
///
// The resulting string must be freed by calling cef_string_userfree_free().
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);
///
@ -214,7 +217,6 @@ typedef struct _cef_xml_reader_t {
///
int(CEF_CALLBACK* get_line_number)(struct _cef_xml_reader_t* self);
// 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()
// can be called afterwards to return the cursor to the carrying element. The
@ -231,7 +233,8 @@ typedef struct _cef_xml_reader_t {
// Moves the cursor to the attribute with the specified qualified name.
// 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);
///
@ -239,8 +242,10 @@ typedef struct _cef_xml_reader_t {
// namespace URI. Returns true (1) if the cursor position was set
// successfully.
///
int (CEF_CALLBACK *move_to_attribute_bylname)(struct _cef_xml_reader_t* self,
const cef_string_t* localName, const cef_string_t* namespaceURI);
int(CEF_CALLBACK* move_to_attribute_bylname)(
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
@ -261,16 +266,15 @@ typedef struct _cef_xml_reader_t {
int(CEF_CALLBACK* move_to_carrying_element)(struct _cef_xml_reader_t* self);
} cef_xml_reader_t;
///
// Create a new cef_xml_reader_t object. The returned object's functions can
// only be called from the thread that created the object.
///
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);
#ifdef __cplusplus
}
#endif

12
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
// more information.
//
// $hash=fec66a36497e467f3da1d2b86d0ae66b8cf709b7$
//
#ifndef CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
#define CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
@ -45,7 +47,6 @@
extern "C" {
#endif
///
// 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
@ -75,7 +76,8 @@ typedef struct _cef_zip_reader_t {
// cursor position was set successfully.
///
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
@ -83,7 +85,6 @@ typedef struct _cef_zip_reader_t {
///
int(CEF_CALLBACK* close)(struct _cef_zip_reader_t* self);
// The below functions act on the file at the current cursor position.
///
@ -120,7 +121,8 @@ typedef struct _cef_zip_reader_t {
// 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.
///
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);
///
@ -134,7 +136,6 @@ typedef struct _cef_zip_reader_t {
int(CEF_CALLBACK* eof)(struct _cef_zip_reader_t* self);
} cef_zip_reader_t;
///
// Create a new cef_zip_reader_t object. The returned object's functions can
// 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(
struct _cef_stream_reader_t* stream);
#ifdef __cplusplus
}
#endif

142
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
// more information.
//
// $hash=ec043910c391a84dda3b85cf01ea11cd44f37c1f$
//
#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
#define CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
@ -67,7 +69,6 @@ typedef struct _cef_translator_test_t {
///
cef_base_ref_counted_t base;
// PRIMITIVE VALUES
///
@ -129,27 +130,27 @@ typedef struct _cef_translator_test_t {
///
// Set a size_t value.
///
int (CEF_CALLBACK *set_sizet)(struct _cef_translator_test_t* self,
size_t val);
int(CEF_CALLBACK* set_sizet)(struct _cef_translator_test_t* self, size_t val);
///
// Set a int list value.
///
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.
///
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.
///
size_t(CEF_CALLBACK* get_int_list_size)(struct _cef_translator_test_t* self);
// STRING VALUES
///
@ -180,8 +181,8 @@ typedef struct _cef_translator_test_t {
///
// Return a string list value by out-param.
///
int (CEF_CALLBACK *get_string_list_by_ref)(
struct _cef_translator_test_t* self, cef_string_list_t val);
int(CEF_CALLBACK* get_string_list_by_ref)(struct _cef_translator_test_t* self,
cef_string_list_t val);
///
// Set a string map value.
@ -205,8 +206,8 @@ typedef struct _cef_translator_test_t {
// Return a string multimap value by out-param.
///
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
@ -231,13 +232,15 @@ typedef struct _cef_translator_test_t {
// Set a point list vlaue.
///
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.
///
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.
@ -245,7 +248,6 @@ typedef struct _cef_translator_test_t {
size_t(CEF_CALLBACK* get_point_list_size)(
struct _cef_translator_test_t* self);
// LIBRARY-SIDE REFPTR VALUES
///
@ -260,7 +262,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_library_t::get_value(). This tests input and
// 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);
///
@ -294,16 +297,20 @@ typedef struct _cef_translator_test_t {
// Set an object list vlaue.
///
int(CEF_CALLBACK* set_ref_ptr_library_list)(
struct _cef_translator_test_t* self, size_t valCount,
struct _cef_translator_test_ref_ptr_library_t* const* val, int val1,
struct _cef_translator_test_t* self,
size_t valCount,
struct _cef_translator_test_ref_ptr_library_t* const* val,
int val1,
int val2);
///
// Return an object list value by out-param.
///
int(CEF_CALLBACK* get_ref_ptr_library_list_by_ref)(
struct _cef_translator_test_t* self, size_t* valCount,
struct _cef_translator_test_ref_ptr_library_t** val, int val1,
struct _cef_translator_test_t* self,
size_t* valCount,
struct _cef_translator_test_ref_ptr_library_t** val,
int val1,
int val2);
///
@ -312,7 +319,6 @@ typedef struct _cef_translator_test_t {
size_t(CEF_CALLBACK* get_ref_ptr_library_list_size)(
struct _cef_translator_test_t* self);
// CLIENT-SIDE REFPTR VALUES
///
@ -320,7 +326,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_ref_ptr_client_t::get_value(). This tests input and
// 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);
///
@ -354,15 +361,18 @@ typedef struct _cef_translator_test_t {
// Set an object list vlaue.
///
int(CEF_CALLBACK* set_ref_ptr_client_list)(
struct _cef_translator_test_t* self, size_t valCount,
struct _cef_translator_test_ref_ptr_client_t* const* val, int val1,
struct _cef_translator_test_t* self,
size_t valCount,
struct _cef_translator_test_ref_ptr_client_t* const* val,
int val1,
int val2);
///
// Return an object list value by out-param.
///
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* val1,
struct _cef_translator_test_ref_ptr_client_t* val2);
@ -373,7 +383,6 @@ typedef struct _cef_translator_test_t {
size_t(CEF_CALLBACK* get_ref_ptr_client_list_size)(
struct _cef_translator_test_t* self);
// LIBRARY-SIDE OWNPTR VALUES
///
@ -388,7 +397,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_library_t::get_value(). This tests input and
// 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);
///
@ -418,7 +428,6 @@ typedef struct _cef_translator_test_t {
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_library_child_t* val);
// CLIENT-SIDE OWNPTR VALUES
///
@ -426,7 +435,8 @@ typedef struct _cef_translator_test_t {
// cef_translator_test_scoped_client_t::get_value(). This tests input and
// 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);
///
@ -456,7 +466,6 @@ typedef struct _cef_translator_test_t {
struct _cef_translator_test_t* self,
struct _cef_translator_test_scoped_client_child_t* val);
// 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
// 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);
///
@ -480,11 +490,12 @@ typedef struct _cef_translator_test_t {
// Set an object list vlaue.
///
int(CEF_CALLBACK* set_raw_ptr_library_list)(
struct _cef_translator_test_t* self, size_t valCount,
struct _cef_translator_test_scoped_library_t* const* val, int val1,
struct _cef_translator_test_t* self,
size_t valCount,
struct _cef_translator_test_scoped_library_t* const* val,
int val1,
int val2);
// 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
// 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);
///
@ -508,18 +520,18 @@ typedef struct _cef_translator_test_t {
// Set an object list vlaue.
///
int(CEF_CALLBACK* set_raw_ptr_client_list)(
struct _cef_translator_test_t* self, size_t valCount,
struct _cef_translator_test_scoped_client_t* const* val, int val1,
struct _cef_translator_test_t* self,
size_t valCount,
struct _cef_translator_test_scoped_client_t* const* val,
int val1,
int val2);
} cef_translator_test_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_t* cef_translator_test_create();
///
// Library-side test object for RefPtr.
///
@ -539,16 +551,15 @@ typedef struct _cef_translator_test_ref_ptr_library_t {
// Set a 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;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_ref_ptr_library_t* cef_translator_test_ref_ptr_library_create(
int value);
CEF_EXPORT cef_translator_test_ref_ptr_library_t*
cef_translator_test_ref_ptr_library_create(int value);
///
// Library-side child test object for RefPtr.
@ -569,16 +580,15 @@ typedef struct _cef_translator_test_ref_ptr_library_child_t {
// Set a 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;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_ref_ptr_library_child_t* cef_translator_test_ref_ptr_library_child_create(
int value, int other_value);
CEF_EXPORT cef_translator_test_ref_ptr_library_child_t*
cef_translator_test_ref_ptr_library_child_create(int value, int other_value);
///
// Another library-side child test object for RefPtr.
@ -603,13 +613,13 @@ typedef struct _cef_translator_test_ref_ptr_library_child_child_t {
int value);
} cef_translator_test_ref_ptr_library_child_child_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_ref_ptr_library_child_child_t* cef_translator_test_ref_ptr_library_child_child_create(
int value, int other_value, int other_other_value);
CEF_EXPORT cef_translator_test_ref_ptr_library_child_child_t*
cef_translator_test_ref_ptr_library_child_child_create(int value,
int other_value,
int other_other_value);
///
// Client-side test object for RefPtr.
@ -627,7 +637,6 @@ typedef struct _cef_translator_test_ref_ptr_client_t {
struct _cef_translator_test_ref_ptr_client_t* self);
} cef_translator_test_ref_ptr_client_t;
///
// Client-side child test object for RefPtr.
///
@ -644,7 +653,6 @@ typedef struct _cef_translator_test_ref_ptr_client_child_t {
struct _cef_translator_test_ref_ptr_client_child_t* self);
} cef_translator_test_ref_ptr_client_child_t;
///
// Library-side test object for OwnPtr/RawPtr.
///
@ -664,16 +672,15 @@ typedef struct _cef_translator_test_scoped_library_t {
// Set a 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;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_scoped_library_t* cef_translator_test_scoped_library_create(
int value);
CEF_EXPORT cef_translator_test_scoped_library_t*
cef_translator_test_scoped_library_create(int value);
///
// Library-side child test object for OwnPtr/RawPtr.
@ -694,16 +701,15 @@ typedef struct _cef_translator_test_scoped_library_child_t {
// Set a 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;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_scoped_library_child_t* cef_translator_test_scoped_library_child_create(
int value, int other_value);
CEF_EXPORT cef_translator_test_scoped_library_child_t*
cef_translator_test_scoped_library_child_create(int value, int other_value);
///
// Another library-side child test object for OwnPtr/RawPtr.
@ -728,13 +734,13 @@ typedef struct _cef_translator_test_scoped_library_child_child_t {
int value);
} cef_translator_test_scoped_library_child_child_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_scoped_library_child_child_t* cef_translator_test_scoped_library_child_child_create(
int value, int other_value, int other_other_value);
CEF_EXPORT cef_translator_test_scoped_library_child_child_t*
cef_translator_test_scoped_library_child_child_create(int value,
int other_value,
int other_other_value);
///
// Client-side test object for OwnPtr/RawPtr.
@ -752,7 +758,6 @@ typedef struct _cef_translator_test_scoped_client_t {
struct _cef_translator_test_scoped_client_t* self);
} cef_translator_test_scoped_client_t;
///
// Client-side child test object for OwnPtr/RawPtr.
///
@ -769,7 +774,6 @@ typedef struct _cef_translator_test_scoped_client_child_t {
struct _cef_translator_test_scoped_client_child_t* self);
} cef_translator_test_scoped_client_child_t;
#ifdef __cplusplus
}
#endif

6
include/capi/views/cef_box_layout_capi.h
View File

@ -33,6 +33,8 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=acbfe00533fba6a55e9a0d0d0c6a317f54dbf887$
//
#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_
#define CEF_INCLUDE_CAPI_VIEWS_CEF_BOX_LAYOUT_CAPI_H_
@ -68,7 +70,8 @@ typedef struct _cef_box_layout_t {
// resized. Flex values must not be negative.
///
void(CEF_CALLBACK* set_flex_for_view)(struct _cef_box_layout_t* self,
struct _cef_view_t* view, int flex);
struct _cef_view_t* view,
int flex);
///
// Clears the flex for the given |view|, causing it to use the default flex
@ -78,7 +81,6 @@ typedef struct _cef_box_layout_t {
struct _cef_view_t* view);
} cef_box_layout_t;
#ifdef __cplusplus
}
#endif

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