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

Update to Chromium revision 8cb76f56 (#307671)

Browse Source 
- Linux/Mac: Load V8 initial snapshot from external bin files (see http://crbug.com/421063).
- Windows: 8.1 SDK is now required (issue #1470).
- Remove CefDOMDocument::GetSelectionStartNode and GetSelectionEndNode methods(see https://codereview.chromium.org/763043004).
- Rename internal namespace used in base headers to avoid linker conflicts with cef_sandbox.lib.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1956 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2014-12-13 20:18:31 +00:00
parent ac81cbcdf1
commit 5a5d2caff2
81 changed files with 2159 additions and 2184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

322
include/base/cef_bind.h
View File

@@ -90,39 +90,39 @@ namespace base {
template <typename Functor>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
void()>
::UnboundRunType>
Bind(Functor functor) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
typedef typename cef_internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename cef_internal::FunctorTraits<Functor>::RunType RunType;
typedef internal::BindState<RunnableType, RunType, void()> BindState;
typedef cef_internal::BindState<RunnableType, RunType, void()> BindState;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor)));
new BindState(cef_internal::MakeRunnable(functor)));
}
template <typename Functor, typename P1>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType)>
typename cef_internal::BindState<
typename cef_internal::FunctorTraits<Functor>::RunnableType,
typename cef_internal::FunctorTraits<Functor>::RunType,
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 internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -139,37 +139,37 @@ Bind(Functor functor, const P1& p1) {
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
typedef internal::BindState<RunnableType, RunType,
void(typename 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(internal::MakeRunnable(functor), p1));
new BindState(cef_internal::MakeRunnable(functor), p1));
}
template <typename Functor, typename P1, typename P2>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType)>
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>
Bind(Functor functor, const P1& p1, const P2& p2) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -187,41 +187,41 @@ Bind(Functor functor, const P1& p1, const P2& p2) {
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
typedef cef_internal::BindState<RunnableType, RunType,
void(typename cef_internal::CallbackParamTraits<P1>::StorageType,
typename cef_internal::CallbackParamTraits<P2>::StorageType)> BindState;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2));
new BindState(cef_internal::MakeRunnable(functor), p1, p2));
}
template <typename Functor, typename P1, typename P2, typename P3>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType)>
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>
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -240,45 +240,45 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType)> BindState;
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;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2, p3));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType)>
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>
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 internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -298,51 +298,51 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
p4_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType)> BindState;
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;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
typename P5>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType)>
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,
const P5& p5) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -363,55 +363,55 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
p4_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
p5_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType)> BindState;
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;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType,
typename internal::CallbackParamTraits<P6>::StorageType)>
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,
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 internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -433,59 +433,59 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
p4_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
p5_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
p6_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType,
typename internal::CallbackParamTraits<P6>::StorageType)> BindState;
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;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
}
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6, typename P7>
base::Callback<
typename internal::BindState<
typename internal::FunctorTraits<Functor>::RunnableType,
typename internal::FunctorTraits<Functor>::RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType,
typename internal::CallbackParamTraits<P6>::StorageType,
typename internal::CallbackParamTraits<P7>::StorageType)>
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,
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) {
// Typedefs for how to store and run the functor.
typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
typedef typename internal::FunctorTraits<Functor>::RunType RunType;
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
// checks should below for bound references need to know what the actual
// functor is going to interpret the argument as.
typedef internal::FunctionTraits<typename RunnableType::RunType>
typedef cef_internal::FunctionTraits<typename RunnableType::RunType>
BoundFunctorTraits;
// Do not allow binding a non-const reference parameter. Non-const reference
@@ -508,36 +508,36 @@ Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
// methods. We also disallow binding of an array as the method's target
// object.
COMPILE_ASSERT(
internal::HasIsMethodTag<RunnableType>::value ||
!internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
cef_internal::HasIsMethodTag<RunnableType>::value ||
!cef_internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
p1_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
COMPILE_ASSERT(!cef_internal::HasIsMethodTag<RunnableType>::value ||
!is_array<P1>::value,
first_bound_argument_to_method_cannot_be_array);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
p2_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
p3_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
p4_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
p5_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
p6_is_refcounted_type_and_needs_scoped_refptr);
COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
COMPILE_ASSERT(!cef_internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
p7_is_refcounted_type_and_needs_scoped_refptr);
typedef internal::BindState<RunnableType, RunType,
void(typename internal::CallbackParamTraits<P1>::StorageType,
typename internal::CallbackParamTraits<P2>::StorageType,
typename internal::CallbackParamTraits<P3>::StorageType,
typename internal::CallbackParamTraits<P4>::StorageType,
typename internal::CallbackParamTraits<P5>::StorageType,
typename internal::CallbackParamTraits<P6>::StorageType,
typename internal::CallbackParamTraits<P7>::StorageType)> BindState;
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;
return Callback<typename BindState::UnboundRunType>(
new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
new BindState(cef_internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
p7));
}

