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
 
+// 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) {

[Nico, 2016/09/08 17:12:59]

This should be called UnderlyingType. This file is a mix of two things:

1. template utils we write
2. backfill for c++ standard library functions that don't exist on libstdc++4.6
yet (on linux)

This is of type 1, so it should use chrome style naming.

However, it looks like this is only used to pass enum class types to histograms
-- can't you just use plain enums in those two places and not need all this
machinery?

And if you _really_ want to do this, maybe we could discuss it in a separate CL
as changing these enums to enum classes seems kind of unrelated to this change

[Sidney San Martín, 2016/09/09 01:36:00]

Done. You're right that it should be left to a separate CL, and that there isn't
sufficient evidence that it's worth supporting scoped enums here.

+  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_