zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Injectable logging"

Browse Source 
This reverts commit 59216ec4a4151b1ba5478c8f2b5c9f01f4683d7f.

Reason for revert:  forces all logs to have identical tag

Original change's description:
> Injectable logging
> 
> Allows passing a Loggable to PCFactory.initializationOptions, which
> is then injected to Logging.java and logging.h. Future log messages
> in both Java and native will then be passed to this Loggable.
> 
> Bug: webrtc:9225
> Change-Id: I2ff693380639448301a78a93dc11d3a0106f0967
> Reviewed-on: https://webrtc-review.googlesource.com/73243
> Commit-Queue: Paulina Hensman <phensman@webrtc.org>
> Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
> Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#23241}

TBR=magjed@webrtc.org,sakal@webrtc.org,kwiberg@webrtc.org,phensman@webrtc.org

Change-Id: I27c9587238325b69b26166434740869021b7db8a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:9225
Reviewed-on: https://webrtc-review.googlesource.com/76885
Reviewed-by: Alex Glaznev <glaznev@webrtc.org>
Commit-Queue: Alex Glaznev <glaznev@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23253}
This commit is contained in:
Alex Glaznev
2018-05-15 22:30:06 +00:00
committed by Commit Bot
parent d7624f2d90
commit 4f81038a52
16 changed files with 70 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
rtc_base/BUILD.gn
View File

