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

Moving src/webrtc into src/.

Browse Source 
In order to eliminate the WebRTC Subtree mirror in Chromium, 
WebRTC is moving the content of the src/webrtc directory up
to the src/ directory.

NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
TBR=tommi@webrtc.org

Bug: chromium:611808
Change-Id: Iac59c5b51b950f174119565bac87955a7994bc38
Reviewed-on: https://webrtc-review.googlesource.com/1560
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Henrik Kjellander <kjellander@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#19845}
This commit is contained in:
Mirko Bonadei
2017-09-15 06:15:48 +02:00
committed by Commit Bot
parent 6674846b4a
commit bb547203bf
4576 changed files with 1092 additions and 1196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
rtc_base/java/src/org/webrtc/ContextUtils.java Normal file
View File

@ -0,0 +1,47 @@
/*
* 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.
*/
package org.webrtc;
import android.content.Context;
import org.webrtc.Logging;
/**
* Class for storing the application context and retrieving it in a static context. Similar to
* org.chromium.base.ContextUtils.
*/
public class ContextUtils {
private static final String TAG = "ContextUtils";
private static Context applicationContext;
/**
* Stores the application context that will be returned by getApplicationContext. This is called
* by PeerConnectionFactory.initializeAndroidGlobals.
*/
public static void initialize(Context applicationContext) {
if (ContextUtils.applicationContext != null) {
// TODO(sakal): Re-enable after the migration period.
// throw new RuntimeException("Multiple ContextUtils.initialize calls.");
Logging.e(
TAG, "Calling ContextUtils.initialize multiple times, this will crash in the future!");
}
if (applicationContext == null) {
throw new RuntimeException("Application context cannot be null for ContextUtils.initialize.");
}
ContextUtils.applicationContext = applicationContext;
}
/**
* Returns the stored application context.
*/
public static Context getApplicationContext() {
return applicationContext;
}
}

200
rtc_base/java/src/org/webrtc/Logging.java Normal file
View File

@ -0,0 +1,200 @@
/*
* Copyright (c) 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.
*/
package org.webrtc;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.EnumSet;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* 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.enableTracing
* - Logging.enableLogToDebugOutput
* Using native logging requires the presence of the jingle_peerconnection_so library.
*/
public class Logging {
private static final Logger fallbackLogger = createFallbackLogger();
private static volatile boolean tracingEnabled;
private static volatile boolean loggingEnabled;
private static enum NativeLibStatus { UNINITIALIZED, LOADED, FAILED }
private static volatile NativeLibStatus nativeLibStatus = NativeLibStatus.UNINITIALIZED;
private static Logger createFallbackLogger() {
final Logger fallbackLogger = Logger.getLogger("org.webrtc.Logging");
fallbackLogger.setLevel(Level.ALL);
return fallbackLogger;
}
private static boolean loadNativeLibrary() {
if (nativeLibStatus == NativeLibStatus.UNINITIALIZED) {
try {
System.loadLibrary("jingle_peerconnection_so");
nativeLibStatus = NativeLibStatus.LOADED;
} catch (UnsatisfiedLinkError t) {
nativeLibStatus = NativeLibStatus.FAILED;
fallbackLogger.log(Level.WARNING, "Failed to load jingle_peerconnection_so: ", t);
}
}
return nativeLibStatus == NativeLibStatus.LOADED;
}
// Keep in sync with webrtc/common_types.h:TraceLevel.
public enum TraceLevel {
TRACE_NONE(0x0000),
TRACE_STATEINFO(0x0001),
TRACE_WARNING(0x0002),
TRACE_ERROR(0x0004),
TRACE_CRITICAL(0x0008),
TRACE_APICALL(0x0010),
TRACE_DEFAULT(0x00ff),
TRACE_MODULECALL(0x0020),
TRACE_MEMORY(0x0100),
TRACE_TIMER(0x0200),
TRACE_STREAM(0x0400),
TRACE_DEBUG(0x0800),
TRACE_INFO(0x1000),
TRACE_TERSEINFO(0x2000),
TRACE_ALL(0xffff);
public final int level;
TraceLevel(int level) {
this.level = level;
}
}
// Keep in sync with webrtc/rtc_base/logging.h:LoggingSeverity.
public enum Severity { LS_SENSITIVE, LS_VERBOSE, LS_INFO, LS_WARNING, LS_ERROR, LS_NONE }
public static void enableLogThreads() {
if (!loadNativeLibrary()) {
fallbackLogger.log(Level.WARNING, "Cannot enable log thread because native lib not loaded.");
return;
}
nativeEnableLogThreads();
}
public static void enableLogTimeStamps() {
if (!loadNativeLibrary()) {
fallbackLogger.log(
Level.WARNING, "Cannot enable log timestamps because native lib not loaded.");
return;
}
nativeEnableLogTimeStamps();
}
// Enable tracing to |path| of messages of |levels|.
// On Android, use "logcat:" for |path| to send output there.
// Note: this function controls the output of the WEBRTC_TRACE() macros.
public static synchronized void enableTracing(String path, EnumSet<TraceLevel> levels) {
if (!loadNativeLibrary()) {
fallbackLogger.log(Level.WARNING, "Cannot enable tracing because native lib not loaded.");
return;
}
if (tracingEnabled) {
return;
}
int nativeLevel = 0;
for (TraceLevel level : levels) {
nativeLevel |= level.level;
}
nativeEnableTracing(path, nativeLevel);
tracingEnabled = true;
}
// Enable diagnostic logging for messages of |severity| to the platform debug
// output. On Android, the output will be directed to Logcat.
// Note: this function starts collecting the output of the LOG() macros.
public static synchronized void enableLogToDebugOutput(Severity severity) {
if (!loadNativeLibrary()) {
fallbackLogger.log(Level.WARNING, "Cannot enable logging because native lib not loaded.");
return;
}
nativeEnableLogToDebugOutput(severity.ordinal());
loggingEnabled = true;
}
public static void log(Severity severity, String tag, String message) {
if (loggingEnabled) {
nativeLog(severity.ordinal(), tag, message);
return;
}
// 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) {
log(Severity.LS_INFO, tag, message);
}
public static void e(String tag, String message) {
log(Severity.LS_ERROR, tag, message);
}
public static void w(String tag, String message) {
log(Severity.LS_WARNING, tag, message);
}
public static void e(String tag, String message, Throwable e) {
log(Severity.LS_ERROR, tag, message);
log(Severity.LS_ERROR, tag, e.toString());
log(Severity.LS_ERROR, tag, getStackTraceString(e));
}
public static void w(String tag, String message, Throwable e) {
log(Severity.LS_WARNING, tag, message);
log(Severity.LS_WARNING, tag, e.toString());
log(Severity.LS_WARNING, tag, getStackTraceString(e));
}
public static void v(String tag, String message) {
log(Severity.LS_VERBOSE, tag, message);
}
private static String getStackTraceString(Throwable e) {
if (e == null) {
return "";
}
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
return sw.toString();
}
private static native void nativeEnableTracing(String path, int nativeLevels);
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);
}

