logging: Provide a specific MakeCheckOpValueString overload for functions

base/logging.h

 // Copyright (c) 2012 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_LOGGING_H_
 #define BASE_LOGGING_H_
 
 #include <stddef.h>
 
 #include <cassert>
@@ skipping 509 matching lines @@
    ;                                                                           \
   else                                                                         \
     ::logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()).stream()
 
 #endif  // !(OFFICIAL_BUILD && NDEBUG)
 
 // This formats a value for a failing CHECK_XX statement.  Ordinarily,
 // it uses the definition for operator<<, with a few special cases below.
 template <typename T>
 inline typename std::enable_if<
-    base::internal::SupportsOstreamOperator<const T&>::value,
+    base::internal::SupportsOstreamOperator<const T&>::value &&
+        !std::is_function<typename std::remove_pointer<T>::type>::value,
     void>::type
 MakeCheckOpValueString(std::ostream* os, const T& v) {
   (*os) << v;
 }
 
+// Provide an overload for functions and function pointers, which are otherwise
+// implicitly converted to bool (MSVC seems to be the exception) and produce

[Nico, 2016/11/23 18:09:26]

This comment is a bit confusing as written. I'd reword it as:

// Provide an overload for functions and function pointers. Function pointers
don't implicitly
// convert to void* but do implicitly convert to bool, so without this function
pointers are always
// printed as 1 or 0. (MSVC isn't standards-conforming here and converts
function pointers to
// regular pointers, so this is a no-op for MSVC.)

+// unhelpful values.
+template <typename T>
+inline typename std::enable_if<
+    std::is_function<typename std::remove_pointer<T>::type>::value,
+    void>::type
+MakeCheckOpValueString(std::ostream* os, const T& v) {
+  (*os) << 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 typename std::enable_if<
     !base::internal::SupportsOstreamOperator<const T&>::value &&
         std::is_enum<T>::value,
     void>::type
 MakeCheckOpValueString(std::ostream* os, const T& v) {
   (*os) << static_cast<typename base::underlying_type<T>::type>(v);
 }
@@ skipping 442 matching lines @@
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static bool logged_once = false;\
   LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
   logged_once = true;\
 } while(0);\
 EAT_STREAM_PARAMETERS
 #endif
 
 #endif  // BASE_LOGGING_H_