@ -1342,10 +1342,7 @@ if (is_android) {
rtc_android_library("base_java") {
java_files = [
"java/src/org/webrtc/ContextUtils.java",
"java/src/org/webrtc/FallbackLogger.java",
"java/src/org/webrtc/Loggable.java",
"java/src/org/webrtc/Logging.java",
"java/src/org/webrtc/NativeLogger.java",
"java/src/org/webrtc/Size.java",
"java/src/org/webrtc/ThreadUtils.java",
]

45
rtc_base/java/src/org/webrtc/FallbackLogger.java
View File

@ -1,45 +0,0 @@
/*
* Copyright 2018 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.
*/
package org.webrtc;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.webrtc.Loggable;
import org.webrtc.Logging.Severity;
class FallbackLogger implements Loggable {
final Logger fallbackLogger;
public FallbackLogger() {
fallbackLogger = Logger.getLogger("org.webrtc.FallbackLogger");
fallbackLogger.setLevel(Level.ALL);
}
@Override
public void onLogMessage(String message, Severity severity, String tag) {
Level level;
switch (severity) {
case LS_ERROR:
level = Level.SEVERE;
break;
case LS_WARNING:
level = Level.WARNING;
break;
case LS_INFO:
level = Level.INFO;
break;
default:
level = Level.FINE;
break;
}
fallbackLogger.log(level, tag + ": " + message);
}
}

22
rtc_base/java/src/org/webrtc/Loggable.java
View File

@ -1,22 +0,0 @@
/*
* Copyright (c) 2018 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.
*/
package org.webrtc;
import org.webrtc.Logging.Severity;
/**
* Java interface for WebRTC logging. The default implementation uses webrtc.Logging.
*
* When injected, the Loggable will receive logging from both Java and native.
*/
public interface Loggable {
public void onLogMessage(String message, Severity severity, String tag);
}

64
rtc_base/java/src/org/webrtc/Logging.java
View File

@ -13,31 +13,28 @@ package org.webrtc;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.EnumSet;
import org.webrtc.Loggable;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Java wrapper for WebRTC logging. Logging defaults to java.util.logging.Logger, but a custom
* logger implementing the Loggable interface can be injected along with a Severity. All subsequent
* log messages will then be redirected to the injected Loggable, except those with a severity lower
* than the specified severity, which will be discarded.
* Java wrapper for WebRTC logging. Logging defaults to java.util.logging.Logger, but will switch to
* native logging (rtc::LogMessage) if one of the following static functions are called from the
* app:
* - Logging.enableLogThreads
* - Logging.enableLogTimeStamps
* - Logging.enableLogToDebugOutput
*
* Injecting a Loggable or using any of the enable... methods requires that the native library is
* loaded, using PeerConnectionFactory.initialize.
* Using these APIs requires that the native library is loaded, using
* PeerConnectionFactory.initialize.
*/
public class Logging {
private static Loggable loggable = new FallbackLogger();
private static Severity loggableSeverity = Severity.LS_SENSITIVE;
private static final Logger fallbackLogger = createFallbackLogger();
private static volatile boolean loggingEnabled;
static void injectLoggable(Loggable injectedLoggable, Severity severity) {
if (injectedLoggable != null) {
loggable = injectedLoggable;
loggableSeverity = severity;
}
}
static void deleteInjectedLoggable() {
loggable = new FallbackLogger();
loggableSeverity = Severity.LS_SENSITIVE;
private static Logger createFallbackLogger() {
final Logger fallbackLogger = Logger.getLogger("org.webrtc.Logging");
fallbackLogger.setLevel(Level.ALL);
return fallbackLogger;
}
// TODO(solenberg): Remove once dependent projects updated.
@ -86,16 +83,33 @@ public class Logging {
// TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression.
@SuppressWarnings("NoSynchronizedMethodCheck")
public static synchronized void enableLogToDebugOutput(Severity severity) {
loggable = new NativeLogger(severity);
loggableSeverity = severity;
nativeEnableLogToDebugOutput(severity.ordinal());
loggingEnabled = true;
}
public static void log(Severity severity, String tag, String message) {
// Filter log messages below loggableSeverity.
if (severity.ordinal() < loggableSeverity.ordinal()) {
if (loggingEnabled) {
nativeLog(severity.ordinal(), tag, message);
return;
}
loggable.onLogMessage(message, severity, tag);
// Fallback to system log.
Level level;
switch (severity) {
case LS_ERROR:
level = Level.SEVERE;
break;
case LS_WARNING:
level = Level.WARNING;
break;
case LS_INFO:
level = Level.INFO;
break;
default:
level = Level.FINE;
break;
}
fallbackLogger.log(level, tag + ": " + message);
}
public static void d(String tag, String message) {
@ -137,6 +151,8 @@ public class Logging {
return sw.toString();
}
private static native void nativeEnableLogToDebugOutput(int nativeSeverity);
private static native void nativeEnableLogThreads();
private static native void nativeEnableLogTimeStamps();
private static native void nativeLog(int severity, String tag, String message);
}

28
rtc_base/java/src/org/webrtc/NativeLogger.java
View File

@ -1,28 +0,0 @@
/*
* Copyright 2018 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.
*/
package org.webrtc;
import org.webrtc.Loggable;
import org.webrtc.Logging.Severity;
class NativeLogger implements Loggable {
public NativeLogger(Severity severity) {
nativeEnableLogToDebugOutput(severity.ordinal());
}
@Override
public void onLogMessage(String message, Severity severity, String tag) {
nativeLog(severity.ordinal(), tag, message);
}
private static native void nativeEnableLogToDebugOutput(int nativeSeverity);
private static native void nativeLog(int severity, String tag, String message);
}

18
rtc_base/logging.cc
View File

@ -80,11 +80,6 @@ std::ostream& GetNoopStream() {
CriticalSection g_log_crit;
} // namespace
void LogSink::OnLogMessage(const std::string& msg,
LoggingSeverity severity,
const char* tag) {
OnLogMessage(msg);
}
/////////////////////////////////////////////////////////////////////////////
// LogMessage
@ -131,14 +126,8 @@ LogMessage::LogMessage(const char* file,
print_stream_ << "[" << std::dec << id << "] ";
}
if (file != nullptr) {
#if defined(WEBRTC_ANDROID)
tag_ = FilenameFromPath(file);
print_stream_ << "(line " << line << "): ";
#else
if (file != nullptr)
print_stream_ << "(" << FilenameFromPath(file) << ":" << line << "): ";
#endif
}
if (err_ctx != ERRCTX_NONE) {
char tmp_buf[1024];
@ -191,6 +180,7 @@ LogMessage::LogMessage(const char* file,
0 /* err */) {
if (!is_noop_) {
tag_ = tag;
print_stream_ << tag << ": ";
}
}
#endif
@ -228,11 +218,7 @@ LogMessage::~LogMessage() {
CritScope cs(&g_log_crit);
for (auto& kv : streams_) {
if (severity_ >= kv.second) {
#if defined(WEBRTC_ANDROID)
kv.first->OnLogMessage(str, severity_, tag_);
#else
kv.first->OnLogMessage(str);
#endif
}
}
}

5
rtc_base/logging.h
View File

@ -117,9 +117,6 @@ class LogSink {
public:
LogSink() {}
virtual ~LogSink() {}
virtual void OnLogMessage(const std::string& msg,
LoggingSeverity severity,
const char* tag);
virtual void OnLogMessage(const std::string& message) = 0;
};
@ -246,7 +243,7 @@ class LogMessage {
LoggingSeverity severity_;
#if defined(WEBRTC_ANDROID)
// The default Android debug output tag.
// The Android debug output tag.
const char* tag_ = "libjingle";
#endif

9
rtc_base/logging_unittest.cc
View File

@ -47,9 +47,6 @@ class LogMessageForTesting : public LogMessage {
const std::string& get_extra() const { return extra_; }
bool is_noop() const { return is_noop_; }
#if defined(WEBRTC_ANDROID)
const char* get_tag() const { return tag_; }
#endif
// Returns the contents of the internal log stream.
// Note that parts of the stream won't (as is) be available until *after* the
@ -189,13 +186,7 @@ TEST(LogTest, CheckFilePathParsed) {
log_msg.stream() << "<- Does this look right?";
const std::string stream = log_msg.GetPrintStream();
#if defined(WEBRTC_ANDROID)
const char* tag = log_msg.get_tag();
EXPECT_NE(nullptr, strstr(tag, "myfile.cc"));
EXPECT_NE(std::string::npos, stream.find("100"));
#else
EXPECT_NE(std::string::npos, stream.find("(myfile.cc:100)"));
#endif
}
TEST(LogTest, CheckNoopLogEntry) {

38
sdk/android/BUILD.gn
View File

@ -89,9 +89,7 @@ rtc_source_set("base_jni") {
"src/jni/jni_helpers.cc",
"src/jni/jni_helpers.h",
"src/jni/pc/audio.h",
"src/jni/pc/logging.cc",
"src/jni/pc/media.h",
"src/jni/pc/native_logger.cc",
"src/jni/pc/video.h",
]
@ -510,38 +508,6 @@ generate_jni("generated_peerconnection_jni") {
jni_generator_include = "//sdk/android/src/jni/jni_generator_helper.h"
}
rtc_android_library("logging_java") {
java_files = [ "src/java/org/webrtc/JNILogging.java" ]
deps = [
":base_java",
"//rtc_base:base_java",
]
}
generate_jni("generated_logging_jni") {
sources = [
"src/java/org/webrtc/JNILogging.java",
]
jni_package = ""
jni_generator_include = "//sdk/android/src/jni/jni_generator_helper.h"
}
rtc_static_library("logging_jni") {
visibility = [ "*" ]
sources = [
"src/jni/logging/logsink.cc",
"src/jni/logging/logsink.h",
]
deps = [
":base_jni",
":generated_logging_jni",
":native_api_jni",
"../../rtc_base:rtc_base",
]
}
rtc_static_library("peerconnection_jni") {
# Do not depend on this target externally unless you absolute have to. It is
# made public because we don't have a proper NDK yet. Header APIs here are not
@ -558,6 +524,7 @@ rtc_static_library("peerconnection_jni") {
"src/jni/pc/dtmfsender.cc",
"src/jni/pc/icecandidate.cc",
"src/jni/pc/icecandidate.h",
"src/jni/pc/logging.cc",
"src/jni/pc/mediaconstraints.cc",
"src/jni/pc/mediaconstraints.h",
"src/jni/pc/mediasource.cc",
@ -615,7 +582,6 @@ rtc_static_library("peerconnection_jni") {
":base_jni",
":generated_external_classes_jni",
":generated_peerconnection_jni",
":logging_jni",
":native_api_jni",
"../..:webrtc_common",
"../../api:libjingle_peerconnection_api",
@ -741,7 +707,6 @@ dist_jar("libwebrtc") {
":java_audio_device_module_java",
":libjingle_peerconnection_java",
":libjingle_peerconnection_metrics_default_java",
":logging_java",
":peerconnection_java",
":screencapturer_java",
":surfaceviewrenderer_java",
@ -1036,7 +1001,6 @@ rtc_android_library("peerconnection_java") {
deps = [
":audio_api_java",
":base_java",
":logging_java",
":video_api_java",
":video_java", # TODO(sakal): Remove dependency.
"//modules/audio_device:audio_device_java",

28
sdk/android/api/org/webrtc/PeerConnectionFactory.java
View File

@ -13,7 +13,6 @@ package org.webrtc;
import android.content.Context;
import java.util.List;
import javax.annotation.Nullable;
import org.webrtc.Logging.Severity;
import org.webrtc.audio.AudioDeviceModule;
import org.webrtc.audio.LegacyAudioDeviceModule;
@ -43,20 +42,15 @@ public class PeerConnectionFactory {
final boolean enableInternalTracer;
final boolean enableVideoHwAcceleration;
final NativeLibraryLoader nativeLibraryLoader;
@Nullable Loggable loggable;
@Nullable Severity loggableSeverity;
private InitializationOptions(Context applicationContext, String fieldTrials,
boolean enableInternalTracer, boolean enableVideoHwAcceleration,
NativeLibraryLoader nativeLibraryLoader, @Nullable Loggable loggable,
@Nullable Severity loggableSeverity) {
NativeLibraryLoader nativeLibraryLoader) {
this.applicationContext = applicationContext;
this.fieldTrials = fieldTrials;
this.enableInternalTracer = enableInternalTracer;
this.enableVideoHwAcceleration = enableVideoHwAcceleration;
this.nativeLibraryLoader = nativeLibraryLoader;
this.loggable = loggable;
this.loggableSeverity = loggableSeverity;
}
public static Builder builder(Context applicationContext) {
@ -69,8 +63,6 @@ public class PeerConnectionFactory {
private boolean enableInternalTracer = false;
private boolean enableVideoHwAcceleration = true;
private NativeLibraryLoader nativeLibraryLoader = new NativeLibrary.DefaultLoader();
@Nullable private Loggable loggable = null;
@Nullable private Severity loggableSeverity = null;
Builder(Context applicationContext) {
this.applicationContext = applicationContext;
@ -96,16 +88,9 @@ public class PeerConnectionFactory {
return this;
}
public Builder setInjectableLogger(Loggable loggable, Severity severity) {
this.loggable = loggable;
this.loggableSeverity = severity;
return this;
}
public PeerConnectionFactory.InitializationOptions createInitializationOptions() {
return new PeerConnectionFactory.InitializationOptions(applicationContext, fieldTrials,
enableInternalTracer, enableVideoHwAcceleration, nativeLibraryLoader, loggable,
loggableSeverity);
enableInternalTracer, enableVideoHwAcceleration, nativeLibraryLoader);
}
}
}
@ -215,13 +200,6 @@ public class PeerConnectionFactory {
if (options.enableInternalTracer && !internalTracerInitialized) {
initializeInternalTracer();
}
if (options.loggable != null) {
Logging.injectLoggable(options.loggable, options.loggableSeverity);
nativeInjectLoggable(new JNILogging(options.loggable), options.loggableSeverity.ordinal());
} else {
Logging.deleteInjectedLoggable();
nativeDeleteLoggable();
}
}
private void checkInitializeHasBeenCalled() {
@ -497,6 +475,4 @@ public class PeerConnectionFactory {
private static native void nativeInvokeThreadsCallbacks(long factory);
private static native void nativeFreeFactory(long factory);
private static native long nativeGetNativePeerConnectionFactory(long factory);
private static native void nativeInjectLoggable(JNILogging jniLogging, int severity);
private static native void nativeDeleteLoggable();
}

28
sdk/android/src/java/org/webrtc/JNILogging.java
View File

@ -1,28 +0,0 @@
/*
* Copyright 2018 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.
*/
package org.webrtc;
import org.webrtc.CalledByNative;
import org.webrtc.Loggable;
import org.webrtc.Logging.Severity;
class JNILogging {
private final Loggable loggable;
public JNILogging(Loggable loggable) {
this.loggable = loggable;
}
@CalledByNative
public void logToInjectable(String message, Integer severity, String tag) {
loggable.onLogMessage(message, Severity.values()[severity], tag);
}
}

35
sdk/android/src/jni/logging/logsink.cc
View File

@ -1,35 +0,0 @@
/*
* Copyright 2018 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 "sdk/android/src/jni/logging/logsink.h"
#include "sdk/android/generated_logging_jni/jni/JNILogging_jni.h"
namespace webrtc {
namespace jni {
JNILogSink::JNILogSink(JNIEnv* env, const JavaRef<jobject>& j_logging)
: j_logging_(env, j_logging) {}
JNILogSink::~JNILogSink() = default;
void JNILogSink::OnLogMessage(const std::string& msg,
rtc::LoggingSeverity severity,
const char* tag) {
JNIEnv* env = AttachCurrentThreadIfNeeded();
Java_JNILogging_logToInjectable(env, j_logging_, NativeToJavaString(env, msg),
NativeToJavaInteger(env, severity),
NativeToJavaString(env, tag));
}
void JNILogSink::OnLogMessage(const std::string& msg) {
RTC_NOTREACHED();
}
} // namespace jni
} // namespace webrtc

39
sdk/android/src/jni/logging/logsink.h
View File

@ -1,39 +0,0 @@
/*
* Copyright 2018 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 SDK_ANDROID_SRC_JNI_LOGGING_LOGSINK_H_
#define SDK_ANDROID_SRC_JNI_LOGGING_LOGSINK_H_
#include <string>
#include "rtc_base/logging.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
class JNILogSink : public rtc::LogSink {
public:
JNILogSink(JNIEnv* env, const JavaRef<jobject>& j_logging);
~JNILogSink() override;
void OnLogMessage(const std::string& msg,
rtc::LoggingSeverity severity,
const char* tag) override;
void OnLogMessage(const std::string& msg) override;
private:
const ScopedJavaGlobalRef<jobject> j_logging_;
};
} // namespace jni
} // namespace webrtc
#endif // SDK_ANDROID_SRC_JNI_LOGGING_LOGSINK_H_

24
sdk/android/src/jni/pc/logging.cc
View File

@ -17,6 +17,17 @@
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void,
Logging_nativeEnableLogToDebugOutput,
JNIEnv* jni,
jclass,
jint nativeSeverity) {
if (nativeSeverity >= rtc::LS_SENSITIVE && nativeSeverity <= rtc::LS_NONE) {
rtc::LogMessage::LogToDebug(
static_cast<rtc::LoggingSeverity>(nativeSeverity));
}
}
JNI_FUNCTION_DECLARATION(void,
Logging_nativeEnableLogThreads,
JNIEnv* jni,
@ -31,5 +42,18 @@ JNI_FUNCTION_DECLARATION(void,
rtc::LogMessage::LogTimestamps(true);
}
JNI_FUNCTION_DECLARATION(void,
Logging_nativeLog,
JNIEnv* jni,
jclass,
jint j_severity,
jstring j_tag,
jstring j_message) {
std::string message = JavaToStdString(jni, JavaParamRef<jstring>(j_message));
std::string tag = JavaToStdString(jni, JavaParamRef<jstring>(j_tag));
RTC_LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag.c_str())
<< message;
}
} // namespace jni
} // namespace webrtc

46
sdk/android/src/jni/pc/native_logger.cc
View File

@ -1,46 +0,0 @@
/*
* 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 <memory>
#include "rtc_base/logging.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
namespace webrtc {
namespace jni {
JNI_FUNCTION_DECLARATION(void,
NativeLogger_nativeEnableLogToDebugOutput,
JNIEnv* jni,
jclass,
jint native_severity) {
// Check that native_severity is a valid enum.
if (native_severity >= rtc::LS_SENSITIVE && native_severity <= rtc::LS_NONE) {
rtc::LogMessage::LogToDebug(
static_cast<rtc::LoggingSeverity>(native_severity));
}
}
JNI_FUNCTION_DECLARATION(void,
NativeLogger_nativeLog,
JNIEnv* jni,
jclass,
jint j_severity,
jstring j_tag,
jstring j_message) {
std::string message = JavaToStdString(jni, JavaParamRef<jstring>(j_message));
std::string tag = JavaToStdString(jni, JavaParamRef<jstring>(j_tag));
RTC_LOG_TAG(static_cast<rtc::LoggingSeverity>(j_severity), tag.c_str())
<< message;
}
} // namespace jni
} // namespace webrtc

28
sdk/android/src/jni/pc/peerconnectionfactory.cc
View File

@ -27,7 +27,6 @@
#include "sdk/android/generated_peerconnection_jni/jni/PeerConnectionFactory_jni.h"
#include "sdk/android/native_api/jni/java_types.h"
#include "sdk/android/src/jni/jni_helpers.h"
#include "sdk/android/src/jni/logging/logsink.h"
#include "sdk/android/src/jni/pc/androidnetworkmonitor.h"
#include "sdk/android/src/jni/pc/audio.h"
#include "sdk/android/src/jni/pc/icecandidate.h"
@ -82,9 +81,6 @@ static char* field_trials_init_string = nullptr;
static bool factory_static_initialized = false;
static bool video_hw_acceleration_enabled = true;
// Set in PeerConnectionFactory_InjectLoggable().
static std::unique_ptr<JNILogSink> jni_log_sink;
void PeerConnectionFactoryNetworkThreadReady() {
RTC_LOG(LS_INFO) << "Network thread JavaCallback";
JNIEnv* env = AttachCurrentThreadIfNeeded();
@ -507,29 +503,5 @@ static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory(
return jlongFromPointer(factoryFromJava(native_factory));
}
static void JNI_PeerConnectionFactory_InjectLoggable(
JNIEnv* jni,
const JavaParamRef<jclass>&,
const JavaParamRef<jobject>& j_logging,
jint nativeSeverity) {
// If there is already a LogSink, remove it from LogMessage.
if (jni_log_sink) {
rtc::LogMessage::RemoveLogToStream(jni_log_sink.get());
}
jni_log_sink = rtc::MakeUnique<JNILogSink>(jni, j_logging);
rtc::LogMessage::AddLogToStream(
jni_log_sink.get(), static_cast<rtc::LoggingSeverity>(nativeSeverity));
rtc::LogMessage::LogToDebug(rtc::LS_NONE);
}
static void JNI_PeerConnectionFactory_DeleteLoggable(
JNIEnv* jni,
const JavaParamRef<jclass>&) {
if (jni_log_sink) {
rtc::LogMessage::RemoveLogToStream(jni_log_sink.get());
jni_log_sink.reset();
}
}
} // namespace jni
} // namespace webrtc