Add a PrintTo function for rtc::Optional to aid with testing.

webrtc/base/optional.h

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_OPTIONAL_H_
 #define WEBRTC_BASE_OPTIONAL_H_
 
 #include <algorithm>
 #include <memory>
+#include <ostream>
 #include <utility>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/sanitizer.h"
 
 namespace rtc {
 
 namespace optional_internal {
 
 #if RTC_HAS_ASAN
 
-// This is a non-inlined function. The optimizer can't see inside it.
+// This is a non-inlined function. The optimizer can't see inside it.  It
+// prevents the compiler from generating optimized code that reads value_ even
+// if it is unset. Although safe, this causes memory sanitizers to complain.
 void* FunctionThatDoesNothingImpl(void*);
 
 template <typename T>
 inline T* FunctionThatDoesNothing(T* x) {
   return reinterpret_cast<T*>(
       FunctionThatDoesNothingImpl(reinterpret_cast<void*>(x)));
 }
 
+template <typename T>
+inline const T* FunctionThatDoesNothing(const T* x) {
+  return const_cast<const T*>(reinterpret_cast<T*>(
+      FunctionThatDoesNothingImpl(reinterpret_cast<void*>(const_cast<T*>(x)))));
+}

[kwiberg-webrtc, 2017/02/17 13:50:17]

Hmm. Wouldn't it be more general to just have one of these functions,

  template <typename T,
            typename std::enable_if<std::is_pointer<T>::value>::type* = nullptr>
  inline T FunctionThatDoesNothing(T x);

defined only for types T that are pointers?

Regardless, don't you need the const version in the other #if branch as well?

[ossu, 2017/02/17 14:02:19]

Nope, the problem was that the compiler disallowed casting away const with
reinterpret_cast. The other path doesn't do any casting, so it's fine regardless
of type. However, I don't think I need it at all anymore, since I changed
PrintTo to not use it. I'll remove it from here and put it back in if I follow
up with a CL that ensures all references to value_ go through
FunctionThatDoesNothing.

+
 #else
 
 template <typename T>
 inline T* FunctionThatDoesNothing(T* x) { return x; }
 
 #endif
 
 }  // namespace optional_internal
 
 // Simple std::optional-wannabe. It either contains a T or not.
@@ skipping 242 matching lines @@
     char empty_;
     // By placing value_ in a union, we get to manage its construction and
     // destruction manually: the Optional constructors won't automatically
     // construct it, and the Optional destructor won't automatically destroy
     // it. Basically, this just allocates a properly sized and aligned block of
     // memory in which we can manually put a T with placement new.
     T value_;
   };
 };
 
+namespace optional_internal {
+
+// Checks if there's a valid PrintTo(const T&, std::ostream*) call for T.
+template <typename T>
+struct HasPrintTo {
+ private:
+  struct No {};
+
+  template <typename T2>
+  static auto Test(const T2& obj)
+      -> decltype(PrintTo(obj, std::declval<std::ostream*>()));
+
+  template <typename>
+  static No Test(...);
+
+ public:
+  static constexpr bool value =
+      !std::is_same<decltype(Test<T>(std::declval<const T&>())), No>::value;
+};
+
+// Checks if there's a valid operator<<(std::ostream&, const T&) call for T.
+template <typename T>
+struct HasOstreamOperator {
+ private:
+  struct No {};
+
+  template <typename T2>
+  static auto Test(const T2& obj)
+      -> decltype(std::declval<std::ostream&>() << obj);
+
+  template <typename>
+  static No Test(...);
+
+ public:
+  static constexpr bool value =
+      !std::is_same<decltype(Test<T>(std::declval<const T&>())), No>::value;
+};
+
+// Prefer using PrintTo to print the object.
+template <typename T>
+typename std::enable_if<HasPrintTo<T>::value, void>::type OptionalPrintToHelper(
+    const T& value,
+    std::ostream* os) {
+  PrintTo(value, os);
+}
+
+// Fall back to operator<<(std::ostream&, ...) if it exists.
+template <typename T>
+typename std::enable_if<HasOstreamOperator<T>::value && !HasPrintTo<T>::value,
+                        void>::type
+OptionalPrintToHelper(const T& value, std::ostream* os) {
+  *os << value;
+}
+
+void OptionalPrintObjectBytes(const unsigned char* bytes,
+                              size_t size,

[kwiberg-webrtc, 2017/02/17 13:50:17]

ArrayView?

[ossu, 2017/02/17 14:02:20]

Not certain the extra dependency is worth it, honestly. It's just a helper for
OptionalPrintToHelper, not a general interface. If it were, I would.

+                              std::ostream* os);
+
+// As a final back-up, just print the contents of the objcets byte-wise.
+template <typename T>
+typename std::enable_if<!HasOstreamOperator<T>::value && !HasPrintTo<T>::value,
+                        void>::type
+OptionalPrintToHelper(const T& value, std::ostream* os) {
+  OptionalPrintObjectBytes(reinterpret_cast<const unsigned char*>(&value),
+                           sizeof(value), os);
+}
+
+}  // namespace optional_internal
+
+// PrintTo is used by gtest to print out the results of tests. We want to ensure
+// the object contained in an Optional can be printed out if it's set, while
+// avoiding touching the object's storage if it is undefined.
+template <typename T>
+void PrintTo(const rtc::Optional<T>& opt, std::ostream* os) {
+  if (opt) {
+    optional_internal::OptionalPrintToHelper(*opt, os);
+  } else {
+    *os << "<empty optional>";
+  }
+}
+
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_OPTIONAL_H_