32
include/base/cef_bind_helpers.h
View File

@@ -189,7 +189,7 @@
#include "include/base/cef_weak_ptr.h"
namespace base {
namespace internal {
namespace cef_internal {
// Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
// for the existence of AddRef() and Release() functions of the correct
@@ -531,21 +531,21 @@ struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
template <typename T>
struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};
} // namespace internal
} // namespace cef_internal
template <typename T>
static inline internal::UnretainedWrapper<T> Unretained(T* o) {
return internal::UnretainedWrapper<T>(o);
static inline cef_internal::UnretainedWrapper<T> Unretained(T* o) {
return cef_internal::UnretainedWrapper<T>(o);
}
template <typename T>
static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
return internal::ConstRefWrapper<T>(o);
static inline cef_internal::ConstRefWrapper<T> ConstRef(const T& o) {
return cef_internal::ConstRefWrapper<T>(o);
}
template <typename T>
static inline internal::OwnedWrapper<T> Owned(T* o) {
return internal::OwnedWrapper<T>(o);
static inline cef_internal::OwnedWrapper<T> Owned(T* o) {
return cef_internal::OwnedWrapper<T>(o);
}
// We offer 2 syntaxes for calling Passed(). The first takes a temporary and
@@ -553,23 +553,23 @@ static inline internal::OwnedWrapper<T> Owned(T* o) {
// takes a pointer to the scoper and is just syntactic sugar to avoid having
// to write Passed(scoper.Pass()).
template <typename T>
static inline internal::PassedWrapper<T> Passed(T scoper) {
return internal::PassedWrapper<T>(scoper.Pass());
static inline cef_internal::PassedWrapper<T> Passed(T scoper) {
return cef_internal::PassedWrapper<T>(scoper.Pass());
}
template <typename T>
static inline internal::PassedWrapper<T> Passed(T* scoper) {
return internal::PassedWrapper<T>(scoper->Pass());
static inline cef_internal::PassedWrapper<T> Passed(T* scoper) {
return cef_internal::PassedWrapper<T>(scoper->Pass());
}
template <typename T>
static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
return internal::IgnoreResultHelper<T>(data);
static inline cef_internal::IgnoreResultHelper<T> IgnoreResult(T data) {
return cef_internal::IgnoreResultHelper<T>(data);
}
template <typename T>
static inline internal::IgnoreResultHelper<Callback<T> >
static inline cef_internal::IgnoreResultHelper<Callback<T> >
IgnoreResult(const Callback<T>& data) {
return internal::IgnoreResultHelper<Callback<T> >(data);
return cef_internal::IgnoreResultHelper<Callback<T> >(data);
}
void DoNothing();

236
include/base/cef_callback.h
View File

@@ -397,13 +397,13 @@ namespace base {
template <typename Sig>
class Callback;
namespace internal {
namespace cef_internal {
template <typename Runnable, typename RunType, typename BoundArgsType>
struct BindState;
} // namespace internal
} // namespace cef_internal
template <typename R>
class Callback<R(void)> : public internal::CallbackBase {
class Callback<R(void)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)();
@@ -412,7 +412,7 @@ class Callback<R(void)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -420,7 +420,7 @@ class Callback<R(void)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -438,12 +438,12 @@ class Callback<R(void)> : public internal::CallbackBase {
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*);
cef_internal::BindStateBase*);
};
template <typename R, typename A1>
class Callback<R(A1)> : public internal::CallbackBase {
class Callback<R(A1)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1);
@@ -452,7 +452,7 @@ class Callback<R(A1)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -460,7 +460,7 @@ class Callback<R(A1)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -469,22 +469,22 @@ class Callback<R(A1)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1));
return f(bind_state_.get(), cef_internal::CallbackForward(a1));
}
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType);
};
template <typename R, typename A1, typename A2>
class Callback<R(A1, A2)> : public internal::CallbackBase {
class Callback<R(A1, A2)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1, A2);
@@ -493,7 +493,7 @@ class Callback<R(A1, A2)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -501,7 +501,7 @@ class Callback<R(A1, A2)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -510,25 +510,25 @@ class Callback<R(A1, A2)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2));
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2));
}
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType);
};
template <typename R, typename A1, typename A2, typename A3>
class Callback<R(A1, A2, A3)> : public internal::CallbackBase {
class Callback<R(A1, A2, A3)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1, A2, A3);
@@ -537,7 +537,7 @@ class Callback<R(A1, A2, A3)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -545,7 +545,7 @@ class Callback<R(A1, A2, A3)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -554,28 +554,28 @@ class Callback<R(A1, A2, A3)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2),
internal::CallbackForward(a3));
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2),
cef_internal::CallbackForward(a3));
}
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType,
typename internal::CallbackParamTraits<A3>::ForwardType);
cef_internal::BindStateBase*,
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>
class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase {
class Callback<R(A1, A2, A3, A4)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1, A2, A3, A4);
@@ -584,7 +584,7 @@ class Callback<R(A1, A2, A3, A4)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -592,7 +592,7 @@ class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -601,32 +601,32 @@ class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2),
internal::CallbackForward(a3),
internal::CallbackForward(a4));
return f(bind_state_.get(), cef_internal::CallbackForward(a1),
cef_internal::CallbackForward(a2),
cef_internal::CallbackForward(a3),
cef_internal::CallbackForward(a4));
}
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType,
typename internal::CallbackParamTraits<A3>::ForwardType,
typename internal::CallbackParamTraits<A4>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
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,
typename A5>
class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase {
class Callback<R(A1, A2, A3, A4, A5)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1, A2, A3, A4, A5);
@@ -635,7 +635,7 @@ class Callback<R(A1, A2, A3, A4, A5)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -643,7 +643,7 @@ class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -652,35 +652,35 @@ class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2),
internal::CallbackForward(a3),
internal::CallbackForward(a4),
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:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType,
typename internal::CallbackParamTraits<A3>::ForwardType,
typename internal::CallbackParamTraits<A4>::ForwardType,
typename internal::CallbackParamTraits<A5>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType,
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>
class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase {
class Callback<R(A1, A2, A3, A4, A5, A6)> : public cef_internal::CallbackBase {
public:
typedef R(RunType)(A1, A2, A3, A4, A5, A6);
@@ -689,7 +689,7 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -697,7 +697,7 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -706,38 +706,38 @@ class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5,
typename internal::CallbackParamTraits<A6>::ForwardType a6) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2),
internal::CallbackForward(a3),
internal::CallbackForward(a4),
internal::CallbackForward(a5),
internal::CallbackForward(a6));
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));
}
private:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType,
typename internal::CallbackParamTraits<A3>::ForwardType,
typename internal::CallbackParamTraits<A4>::ForwardType,
typename internal::CallbackParamTraits<A5>::ForwardType,
typename internal::CallbackParamTraits<A6>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType,
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 internal::CallbackBase {
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,7 +746,7 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public 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(internal::BindState<Runnable, BindRunType,
Callback(cef_internal::BindState<Runnable, BindRunType,
BoundArgsType>* bind_state)
: CallbackBase(bind_state) {
@@ -754,7 +754,7 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public internal::CallbackBase {
// so the compiler will typecheck that the passed in Run() method has
// the correct type.
PolymorphicInvoke invoke_func =
&internal::BindState<Runnable, BindRunType, BoundArgsType>
&cef_internal::BindState<Runnable, BindRunType, BoundArgsType>
::InvokerType::Run;
polymorphic_invoke_ = reinterpret_cast<InvokeFuncStorage>(invoke_func);
}
@@ -763,35 +763,35 @@ class Callback<R(A1, A2, A3, A4, A5, A6, A7)> : public internal::CallbackBase {
return CallbackBase::Equals(other);
}
R Run(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5,
typename internal::CallbackParamTraits<A6>::ForwardType a6,
typename internal::CallbackParamTraits<A7>::ForwardType a7) const {
R Run(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) const {
PolymorphicInvoke f =
reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
return f(bind_state_.get(), internal::CallbackForward(a1),
internal::CallbackForward(a2),
internal::CallbackForward(a3),
internal::CallbackForward(a4),
internal::CallbackForward(a5),
internal::CallbackForward(a6),
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:
typedef R(*PolymorphicInvoke)(
internal::BindStateBase*,
typename internal::CallbackParamTraits<A1>::ForwardType,
typename internal::CallbackParamTraits<A2>::ForwardType,
typename internal::CallbackParamTraits<A3>::ForwardType,
typename internal::CallbackParamTraits<A4>::ForwardType,
typename internal::CallbackParamTraits<A5>::ForwardType,
typename internal::CallbackParamTraits<A6>::ForwardType,
typename internal::CallbackParamTraits<A7>::ForwardType);
cef_internal::BindStateBase*,
typename cef_internal::CallbackParamTraits<A1>::ForwardType,
typename cef_internal::CallbackParamTraits<A2>::ForwardType,
typename cef_internal::CallbackParamTraits<A3>::ForwardType,
typename cef_internal::CallbackParamTraits<A4>::ForwardType,
typename cef_internal::CallbackParamTraits<A5>::ForwardType,
typename cef_internal::CallbackParamTraits<A6>::ForwardType,
typename cef_internal::CallbackParamTraits<A7>::ForwardType);
};

92
include/base/cef_callback_list.h
View File

@@ -111,7 +111,7 @@
namespace base {
namespace internal {
namespace cef_internal {
template <typename CallbackType>
class CallbackListBase {
@@ -240,20 +240,20 @@ class CallbackListBase {
DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
};
} // namespace internal
} // namespace cef_internal
template <typename Sig> class CallbackList;
template <>
class CallbackList<void(void)>
: public internal::CallbackListBase<Callback<void(void)> > {
: public cef_internal::CallbackListBase<Callback<void(void)> > {
public:
typedef Callback<void(void)> CallbackType;
CallbackList() {}
void Notify() {
internal::CallbackListBase<CallbackType>::Iterator it =
cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -267,14 +267,14 @@ class CallbackList<void(void)>
template <typename A1>
class CallbackList<void(A1)>
: public internal::CallbackListBase<Callback<void(A1)> > {
: public cef_internal::CallbackListBase<Callback<void(A1)> > {
public:
typedef Callback<void(A1)> CallbackType;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -288,15 +288,15 @@ class CallbackList<void(A1)>
template <typename A1, typename A2>
class CallbackList<void(A1, A2)>
: public internal::CallbackListBase<Callback<void(A1, A2)> > {
: public cef_internal::CallbackListBase<Callback<void(A1, A2)> > {
public:
typedef Callback<void(A1, A2)> CallbackType;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -310,16 +310,16 @@ class CallbackList<void(A1, A2)>
template <typename A1, typename A2, typename A3>
class CallbackList<void(A1, A2, A3)>
: public internal::CallbackListBase<Callback<void(A1, A2, A3)> > {
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3)> > {
public:
typedef Callback<void(A1, A2, A3)> CallbackType;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -333,17 +333,17 @@ class CallbackList<void(A1, A2, A3)>
template <typename A1, typename A2, typename A3, typename A4>
class CallbackList<void(A1, A2, A3, A4)>
: public internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > {
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4)> > {
public:
typedef Callback<void(A1, A2, A3, A4)> CallbackType;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -357,18 +357,18 @@ 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 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;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -383,20 +383,20 @@ class CallbackList<void(A1, A2, A3, A4, A5)>
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
class CallbackList<void(A1, A2, A3, A4, A5, A6)>
: public internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5,
: public cef_internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5,
A6)> > {
public:
typedef Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5,
typename internal::CallbackParamTraits<A6>::ForwardType a6) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
typename cef_internal::CallbackParamTraits<A6>::ForwardType a6) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {
@@ -411,21 +411,21 @@ class CallbackList<void(A1, A2, A3, A4, A5, A6)>
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 internal::CallbackListBase<Callback<void(A1, A2, A3, A4, A5, A6,
: 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;
CallbackList() {}
void Notify(typename internal::CallbackParamTraits<A1>::ForwardType a1,
typename internal::CallbackParamTraits<A2>::ForwardType a2,
typename internal::CallbackParamTraits<A3>::ForwardType a3,
typename internal::CallbackParamTraits<A4>::ForwardType a4,
typename internal::CallbackParamTraits<A5>::ForwardType a5,
typename internal::CallbackParamTraits<A6>::ForwardType a6,
typename internal::CallbackParamTraits<A7>::ForwardType a7) {
typename internal::CallbackListBase<CallbackType>::Iterator it =
void Notify(typename cef_internal::CallbackParamTraits<A1>::ForwardType a1,
typename cef_internal::CallbackParamTraits<A2>::ForwardType a2,
typename cef_internal::CallbackParamTraits<A3>::ForwardType a3,
typename cef_internal::CallbackParamTraits<A4>::ForwardType a4,
typename cef_internal::CallbackParamTraits<A5>::ForwardType a5,
typename cef_internal::CallbackParamTraits<A6>::ForwardType a6,
typename cef_internal::CallbackParamTraits<A7>::ForwardType a7) {
typename cef_internal::CallbackListBase<CallbackType>::Iterator it =
this->GetIterator();
CallbackType* cb;
while ((cb = it.GetNext()) != NULL) {

2
include/base/cef_lock.h
View File

@@ -113,7 +113,7 @@ class Lock {
#endif // NDEBUG
// Platform specific underlying lock implementation.
internal::LockImpl lock_;
cef_internal::LockImpl lock_;
DISALLOW_COPY_AND_ASSIGN(Lock);
};

14
include/base/cef_scoped_ptr.h
View File

@@ -215,7 +215,7 @@ struct FreeDeleter {
}
};
namespace internal {
namespace cef_internal {
template <typename T> struct IsNotRefCounted {
enum {
@@ -327,7 +327,7 @@ class scoped_ptr_impl {
DISALLOW_COPY_AND_ASSIGN(scoped_ptr_impl);
};
} // namespace internal
} // namespace cef_internal
} // namespace base
@@ -351,7 +351,7 @@ template <class T, class D = base::DefaultDeleter<T> >
class scoped_ptr {
MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value,
COMPILE_ASSERT(base::cef_internal::IsNotRefCounted<T>::value,
T_is_refcounted_type_and_needs_scoped_refptr);
public:
@@ -431,7 +431,7 @@ class scoped_ptr {
// scoped_ptr2" will compile but do the wrong thing (i.e., convert
// to Testable and then do the comparison).
private:
typedef base::internal::scoped_ptr_impl<element_type, deleter_type>
typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
scoped_ptr::*Testable;
public:
@@ -471,7 +471,7 @@ class scoped_ptr {
private:
// Needed to reach into |impl_| in the constructor.
template <typename U, typename V> friend class scoped_ptr;
base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
// Forbidden for API compatibility with std::unique_ptr.
explicit scoped_ptr(int disallow_construction_from_null);
@@ -541,7 +541,7 @@ class scoped_ptr<T[], D> {
// Allow scoped_ptr<element_type> to be used in boolean expressions, but not
// implicitly convertible to a real bool (which is dangerous).
private:
typedef base::internal::scoped_ptr_impl<element_type, deleter_type>
typedef base::cef_internal::scoped_ptr_impl<element_type, deleter_type>
scoped_ptr::*Testable;
public:
@@ -572,7 +572,7 @@ class scoped_ptr<T[], D> {
enum { type_must_be_complete = sizeof(element_type) };
// Actually hold the data.
base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
base::cef_internal::scoped_ptr_impl<element_type, deleter_type> impl_;
// Disable initialization from any type other than element_type*, by
// providing a constructor that matches such an initialization, but is

14
include/base/cef_template_util.h
View File

@@ -118,7 +118,7 @@ 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 {};
namespace internal {
namespace cef_internal {
// Types YesType and NoType are guaranteed such that sizeof(YesType) <
// sizeof(NoType).
@@ -158,7 +158,7 @@ struct IsClassHelper {
static NoType Test(...);
};
} // namespace internal
} // namespace cef_internal
// Inherits from true_type if From is convertible to To, false_type otherwise.
//
@@ -167,16 +167,16 @@ struct IsClassHelper {
template <typename From, typename To>
struct is_convertible
: integral_constant<bool,
sizeof(internal::ConvertHelper::Test<To>(
internal::ConvertHelper::Create<From>())) ==
sizeof(internal::YesType)> {
sizeof(cef_internal::ConvertHelper::Test<To>(
cef_internal::ConvertHelper::Create<From>())) ==
sizeof(cef_internal::YesType)> {
};
template <typename T>
struct is_class
: integral_constant<bool,
sizeof(internal::IsClassHelper::Test<T>(0)) ==
sizeof(internal::YesType)> {
sizeof(cef_internal::IsClassHelper::Test<T>(0)) ==
sizeof(cef_internal::YesType)> {
};
template<bool B, class T = void>

404
include/base/cef_tuple.h
View File

@@ -580,86 +580,86 @@ inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
template <class ObjT, class Method, class A>
inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
}
template <class ObjT, class Method, class A>
inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
}
template<class ObjT, class Method, class A, class B>
inline void DispatchToMethod(ObjT* obj,
Method method,
const Tuple2<A, B>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
}
template<class ObjT, class Method, class A, class B, class C>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<A, B, C>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
}
template<class ObjT, class Method, class A, class B, class C, class D>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<A, B, C, D>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<A, B, C, D, E>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E,
class F>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<A, B, C, D, E, F>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E,
class F, class G>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple7<A, B, C, D, E, F, G>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f),
base::internal::UnwrapTraits<G>::Unwrap(arg.g));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E,
class F, class G, class H>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple8<A, B, C, D, E, F, G, H>& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f),
base::internal::UnwrapTraits<G>::Unwrap(arg.g),
base::internal::UnwrapTraits<H>::Unwrap(arg.h));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
}
// Static Dispatchers with no out params.
@@ -676,77 +676,77 @@ inline void DispatchToFunction(Function function, const A& arg) {
template <class Function, class A>
inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
}
template<class Function, class A, class B>
inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
}
template<class Function, class A, class B, class C>
inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
}
template<class Function, class A, class B, class C, class D>
inline void DispatchToFunction(Function function,
const Tuple4<A, B, C, D>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
}
template<class Function, class A, class B, class C, class D, class E>
inline void DispatchToFunction(Function function,
const Tuple5<A, B, C, D, E>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
}
template<class Function, class A, class B, class C, class D, class E, class F>
inline void DispatchToFunction(Function function,
const Tuple6<A, B, C, D, E, F>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
}
template<class Function, class A, class B, class C, class D, class E, class F,
class G>
inline void DispatchToFunction(Function function,
const Tuple7<A, B, C, D, E, F, G>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f),
base::internal::UnwrapTraits<G>::Unwrap(arg.g));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g));
}
template<class Function, class A, class B, class C, class D, class E, class F,
class G, class H>
inline void DispatchToFunction(Function function,
const Tuple8<A, B, C, D, E, F, G, H>& arg) {
(*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f),
base::internal::UnwrapTraits<G>::Unwrap(arg.g),
base::internal::UnwrapTraits<H>::Unwrap(arg.h));
(*function)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f),
base::cef_internal::UnwrapTraits<G>::Unwrap(arg.g),
base::cef_internal::UnwrapTraits<H>::Unwrap(arg.h));
}
// Dispatchers with 0 out param (as a Tuple0).
@@ -760,61 +760,61 @@ inline void DispatchToMethod(ObjT* obj,
template <class ObjT, class Method, class A>
inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg));
}
template <class ObjT, class Method, class A>
inline void DispatchToMethod(ObjT* obj,
Method method,
const Tuple1<A>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a));
}
template<class ObjT, class Method, class A, class B>
inline void DispatchToMethod(ObjT* obj,
Method method,
const Tuple2<A, B>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b));
}
template<class ObjT, class Method, class A, class B, class C>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<A, B, C>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c));
}
template<class ObjT, class Method, class A, class B, class C, class D>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<A, B, C, D>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e));
}
template<class ObjT, class Method, class A, class B, class C, class D, class E,
class F>
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
base::internal::UnwrapTraits<B>::Unwrap(arg.b),
base::internal::UnwrapTraits<C>::Unwrap(arg.c),
base::internal::UnwrapTraits<D>::Unwrap(arg.d),
base::internal::UnwrapTraits<E>::Unwrap(arg.e),
base::internal::UnwrapTraits<F>::Unwrap(arg.f));
(obj->*method)(base::cef_internal::UnwrapTraits<A>::Unwrap(arg.a),
base::cef_internal::UnwrapTraits<B>::Unwrap(arg.b),
base::cef_internal::UnwrapTraits<C>::Unwrap(arg.c),
base::cef_internal::UnwrapTraits<D>::Unwrap(arg.d),
base::cef_internal::UnwrapTraits<E>::Unwrap(arg.e),
base::cef_internal::UnwrapTraits<F>::Unwrap(arg.f));
}
// Dispatchers with 1 out param.
@@ -840,7 +840,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple1<InA>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
}
template<class ObjT, class Method, class InA, class InB,
@@ -848,8 +848,8 @@ template<class ObjT, class Method, class InA, class InB,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple2<InA, InB>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
&out->a);
}
@@ -858,9 +858,9 @@ template<class ObjT, class Method, class InA, class InB, class InC,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<InA, InB, InC>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
&out->a);
}
@@ -869,10 +869,10 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<InA, InB, InC, InD>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
&out->a);
}
@@ -881,11 +881,11 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<InA, InB, InC, InD, InE>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
&out->a);
}
@@ -895,12 +895,12 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<InA, InB, InC, InD, InE, InF>& in,
Tuple1<OutA>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
base::internal::UnwrapTraits<InF>::Unwrap(in.f),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
&out->a);
}
@@ -928,7 +928,7 @@ inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple1<InA>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(
base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
}
template<class ObjT, class Method, class InA, class InB,
@@ -936,8 +936,8 @@ template<class ObjT, class Method, class InA, class InB,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple2<InA, InB>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
&out->a,
&out->b);
}
@@ -947,9 +947,9 @@ template<class ObjT, class Method, class InA, class InB, class InC,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<InA, InB, InC>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
&out->a,
&out->b);
}
@@ -959,10 +959,10 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<InA, InB, InC, InD>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
&out->a,
&out->b);
}
@@ -973,11 +973,11 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<InA, InB, InC, InD, InE>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
&out->a,
&out->b);
}
@@ -988,12 +988,12 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<InA, InB, InC, InD, InE, InF>& in,
Tuple2<OutA, OutB>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
base::internal::UnwrapTraits<InF>::Unwrap(in.f),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
&out->a,
&out->b);
}
@@ -1021,7 +1021,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple1<InA>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
&out->a,
&out->b,
&out->c);
@@ -1032,8 +1032,8 @@ template<class ObjT, class Method, class InA, class InB,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple2<InA, InB>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
&out->a,
&out->b,
&out->c);
@@ -1044,9 +1044,9 @@ template<class ObjT, class Method, class InA, class InB, class InC,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<InA, InB, InC>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
&out->a,
&out->b,
&out->c);
@@ -1057,10 +1057,10 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<InA, InB, InC, InD>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
&out->a,
&out->b,
&out->c);
@@ -1072,11 +1072,11 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<InA, InB, InC, InD, InE>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
&out->a,
&out->b,
&out->c);
@@ -1088,12 +1088,12 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<InA, InB, InC, InD, InE, InF>& in,
Tuple3<OutA, OutB, OutC>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
base::internal::UnwrapTraits<InF>::Unwrap(in.f),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
&out->a,
&out->b,
&out->c);
@@ -1114,7 +1114,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const InA& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
&out->a,
&out->b,
&out->c,
@@ -1126,7 +1126,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple1<InA>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
&out->a,
&out->b,
&out->c,
@@ -1138,8 +1138,8 @@ template<class ObjT, class Method, class InA, class InB,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple2<InA, InB>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
&out->a,
&out->b,
&out->c,
@@ -1151,9 +1151,9 @@ template<class ObjT, class Method, class InA, class InB, class InC,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<InA, InB, InC>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
&out->a,
&out->b,
&out->c,
@@ -1165,10 +1165,10 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<InA, InB, InC, InD>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
&out->a,
&out->b,
&out->c,
@@ -1181,11 +1181,11 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<InA, InB, InC, InD, InE>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
&out->a,
&out->b,
&out->c,
@@ -1198,12 +1198,12 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<InA, InB, InC, InD, InE, InF>& in,
Tuple4<OutA, OutB, OutC, OutD>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
base::internal::UnwrapTraits<InF>::Unwrap(in.f),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
&out->a,
&out->b,
&out->c,
@@ -1225,7 +1225,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const InA& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in),
&out->a,
&out->b,
&out->c,
@@ -1238,7 +1238,7 @@ template<class ObjT, class Method, class InA,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple1<InA>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
&out->a,
&out->b,
&out->c,
@@ -1251,8 +1251,8 @@ template<class ObjT, class Method, class InA, class InB,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple2<InA, InB>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
&out->a,
&out->b,
&out->c,
@@ -1265,9 +1265,9 @@ template<class ObjT, class Method, class InA, class InB, class InC,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple3<InA, InB, InC>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
&out->a,
&out->b,
&out->c,
@@ -1280,10 +1280,10 @@ template<class ObjT, class Method, class InA, class InB, class InC, class InD,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple4<InA, InB, InC, InD>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
&out->a,
&out->b,
&out->c,
@@ -1297,11 +1297,11 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple5<InA, InB, InC, InD, InE>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
&out->a,
&out->b,
&out->c,
@@ -1315,12 +1315,12 @@ template<class ObjT, class Method,
inline void DispatchToMethod(ObjT* obj, Method method,
const Tuple6<InA, InB, InC, InD, InE, InF>& in,
Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
(obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
base::internal::UnwrapTraits<InB>::Unwrap(in.b),
base::internal::UnwrapTraits<InC>::Unwrap(in.c),
base::internal::UnwrapTraits<InD>::Unwrap(in.d),
base::internal::UnwrapTraits<InE>::Unwrap(in.e),
base::internal::UnwrapTraits<InF>::Unwrap(in.f),
(obj->*method)(base::cef_internal::UnwrapTraits<InA>::Unwrap(in.a),
base::cef_internal::UnwrapTraits<InB>::Unwrap(in.b),
base::cef_internal::UnwrapTraits<InC>::Unwrap(in.c),
base::cef_internal::UnwrapTraits<InD>::Unwrap(in.d),
base::cef_internal::UnwrapTraits<InE>::Unwrap(in.e),
base::cef_internal::UnwrapTraits<InF>::Unwrap(in.f),
&out->a,
&out->b,
&out->c,

22
include/base/cef_weak_ptr.h
View File

@@ -114,7 +114,7 @@ namespace base {
template <typename T> class SupportsWeakPtr;
template <typename T> class WeakPtr;
namespace internal {
namespace cef_internal {
// These classes are part of the WeakPtr implementation.
// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
@@ -195,7 +195,7 @@ class SupportsWeakPtrBase {
template<typename Derived>
static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
typedef
is_convertible<Derived, internal::SupportsWeakPtrBase&> convertible;
is_convertible<Derived, cef_internal::SupportsWeakPtrBase&> convertible;
COMPILE_ASSERT(convertible::value,
AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
return AsWeakPtrImpl<Derived>(t, *t);
@@ -213,7 +213,7 @@ class SupportsWeakPtrBase {
}
};
} // namespace internal
} // namespace cef_internal
template <typename T> class WeakPtrFactory;
@@ -231,7 +231,7 @@ template <typename T> class WeakPtrFactory;
// foo->method();
//
template <typename T>
class WeakPtr : public internal::WeakPtrBase {
class WeakPtr : public cef_internal::WeakPtrBase {
public:
WeakPtr() : ptr_(NULL) {
}
@@ -267,7 +267,7 @@ class WeakPtr : public internal::WeakPtrBase {
operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; }
void reset() {
ref_ = internal::WeakReference();
ref_ = cef_internal::WeakReference();
ptr_ = NULL;
}
@@ -277,12 +277,12 @@ class WeakPtr : public internal::WeakPtrBase {
template <class U> bool operator==(WeakPtr<U> const&) const;
template <class U> bool operator!=(WeakPtr<U> const&) const;
friend class internal::SupportsWeakPtrBase;
friend class cef_internal::SupportsWeakPtrBase;
template <typename U> friend class WeakPtr;
friend class SupportsWeakPtr<T>;
friend class WeakPtrFactory<T>;
WeakPtr(const internal::WeakReference& ref, T* ptr)
WeakPtr(const cef_internal::WeakReference& ref, T* ptr)
: WeakPtrBase(ref),
ptr_(ptr) {
}
@@ -325,7 +325,7 @@ class WeakPtrFactory {
}
private:
internal::WeakReferenceOwner weak_reference_owner_;
cef_internal::WeakReferenceOwner weak_reference_owner_;
T* ptr_;
DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
};
@@ -336,7 +336,7 @@ class WeakPtrFactory {
// weak pointers to the class until after the derived class' members have been
// destroyed, its use can lead to subtle use-after-destroy issues.
template <class T>
class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
class SupportsWeakPtr : public cef_internal::SupportsWeakPtrBase {
public:
SupportsWeakPtr() {}
@@ -348,7 +348,7 @@ class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
~SupportsWeakPtr() {}
private:
internal::WeakReferenceOwner weak_reference_owner_;
cef_internal::WeakReferenceOwner weak_reference_owner_;
DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
};
@@ -372,7 +372,7 @@ class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
template <typename Derived>
WeakPtr<Derived> AsWeakPtr(Derived* t) {
return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
return cef_internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
}
} // namespace base

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

@@ -44,7 +44,7 @@
#endif
namespace base {
namespace internal {
namespace cef_internal {
// See base/callback.h for user documentation.
//
@@ -2805,7 +2805,7 @@ struct BindState<Runnable, RunType, void(P1, P2, P3, P4, P5, P6,
P7 p7_;
};
} // namespace internal
} // namespace cef_internal
} // namespace base
#endif // CEF_INCLUDE_BASE_INTERNAL_CEF_BIND_INTERNAL_H_

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

@@ -41,7 +41,7 @@
#if !defined(ARCH_CPU_X86_64)
namespace base {
namespace internal {
namespace cef_internal {
template <typename Functor>
class RunnableAdapter;
@@ -382,7 +382,7 @@ class RunnableAdapter<R(__fastcall *)(A1, A2, A3, A4, A5, A6, A7)> {
R (__fastcall *function_)(A1, A2, A3, A4, A5, A6, A7);
};
} // namespace internal
} // namespace cef_internal
} // namespace base
#endif // !defined(ARCH_CPU_X86_64)

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

@@ -45,7 +45,7 @@ template <typename T>
class ScopedVector;
namespace base {
namespace internal {
namespace cef_internal {
// BindStateBase is used to provide an opaque handle that the Callback
// class can use to represent a function object with bound arguments. It
@@ -199,7 +199,7 @@ typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) {
return t.Pass();
}
} // namespace internal
} // namespace cef_internal
} // namespace base
#endif // CEF_INCLUDE_BASE_INTERNAL_CEF_CALLBACK_INTERNAL_H_

4
include/base/internal/cef_lock_impl.h
View File

@@ -43,7 +43,7 @@
#include "include/base/cef_macros.h"
namespace base {
namespace internal {
namespace cef_internal {
// This class implements the underlying platform-specific spin-lock mechanism
// used for the Lock class. Most users should not use LockImpl directly, but
@@ -81,7 +81,7 @@ class LockImpl {
DISALLOW_COPY_AND_ASSIGN(LockImpl);
};
} // namespace internal
} // namespace cef_internal
} // namespace base
#endif // CEF_INCLUDE_BASE_INTERNAL_CEF_LOCK_IMPL_H_

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

@@ -46,7 +46,7 @@
namespace base {
namespace internal {
namespace cef_internal {
template <typename T>
struct NeedsScopedRefptrButGetsRawPtr {
@@ -147,7 +147,7 @@ struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H> > {
NeedsScopedRefptrButGetsRawPtr<H>::value) };
};
} // namespace internal
} // namespace cef_internal
} // namespace base