Source code
Revision control
Copy as Markdown
Other Tools
# HG changeset patch
# User Bob Owen <bobowencode@gmail.com>
Minor reversions for changes that require c++20 support.
diff --git a/base/check_op.h b/base/check_op.h
--- a/base/check_op.h
+++ b/base/check_op.h
@@ -65,17 +65,17 @@ BASE_EXPORT char* StreamValToStr(const v
#ifdef __has_builtin
#define SUPPORTS_BUILTIN_ADDRESSOF (__has_builtin(__builtin_addressof))
#else
#define SUPPORTS_BUILTIN_ADDRESSOF 0
#endif
template <typename T>
inline std::enable_if_t<
- base::internal::SupportsOstreamOperator<const T&> &&
+ base::internal::SupportsOstreamOperator<const T&>::value &&
!std::is_function_v<typename std::remove_pointer<T>::type>,
char*>
CheckOpValueStr(const T& v) {
auto f = [](std::ostream& s, const void* p) {
s << *reinterpret_cast<const T*>(p);
};
// operator& might be overloaded, so do the std::addressof dance.
@@ -90,18 +90,19 @@ CheckOpValueStr(const T& v) {
#endif
return StreamValToStr(vp, f);
}
#undef SUPPORTS_BUILTIN_ADDRESSOF
// Overload for types that have no operator<< but do have .ToString() defined.
template <typename T>
-inline std::enable_if_t<!base::internal::SupportsOstreamOperator<const T&> &&
- base::internal::SupportsToString<const T&>,
+inline std::enable_if_t<
+ !base::internal::SupportsOstreamOperator<const T&>::value &&
+ base::internal::SupportsToString<const T&>::value,
char*>
CheckOpValueStr(const T& v) {
// .ToString() may not return a std::string, e.g. blink::WTF::String.
return CheckOpValueStr(v.ToString());
}
// Provide an overload for functions and function pointers. Function pointers
// don't implicitly convert to void* but do implicitly convert to bool, so
@@ -114,18 +115,19 @@ inline std::enable_if_t<
char*>
CheckOpValueStr(const T& v) {
return CheckOpValueStr(reinterpret_cast<const void*>(v));
}
// We need overloads for enums that don't support operator<<.
// (i.e. scoped enums where no operator<< overload was declared).
template <typename T>
-inline std::enable_if_t<!base::internal::SupportsOstreamOperator<const T&> &&
- std::is_enum_v<T>,
+inline std::enable_if_t<
+ !base::internal::SupportsOstreamOperator<const T&>::value &&
+ std::is_enum_v<T>,
char*>
CheckOpValueStr(const T& v) {
return CheckOpValueStr(
static_cast<typename std::underlying_type<T>::type>(v));
}
// Takes ownership of `v1_str` and `v2_str`, destroying them with free(). For
// use with CheckOpValueStr() which allocates these strings using strdup().
diff --git a/base/containers/contiguous_iterator.h b/base/containers/contiguous_iterator.h
--- a/base/containers/contiguous_iterator.h
+++ b/base/containers/contiguous_iterator.h
@@ -38,17 +38,19 @@ struct IsStringIterImpl
//
// Note: Requires indirection via `IsStringIterImpl` to avoid triggering a
// `static_assert(is_trivial_v<value_type>)` inside libc++'s std::basic_string.
template <typename T>
struct IsStringIter
: std::conjunction<
std::disjunction<std::is_same<iter_value_t<T>, char>,
std::is_same<iter_value_t<T>, wchar_t>,
+#if !defined(MOZ_SANDBOX)
std::is_same<iter_value_t<T>, char8_t>,
+#endif
std::is_same<iter_value_t<T>, char16_t>,
std::is_same<iter_value_t<T>, char32_t>>,
IsStringIterImpl<T>> {};
// An iterator to std::array is contiguous.
template <typename T, typename ArrayT = std::array<iter_value_t<T>, 1>>
struct IsArrayIter
diff --git a/base/strings/to_string.h b/base/strings/to_string.h
--- a/base/strings/to_string.h
+++ b/base/strings/to_string.h
@@ -18,18 +18,21 @@
namespace base {
template <typename... Ts>
std::string ToString(const Ts&... values);
namespace internal {
+template <typename T, typename = void>
+struct SupportsToString : std::false_type {};
template <typename T>
-concept SupportsToString = requires(const T& t) { t.ToString(); };
+struct SupportsToString<T, decltype(void(std::declval<T>().ToString()))>
+ : std::true_type {};
// I/O manipulators are function pointers, but should be sent directly to the
// `ostream` instead of being cast to `const void*` like other function
// pointers.
template <typename T, typename = void>
constexpr bool IsIomanip = false;
template <typename T>
constexpr bool
@@ -51,50 +54,50 @@ template <typename T, typename = void>
struct ToStringHelper {
static void Stringify(const T& v, std::ostringstream& ss) {
ss << "[" << sizeof(v) << "-byte object at 0x" << std::addressof(v) << "]";
}
};
// Most streamables.
template <typename T>
-struct ToStringHelper<T,
- std::enable_if_t<SupportsOstreamOperator<const T&> &&
- !WillBeIncorrectlyStreamedAsBool<T>>> {
+struct ToStringHelper<
+ T, std::enable_if_t<SupportsOstreamOperator<const T&>::value &&
+ !WillBeIncorrectlyStreamedAsBool<T>>> {
static void Stringify(const T& v, std::ostringstream& ss) { ss << v; }
};
// Functions and function pointers.
template <typename T>
-struct ToStringHelper<T,
- std::enable_if_t<SupportsOstreamOperator<const T&> &&
- WillBeIncorrectlyStreamedAsBool<T>>> {
+struct ToStringHelper<
+ T, std::enable_if_t<SupportsOstreamOperator<const T&>::value &&
+ WillBeIncorrectlyStreamedAsBool<T>>> {
static void Stringify(const T& v, std::ostringstream& ss) {
ToStringHelper<const void*>::Stringify(reinterpret_cast<const void*>(v),
ss);
}
};
// Non-streamables that have a `ToString` member.
template <typename T>
-struct ToStringHelper<T,
- std::enable_if_t<!SupportsOstreamOperator<const T&> &&
- SupportsToString<const T&>>> {
+struct ToStringHelper<
+ T, std::enable_if_t<!SupportsOstreamOperator<const T&>::value &&
+ SupportsToString<const T&>::value>> {
static void Stringify(const T& v, std::ostringstream& ss) {
// .ToString() may not return a std::string, e.g. blink::WTF::String.
ToStringHelper<decltype(v.ToString())>::Stringify(v.ToString(), ss);
}
};
// Non-streamable enums (i.e. scoped enums where no `operator<<` overload was
// declared).
template <typename T>
struct ToStringHelper<
- T,
- std::enable_if_t<!SupportsOstreamOperator<const T&> && std::is_enum_v<T>>> {
+ T, std::enable_if_t<!SupportsOstreamOperator<const T&>::value &&
+ std::is_enum_v<T>>> {
static void Stringify(const T& v, std::ostringstream& ss) {
using UT = typename std::underlying_type_t<T>;
ToStringHelper<UT>::Stringify(static_cast<UT>(v), ss);
}
};
// Tuples. Will recursively apply `ToString()` to each value in the tuple.
template <typename... T>
diff --git a/base/types/strong_alias.h b/base/types/strong_alias.h
--- a/base/types/strong_alias.h
+++ b/base/types/strong_alias.h
@@ -149,17 +149,17 @@ class StrongAlias {
protected:
UnderlyingType value_;
};
// Stream operator for convenience, streams the UnderlyingType.
template <typename TagType,
typename UnderlyingType,
typename = std::enable_if_t<
- internal::SupportsOstreamOperator<UnderlyingType>>>
+ internal::SupportsOstreamOperator<UnderlyingType>::value>>
std::ostream& operator<<(std::ostream& stream,
const StrongAlias<TagType, UnderlyingType>& alias) {
return stream << alias.value();
}
} // namespace base
#endif // BASE_TYPES_STRONG_ALIAS_H_
diff --git a/sandbox/win/src/sandbox_policy_base.cc b/sandbox/win/src/sandbox_policy_base.cc
--- a/sandbox/win/src/sandbox_policy_base.cc
+++ b/sandbox/win/src/sandbox_policy_base.cc
@@ -805,12 +805,12 @@ absl::optional<base::span<const uint8_t>
return absl::nullopt;
}
void PolicyBase::AddDelegateData(base::span<const uint8_t> data) {
CHECK(data.size() > 0u);
// Can only set this once - as there is only one region sent to the child.
CHECK(!delegate_data_);
delegate_data_ =
- std::make_unique<std::vector<const uint8_t>>(data.begin(), data.end());
+ std::make_unique<const std::vector<uint8_t>>(data.begin(), data.end());
}
} // namespace sandbox
diff --git a/sandbox/win/src/sandbox_policy_base.h b/sandbox/win/src/sandbox_policy_base.h
--- a/sandbox/win/src/sandbox_policy_base.h
+++ b/sandbox/win/src/sandbox_policy_base.h
@@ -248,17 +248,17 @@ class PolicyBase final : public TargetPo
// Returns nullopt if no data has been set, or a view into the data.
absl::optional<base::span<const uint8_t>> delegate_data_span();
// The user-defined global policy settings.
HANDLE stdout_handle_;
HANDLE stderr_handle_;
// An opaque blob of data the delegate uses to prime any pre-sandbox hooks.
- std::unique_ptr<std::vector<const uint8_t>> delegate_data_;
+ std::unique_ptr<const std::vector<uint8_t>> delegate_data_;
std::unique_ptr<Dispatcher> dispatcher_;
// Contains the list of handles being shared with the target process.
// This list contains handles other than the stderr/stdout handles which are
// shared with the target at times.
base::HandlesToInheritVector handles_to_share_;
Job job_;