Bring the feedback button to the Mac sad tab

base/template_util.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_TEMPLATE_UTIL_H_
 #define BASE_TEMPLATE_UTIL_H_
 
 #include <stddef.h>
 #include <iosfwd>
 #include <type_traits>
@@ skipping 108 matching lines @@
 // TODO(crbug.com/554293): Remove this when all platforms have this in the std
 // namespace.
 #if defined(CR_USE_FALLBACKS_FOR_OLD_GLIBCXX)
 template <class T>
 using is_trivially_destructible = std::has_trivial_destructor<T>;
 #else
 template <class T>
 using is_trivially_destructible = std::is_trivially_destructible<T>;
 #endif
 
+#undef CR_USE_FALLBACKS_FOR_OLD_GLIBCXX

[Ilya Sherman, 2016/08/30 21:06:39]

nit: Why did you move this?  If you don't need to move it, it would be best to
move it back, so that it kind of follows a "normal" scoping pattern.

[Sidney San Martín, 2016/08/30 21:18:13]

I did have to move it, sadly. It needs the underlying_type implementation a few
lines above because we're on an old libstdc++ on Linux (crbug.com/593874).

[Sidney San Martín, 2016/08/30 21:30:32]

Sorry, just figured out what you meant. Fixed!

+
+// underlying_value
+// Casts an enum to its underlying integral type, leaves other values alone.
+// Useful for scoped enums, which don't cast implicitly.
+
+// Enums, taken by value. This specialization is necessary because creating an
+// std::underlying_type with a non-enum is UB (and usually a compile error).
+template <typename T,
+          typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
+constexpr typename underlying_type<T>::type underlying_value(T val) {
+  return static_cast<typename underlying_type<T>::type>(val);
+}
+
+// Non-enum scalars, taken by value. This specialization is necessary due to an
+// interesting case where a static const integral or enum data member can have
+// an inline initializer and no out-of-line definition, but then may only be
+// used in constant expressions. The catch-all specialization below would try
+// to form a const reference. Discussion here:
+// http://stackoverflow.com/questions/3792412/const-and-static-specifiers-in-c/3792427#3792427
+template <typename T,
+          typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
+constexpr T underlying_value(T val) {
+  return val;
+}
+
+// Non-scalars, taken by rvalue reference. T must be copyable or moveable, just
+// like a static_cast.
+template <typename T,
+          typename std::enable_if<
+              !std::is_scalar<typename std::remove_reference<T>::type>::value,
+              int>::type = 0>
+constexpr T underlying_value(T&& val) {
+  return std::forward<T>(val);
+}
+
 }  // namespace base
 
-#undef CR_USE_FALLBACKS_FOR_OLD_GLIBCXX
-
 #endif  // BASE_TEMPLATE_UTIL_H_