1
rtc_base/java/src/org/webrtc/OWNERS Normal file
View File

@ -0,0 +1 @@
magjed@webrtc.org

45
rtc_base/java/src/org/webrtc/Size.java Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright 2016 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;
/**
* Class for representing size of an object. Very similar to android.util.Size but available on all
* devices.
*/
public class Size {
public int width;
public int height;
public Size(int width, int height) {
this.width = width;
this.height = height;
}
@Override
public String toString() {
return width + "x" + height;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Size)) {
return false;
}
final Size otherSize = (Size) other;
return width == otherSize.width && height == otherSize.height;
}
@Override
public int hashCode() {
// Use prime close to 2^16 to avoid collisions for normal values less than 2^16.
return 1 + 65537 * width + height;
}
}

220
rtc_base/java/src/org/webrtc/ThreadUtils.java Normal file
View File

@ -0,0 +1,220 @@
/*
* 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.
*/
package org.webrtc;
import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class ThreadUtils {
/**
* Utility class to be used for checking that a method is called on the correct thread.
*/
public static class ThreadChecker {
private Thread thread = Thread.currentThread();
public void checkIsOnValidThread() {
if (thread == null) {
thread = Thread.currentThread();
}
if (Thread.currentThread() != thread) {
throw new IllegalStateException("Wrong thread");
}
}
public void detachThread() {
thread = null;
}
}
/**
* Throws exception if called from other than main thread.
*/
public static void checkIsOnMainThread() {
if (Thread.currentThread() != Looper.getMainLooper().getThread()) {
throw new IllegalStateException("Not on main thread!");
}
}
/**
* Utility interface to be used with executeUninterruptibly() to wait for blocking operations
* to complete without getting interrupted..
*/
public interface BlockingOperation { void run() throws InterruptedException; }
/**
* Utility method to make sure a blocking operation is executed to completion without getting
* interrupted. This should be used in cases where the operation is waiting for some critical
* work, e.g. cleanup, that must complete before returning. If the thread is interrupted during
* the blocking operation, this function will re-run the operation until completion, and only then
* re-interrupt the thread.
*/
public static void executeUninterruptibly(BlockingOperation operation) {
boolean wasInterrupted = false;
while (true) {
try {
operation.run();
break;
} catch (InterruptedException e) {
// Someone is asking us to return early at our convenience. We can't cancel this operation,
// but we should preserve the information and pass it along.
wasInterrupted = true;
}
}
// Pass interruption information along.
if (wasInterrupted) {
Thread.currentThread().interrupt();
}
}
public static boolean joinUninterruptibly(final Thread thread, long timeoutMs) {
final long startTimeMs = SystemClock.elapsedRealtime();
long timeRemainingMs = timeoutMs;
boolean wasInterrupted = false;
while (timeRemainingMs > 0) {
try {
thread.join(timeRemainingMs);
break;
} catch (InterruptedException e) {
// Someone is asking us to return early at our convenience. We can't cancel this operation,
// but we should preserve the information and pass it along.
wasInterrupted = true;
final long elapsedTimeMs = SystemClock.elapsedRealtime() - startTimeMs;
timeRemainingMs = timeoutMs - elapsedTimeMs;
}
}
// Pass interruption information along.
if (wasInterrupted) {
Thread.currentThread().interrupt();
}
return !thread.isAlive();
}
public static void joinUninterruptibly(final Thread thread) {
executeUninterruptibly(new BlockingOperation() {
@Override
public void run() throws InterruptedException {
thread.join();
}
});
}
public static void awaitUninterruptibly(final CountDownLatch latch) {
executeUninterruptibly(new BlockingOperation() {
@Override
public void run() throws InterruptedException {
latch.await();
}
});
}
public static boolean awaitUninterruptibly(CountDownLatch barrier, long timeoutMs) {
final long startTimeMs = SystemClock.elapsedRealtime();
long timeRemainingMs = timeoutMs;
boolean wasInterrupted = false;
boolean result = false;
do {
try {
result = barrier.await(timeRemainingMs, TimeUnit.MILLISECONDS);
break;
} catch (InterruptedException e) {
// Someone is asking us to return early at our convenience. We can't cancel this operation,
// but we should preserve the information and pass it along.
wasInterrupted = true;
final long elapsedTimeMs = SystemClock.elapsedRealtime() - startTimeMs;
timeRemainingMs = timeoutMs - elapsedTimeMs;
}
} while (timeRemainingMs > 0);
// Pass interruption information along.
if (wasInterrupted) {
Thread.currentThread().interrupt();
}
return result;
}
public static void waitUninterruptibly(final Object object) {
executeUninterruptibly(new BlockingOperation() {
@Override
public void run() throws InterruptedException {
object.wait();
}
});
}
/**
* Post |callable| to |handler| and wait for the result.
*/
public static <V> V invokeAtFrontUninterruptibly(
final Handler handler, final Callable<V> callable) {
if (handler.getLooper().getThread() == Thread.currentThread()) {
try {
return callable.call();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// Place-holder classes that are assignable inside nested class.
class CaughtException {
Exception e;
}
class Result {
public V value;
}
final Result result = new Result();
final CaughtException caughtException = new CaughtException();
final CountDownLatch barrier = new CountDownLatch(1);
handler.post(new Runnable() {
@Override
public void run() {
try {
result.value = callable.call();
} catch (Exception e) {
caughtException.e = e;
}
barrier.countDown();
}
});
awaitUninterruptibly(barrier);
// Re-throw any runtime exception caught inside the other thread. Since this is an invoke, add
// stack trace for the waiting thread as well.
if (caughtException.e != null) {
final RuntimeException runtimeException = new RuntimeException(caughtException.e);
runtimeException.setStackTrace(
concatStackTraces(caughtException.e.getStackTrace(), runtimeException.getStackTrace()));
throw runtimeException;
}
return result.value;
}
/**
* Post |runner| to |handler|, at the front, and wait for completion.
*/
public static void invokeAtFrontUninterruptibly(final Handler handler, final Runnable runner) {
invokeAtFrontUninterruptibly(handler, new Callable<Void>() {
@Override
public Void call() {
runner.run();
return null;
}
});
}
static StackTraceElement[] concatStackTraces(
StackTraceElement[] inner, StackTraceElement[] outer) {
final StackTraceElement[] combined = new StackTraceElement[inner.length + outer.length];
System.arraycopy(inner, 0, combined, 0, inner.length);
System.arraycopy(outer, 0, combined, inner.length, outer.length);
return combined;
}
}