Adding RTCErrorOr class to be used by ORTC APIs.

webrtc/api/rtcerror.cc

+/*
+ *  Copyright 2017 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.
+ */
+
+#include "webrtc/api/rtcerror.h"
+
+#include "webrtc/base/arraysize.h"
+
+namespace {
+
+static const char* const kRTCErrorTypeNames[] = {
+    "NONE",
+    "UNSUPPORTED_OPERATION",
+    "UNSUPPORTED_PARAMETER",
+    "INVALID_PARAMETER",
+    "INVALID_RANGE",
+    "SYNTAX_ERROR",
+    "INVALID_STATE",
+    "INVALID_MODIFICATION",
+    "NETWORK_ERROR",
+    "RESOURCE_EXHAUSTED",
+    "INTERNAL_ERROR",
+};
+static_assert(static_cast<int>(webrtc::RTCErrorType::INTERNAL_ERROR) ==
+                  (arraysize(kRTCErrorTypeNames) - 1),
+              "kRTCErrorTypeNames must have as many strings as RTCErrorType "
+              "has values.");
+
+}  // namespace
+
+namespace webrtc {
+
+// static
+const RTCError& RTCError::OK() {
+  static RTCError ok;

[tommi, 2017/02/12 12:11:21]

have you checked if this is thread safe? I don't think it is on Windows at
least.
I think there is some singleton code elsewhere that you could take a look at. 
Alterternatively, if it is guaranteed that this method is always called on the
same thread or if it is always called once on a known thread before any other
thread can call it, it can be considered thread safe and it would be good to
document that here.

[Taylor Brandstetter, 2017/02/12 16:19:23]

It's thread-safe according to the standard, though Microsoft didn't implement
this until VS2015. Does webrtc have a minimum version of VS it targets? chromium
builds with VS2015.

[tommi, 2017/02/12 18:19:32]

Looks like the change in chromium was made a couple of weeks ago:
https://www.chromium.org/developers/coding-style/cpp-dos-and-donts#TOC-Static...

We're following that so this should be fine.  Since it's such a recent change
though, I would like to confirm with kjellander@ before landing.

[the sun, 2017/02/13 07:35:03]

I'd rather avoid singletons as much as possible. It doesn't scale well; i.e. bad
for backend scenario.

[Taylor Brandstetter, 2017/02/13 18:03:53]

I'm curious what the downside here is. But would you prefer it returning a newly
constructed RTCError?

[the sun, 2017/02/13 19:28:52]

Sorry, I misread the code in the morning haze. Looks fine, but shouldn't it be
"static const"?

[Taylor Brandstetter, 2017/02/13 22:24:15]

Done. By the way, when I did this, I got a compile warning that was only fixed
by changing the constructor from "RTCError() = default" to "RTCError() {}".
Would you happen to know why? Aren't these doing the same thing?

[kwiberg-webrtc, 2017/02/14 09:51:49]

Interesting. What did the message say?

This page (http://en.cppreference.com/w/cpp/language/default_constructor) has a
section "Deleted implicitly-declared default constructor" on circumstances under
which the implicitly-declared default constructor is deleted. I can't see that
any of them would apply here, though.

[Taylor Brandstetter, 2017/02/15 02:22:23]

"default initialization of an object of const type 'const webrtc::RTCError'
without a user-provided default constructor". It seems it's the union it's
unhappy with. Maybe the union default constructor doesn't work how I thought it
would, or the compiler has a bug. I changed the union anyway though.

+  return ok;
+}
+
+std::ostream& operator<<(std::ostream& stream, RTCErrorType error) {
+  int index = static_cast<int>(error);
+  return stream << kRTCErrorTypeNames[index];
+}
+
+webrtc::RTCError CreateAndLogError(webrtc::RTCErrorType type,
+                                   const std::string& message,
+                                   rtc::LoggingSeverity severity) {
+  // "No error" shouldn't be logged as an error.
+  RTC_DCHECK(type != RTCErrorType::NONE);
+  rtc::LogMessage(__FILE__, __LINE__, severity).stream() << message << " ("
+                                                         << type << ")";
+  return webrtc::RTCError(type, message);
+}
+
+webrtc::RTCError CreateAndLogError(webrtc::RTCErrorType type,
+                                   const std::string& message) {
+  return CreateAndLogError(type, message, rtc::LS_ERROR);
+}
+
+}  // namespace webrtc