Add helpers for logging mojom objects.

mojo/common/logging.h

Index: mojo/common/logging.h
diff --git a/mojo/common/logging.h b/mojo/common/logging.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cb69c6fba1a96ac03574548cd19b4a948f5404e
--- /dev/null
+++ b/mojo/common/logging.h
@@ -0,0 +1,81 @@
+// Copyright 2015 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 MOJO_COMMON_LOGGING_H_
+#define MOJO_COMMON_LOGGING_H_
+
+#include <ostream>

[vardhan, 2015/12/11 00:12:20]

nit: blank line after this include

+#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "mojo/public/cpp/bindings/map.h"
+
+// Mojom Logging helpers.

[vardhan, 2015/12/11 00:12:20]

Probably "mojom debug string" is more clarifying; "logging" is a little
ambiguous?

+
+namespace mojo {
+
+// Support output formatting of Mojo structs by value or by reference
+// assuming there exists an operator<< overload that accepts a const reference.
+template <typename T, typename = typename T::Data_>

[vardhan, 2015/12/11 00:12:20]

Hm, I was hoping you could use IsStructPtr<> in bindings_internal.h, but
realized its in the mojo::internal namespace, so nevermind :(

+auto operator<<(std::ostream& os, const T* value) -> decltype(os << *value) {

[vardhan, 2015/12/11 00:12:20]

What do you think about defining:

template <MojomWrapperType, typename enable = void>
void ToDebugString(MojomWrapperType val, std::ostream& output);

and specializing this for any type you want to be able to generate debug
strings?

i think overloading operator<<() is a little confusing because you could
conceptually define multiple semantics when "writing" mojom types, like write a
debug string /or/ write the serialized byte format (e.g., protobuf has APIs for
serializing to an ostream). so it might be better to be a bit more explicit with
this kind of API?

+  return value ? os << *value : os << "null";
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const mojo::StructPtr<T>& value) {
+  return os << value.get();
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os,
+                         const mojo::InlinedStructPtr<T>& value) {
+  return os << value.get();
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const mojo::InterfacePtr<T>& iface) {
+  return os << "{impl=" << iface.get() << ", bound=" << iface.is_bound() << "}";
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const mojo::Array<T>& array) {
+  if (array) {
+    os << "[";
+    bool first = true;
+    for (auto it = array.storage().cbegin(); it != array.storage().cend();
+         ++it) {
+      if (first)
+        first = false;
+      else
+        os << ", ";
+      os << *it;
+    }
+    os << "]";
+  } else {
+    os << "null";
+  }
+  return os;
+}
+
+template <typename Key, typename Value>
+std::ostream& operator<<(std::ostream& os, const mojo::Map<Key, Value>& map) {
+  if (map) {
+    os << "[";
+    bool first = true;
+    for (auto it = map.cbegin(); it != map.cend(); ++it) {
+      if (first)
+        first = false;
+      else
+        os << ", ";
+      os << "{" << it.GetKey() << ": " << it.GetValue() << "}";
+    }
+    os << "]";
+  } else {
+    os << "null";
+  }
+  return os;
+}
+
+}  // namespace mojo
+
+#endif  // MOJO_COMMON_LOGGING_H_