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 <utility>
 
+#ifdef UNIT_TEST

[kwiberg-webrtc, 2017/02/18 18:50:47]

Who defines this? I couldn't find it in our tree.

[kjellander_webrtc, 2017/02/19 09:29:19]

It comes from gtest:
https://cs.chromium.org/chromium/src/build/secondary/testing/gtest/BUILD.gn?r...
so it should be defined for all that depend on //testing:gtest since it's a
public config.

I also noticed Chromium has this check:
https://cs.chromium.org/chromium/src/PRESUBMIT.py?rcl=22f522e10dd7a816ec45547...
maybe we should add that too?

[kwiberg-webrtc, 2017/02/19 13:14:15]

Aha. Excellent!
Yes---I guess the problem is that .cc files are compiled with their own configs,
which won't in general have UNIT_TEST defined? So ideally, this check should
cover every preprocessor symbol set through a public_config.

[kjellander_webrtc, 2017/02/20 07:24:20]

I don't have time to put in more work than this for now, so I'm just copying
Chromium's check in https://codereview.webrtc.org/2703173002/

+#include <iomanip>
+#include <ostream>
+#endif  // UNIT_TEST
+
 #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/18 18:50:47]

The outermost const_cast is unnecessary.

[ossu, 2017/02/20 11:02:24]

That is true. But also, I think the whole function might be. I'll remove it if
it is.

[kwiberg-webrtc, 2017/02/20 11:45:31]

Acknowledged.

+}
+
 #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_;
   };
 };
 
+#ifdef UNIT_TEST
+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;
+}
+
+inline void OptionalPrintObjectBytes(const unsigned char* bytes,
+                                     size_t size,
+                                     std::ostream* os) {
+  *os << "<optional with " << size << "-byte object [";
+  for (size_t i = 0; i != size; ++i) {
+    *os << (i == 0 ? "" : ((i & 1) ? "-" : " "));
+    *os << std::hex << std::setw(2) << std::setfill('0')
+        << static_cast<int>(bytes[i]);
+  }
+  *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>";
+  }
+}
+
+#endif  // UNIT_TEST
+
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_OPTIONAL_H_