Add severity into RTC logging callbacks

Bug: webrtc:9945
Change-Id: I5022f63103503d2213492d3cd1a6953fe658fda7
Reviewed-on: https://webrtc-review.googlesource.com/c/108981
Commit-Queue: Jiawei Ou <ouj@fb.com>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25510}
diff --git a/sdk/objc/api/logging/RTCCallbackLogger.h b/sdk/objc/api/logging/RTCCallbackLogger.h
index 4867b31..2bce03f 100644
--- a/sdk/objc/api/logging/RTCCallbackLogger.h
+++ b/sdk/objc/api/logging/RTCCallbackLogger.h
@@ -15,6 +15,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+typedef void (^RTCCallbackLoggerMessageHandler)(NSString *message);
+typedef void (^RTCCallbackLoggerMessageAndSeverityHandler)(NSString *message,
+                                                           RTCLoggingSeverity severity);
+
 // This class intercepts WebRTC logs and forwards them to a registered block.
 // This class is not threadsafe.
 RTC_OBJC_EXPORT
@@ -23,10 +27,12 @@
 // The severity level to capture. The default is kRTCLoggingSeverityInfo.
 @property(nonatomic, assign) RTCLoggingSeverity severity;
 
-// The callback will be called on the same thread that does the logging, so
-// if the logging callback can be slow it may be a good idea to implement
-// dispatching to some other queue.
-- (void)start:(nullable void (^)(NSString*))callback;
+// The callback handler will be called on the same thread that does the
+// logging, so if the logging callback can be slow it may be a good idea
+// to implement dispatching to some other queue.
+- (void)start:(nullable RTCCallbackLoggerMessageHandler)handler;
+- (void)startWithMessageAndSeverityHandler:
+        (nullable RTCCallbackLoggerMessageAndSeverityHandler)handler;
 
 - (void)stop;
 
diff --git a/sdk/objc/api/logging/RTCCallbackLogger.mm b/sdk/objc/api/logging/RTCCallbackLogger.mm
index da60c2b..9bbb530 100644
--- a/sdk/objc/api/logging/RTCCallbackLogger.mm
+++ b/sdk/objc/api/logging/RTCCallbackLogger.mm
@@ -18,11 +18,8 @@
 
 class CallbackLogSink : public rtc::LogSink {
  public:
-  CallbackLogSink(void (^callbackHandler)(NSString *message)) {
-    callback_handler_ = callbackHandler;
-  }
-
-  ~CallbackLogSink() override { callback_handler_ = nil; }
+  CallbackLogSink(RTCCallbackLoggerMessageHandler callbackHandler)
+      : callback_handler_(callbackHandler) {}
 
   void OnLogMessage(const std::string &message) override {
     if (callback_handler_) {
@@ -31,12 +28,47 @@
   }
 
  private:
-  void (^callback_handler_)(NSString *message);
+  RTCCallbackLoggerMessageHandler callback_handler_;
+};
+
+class CallbackWithSeverityLogSink : public rtc::LogSink {
+ public:
+  CallbackWithSeverityLogSink(RTCCallbackLoggerMessageAndSeverityHandler callbackHandler)
+      : callback_handler_(callbackHandler) {}
+
+  void OnLogMessage(const std::string& message) override { RTC_NOTREACHED(); }
+
+  void OnLogMessage(const std::string& message, rtc::LoggingSeverity severity) override {
+    if (callback_handler_) {
+      RTCLoggingSeverity loggingSeverity = NativeSeverityToObjcSeverity(severity);
+      callback_handler_([NSString stringWithUTF8String:message.c_str()], loggingSeverity);
+    }
+  }
+
+ private:
+  static RTCLoggingSeverity NativeSeverityToObjcSeverity(rtc::LoggingSeverity severity) {
+    switch (severity) {
+      case rtc::LS_SENSITIVE:
+        return RTCLoggingSeveritySensitive;
+      case rtc::LS_VERBOSE:
+        return RTCLoggingSeverityVerbose;
+      case rtc::LS_INFO:
+        return RTCLoggingSeverityInfo;
+      case rtc::LS_WARNING:
+        return RTCLoggingSeverityWarning;
+      case rtc::LS_ERROR:
+        return RTCLoggingSeverityError;
+      case rtc::LS_NONE:
+        return RTCLoggingSeverityNone;
+    }
+  }
+
+  RTCCallbackLoggerMessageAndSeverityHandler callback_handler_;
 };
 
 @implementation RTCCallbackLogger {
   BOOL _hasStarted;
-  std::unique_ptr<CallbackLogSink> _logSink;
+  std::unique_ptr<rtc::LogSink> _logSink;
 }
 
 @synthesize severity = _severity;
@@ -53,12 +85,24 @@
   [self stop];
 }
 
-- (void)start:(nullable void (^)(NSString *))callback {
+- (void)start:(nullable RTCCallbackLoggerMessageHandler)handler {
   if (_hasStarted) {
     return;
   }
 
-  _logSink.reset(new CallbackLogSink(callback));
+  _logSink.reset(new CallbackLogSink(handler));
+
+  rtc::LogMessage::AddLogToStream(_logSink.get(), [self rtcSeverity]);
+  _hasStarted = YES;
+}
+
+- (void)startWithMessageAndSeverityHandler:
+        (nullable RTCCallbackLoggerMessageAndSeverityHandler)handler {
+  if (_hasStarted) {
+    return;
+  }
+
+  _logSink.reset(new CallbackWithSeverityLogSink(handler));
 
   rtc::LogMessage::AddLogToStream(_logSink.get(), [self rtcSeverity]);
   _hasStarted = YES;
@@ -78,6 +122,8 @@
 
 - (rtc::LoggingSeverity)rtcSeverity {
   switch (_severity) {
+    case RTCLoggingSeveritySensitive:
+      return rtc::LS_SENSITIVE;
     case RTCLoggingSeverityVerbose:
       return rtc::LS_VERBOSE;
     case RTCLoggingSeverityInfo: