Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 1687 insertions, 0 deletions

diff --git a/third_party/libwebrtc/examples/unityplugin/ANDROID_INSTRUCTION b/third_party/libwebrtc/examples/unityplugin/ANDROID_INSTRUCTION
new file mode 100644
index 0000000000..d5f7399bca
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/ANDROID_INSTRUCTION
@@ -0,0 +1,33 @@
+Instruction of running webrtc_unity_plugin on Android Unity
+
+1. On Linux machine, compile target webrtc_unity_plugin.
+   Checkout WebRTC codebase: fetch --nohooks webrtc_android
+   If you already have a checkout for linux, add target_os=”android” into .gclient file.
+      Run gclient sync
+      Run gn args out/Android, and again set target_os=”android” in the args.gn
+      Run ninja -C out/Android webrtc_unity_plugin
+
+2. On Linux machine, build target libwebrtc_unity under webrtc checkout. This is the java code for webrtc to work on Android.
+
+3. Copy libwebrtc_unity.jar and libwebrtc_unity_plugin.so into Unity project folder, under Assets/Plugins/Android folder.
+
+4. Rename libwebrtc_unity_plugin.so to libjingle_peerconnection_so.so. This is hacky, and the purpose is to let the java code in libwebrtc_unity.jar to find their JNI implementations. Simultaneously, in your C# wrapper script for the native plugin libjingle_peerconnection_so.so, the dll_path should be set to “jingle_peerconnection_so”.
+
+5. In the Unity Main Scene’s Start method, write the following code to initialize the Java environment for webrtc (otherwise, webrtc will not be able to access audio device or camera from C++ code):
+
+#if UNITY_ANDROID
+    AndroidJavaClass playerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
+    AndroidJavaObject activity = playerClass.GetStatic<AndroidJavaObject>("currentActivity");
+    AndroidJavaClass utilityClass = new AndroidJavaClass("org.webrtc.UnityUtility");
+    utilityClass.CallStatic("InitializePeerConncectionFactory", new object[1] { activity });
+#endif
+
+6. Compile the unity project into an APK, and decompile the apk using apktool that you can download from https://ibotpeaches.github.io/Apktool/
+    Run apktool d apkname.apk.
+Then copy the AndroidManifest.xml in the decompiled folder to the Assets/Plugins/Android folder, and add two lines:
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.CAMERA" />
+
+The purpose of using apktool is to get a well-written android manifest xml file. If you know how to write manifest file from scratch, you can skip using apktool.
+
+7. Compile the unity project into an APK again and deploy it to an android device.
diff --git a/third_party/libwebrtc/examples/unityplugin/DEPS b/third_party/libwebrtc/examples/unityplugin/DEPS
new file mode 100644
index 0000000000..604005ac73
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  "+modules/utility",
+  "+sdk",
+]
diff --git a/third_party/libwebrtc/examples/unityplugin/README b/third_party/libwebrtc/examples/unityplugin/README
new file mode 100644
index 0000000000..da8f07aa11
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/README
@@ -0,0 +1,309 @@
+This directory contains an example Unity native plugin for Windows OS and Android.
+
+The APIs use Platform Invoke (P/Invoke) technology as required by Unity native plugin.
+This plugin dll can also be used by Windows C# applications other than Unity.
+
+For detailed build instruction on Android, see ANDROID_INSTRUCTION
+
+An example of wrapping native plugin into a C# managed class in Unity is given as following:
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace SimplePeerConnectionM {
+  // A class for ice candidate.
+  public class IceCandidate {
+    public IceCandidate(string candidate, int sdpMlineIndex, string sdpMid) {
+      mCandidate = candidate;
+      mSdpMlineIndex = sdpMlineIndex;
+      mSdpMid = sdpMid;
+    }
+    string mCandidate;
+    int mSdpMlineIndex;
+    string mSdpMid;
+
+    public string Candidate {
+      get { return mCandidate; }
+      set { mCandidate = value; }
+    }
+
+    public int SdpMlineIndex {
+      get { return mSdpMlineIndex; }
+      set { mSdpMlineIndex = value; }
+    }
+
+    public string SdpMid {
+      get { return mSdpMid; }
+      set { mSdpMid = value; }
+    }
+  }
+
+  // A managed wrapper up class for the native c style peer connection APIs.
+  public class PeerConnectionM {
+    private const string dllPath = "webrtc_unity_plugin";
+
+    //create a peerconnection with turn servers
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern int CreatePeerConnection(string[] turnUrls, int noOfUrls,
+        string username, string credential);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool ClosePeerConnection(int peerConnectionId);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool AddStream(int peerConnectionId, bool audioOnly);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool AddDataChannel(int peerConnectionId);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool CreateOffer(int peerConnectionId);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool CreateAnswer(int peerConnectionId);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool SendDataViaDataChannel(int peerConnectionId, string data);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool SetAudioControl(int peerConnectionId, bool isMute, bool isRecord);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void LocalDataChannelReadyInternalDelegate();
+    public delegate void LocalDataChannelReadyDelegate(int id);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnLocalDataChannelReady(
+        int peerConnectionId, LocalDataChannelReadyInternalDelegate callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void DataFromDataChannelReadyInternalDelegate(string s);
+    public delegate void DataFromDataChannelReadyDelegate(int id, string s);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnDataFromDataChannelReady(
+        int peerConnectionId, DataFromDataChannelReadyInternalDelegate callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void FailureMessageInternalDelegate(string msg);
+    public delegate void FailureMessageDelegate(int id, string msg);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnFailure(int peerConnectionId,
+        FailureMessageInternalDelegate callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void AudioBusReadyInternalDelegate(IntPtr data, int bitsPerSample,
+        int sampleRate, int numberOfChannels, int numberOfFrames);
+    public delegate void AudioBusReadyDelegate(int id, IntPtr data, int bitsPerSample,
+        int sampleRate, int numberOfChannels, int numberOfFrames);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnAudioBusReady(int peerConnectionId,
+        AudioBusReadyInternalDelegate callback);
+
+    // Video callbacks.
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void I420FrameReadyInternalDelegate(
+        IntPtr dataY, IntPtr dataU, IntPtr dataV,
+        int strideY, int strideU, int strideV,
+        uint width, uint height);
+    public delegate void I420FrameReadyDelegate(int id,
+        IntPtr dataY, IntPtr dataU, IntPtr dataV,
+        int strideY, int strideU, int strideV,
+        uint width, uint height);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnLocalI420FrameReady(int peerConnectionId,
+        I420FrameReadyInternalDelegate callback);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnRemoteI420FrameReady(int peerConnectionId,
+        I420FrameReadyInternalDelegate callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void LocalSdpReadytoSendInternalDelegate(string type, string sdp);
+    public delegate void LocalSdpReadytoSendDelegate(int id, string type, string sdp);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnLocalSdpReadytoSend(int peerConnectionId,
+        LocalSdpReadytoSendInternalDelegate callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void IceCandidateReadytoSendInternalDelegate(
+        string candidate, int sdpMlineIndex, string sdpMid);
+    public delegate void IceCandidateReadytoSendDelegate(
+        int id, string candidate, int sdpMlineIndex, string sdpMid);
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool RegisterOnIceCandidateReadytoSend(
+        int peerConnectionId, IceCandidateReadytoSendInternalDelegate callback);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool SetRemoteDescription(int peerConnectionId, string type, string sdp);
+
+    [DllImport(dllPath, CallingConvention = CallingConvention.Cdecl)]
+    private static extern bool AddIceCandidate(int peerConnectionId, string sdp,
+      int sdpMlineindex, string sdpMid);
+
+    public PeerConnectionM(List<string> turnUrls, string username, string credential) {
+      string[] urls = turnUrls != null ? turnUrls.ToArray() : null;
+      int length = turnUrls != null ? turnUrls.Count : 0;
+      mPeerConnectionId = CreatePeerConnection(urls, length, username, credential);
+      RegisterCallbacks();
+    }
+
+    public void ClosePeerConnection() {
+      ClosePeerConnection(mPeerConnectionId);
+      mPeerConnectionId = -1;
+    }
+
+    // Return -1 if Peerconnection is not available.
+    public int GetUniqueId() {
+      return mPeerConnectionId;
+    }
+
+    public void AddStream(bool audioOnly) {
+      AddStream(mPeerConnectionId, audioOnly);
+    }
+
+    public void AddDataChannel() {
+      AddDataChannel(mPeerConnectionId);
+    }
+
+    public void CreateOffer() {
+      CreateOffer(mPeerConnectionId);
+    }
+
+    public void CreateAnswer() {
+      CreateAnswer(mPeerConnectionId);
+    }
+
+    public void SendDataViaDataChannel(string data) {
+      SendDataViaDataChannel(mPeerConnectionId, data);
+    }
+
+    public void SetAudioControl(bool isMute, bool isRecord) {
+      SetAudioControl(mPeerConnectionId, isMute, isRecord);
+    }
+
+    public void SetRemoteDescription(string type, string sdp) {
+      SetRemoteDescription(mPeerConnectionId, type, sdp);
+    }
+
+    public void AddIceCandidate(string candidate, int sdpMlineindex, string sdpMid) {
+      AddIceCandidate(mPeerConnectionId, candidate, sdpMlineindex, sdpMid);
+    }
+
+    private void RegisterCallbacks() {
+      localDataChannelReadyDelegate = new LocalDataChannelReadyInternalDelegate(
+          RaiseLocalDataChannelReady);
+      RegisterOnLocalDataChannelReady(mPeerConnectionId, localDataChannelReadyDelegate);
+
+      dataFromDataChannelReadyDelegate = new DataFromDataChannelReadyInternalDelegate(
+          RaiseDataFromDataChannelReady);
+      RegisterOnDataFromDataChannelReady(mPeerConnectionId, dataFromDataChannelReadyDelegate);
+
+      failureMessageDelegate = new FailureMessageInternalDelegate(RaiseFailureMessage);
+      RegisterOnFailure(mPeerConnectionId, failureMessageDelegate);
+
+      audioBusReadyDelegate = new AudioBusReadyInternalDelegate(RaiseAudioBusReady);
+      RegisterOnAudioBusReady(mPeerConnectionId, audioBusReadyDelegate);
+
+      localI420FrameReadyDelegate = new I420FrameReadyInternalDelegate(
+        RaiseLocalVideoFrameReady);
+      RegisterOnLocalI420FrameReady(mPeerConnectionId, localI420FrameReadyDelegate);
+
+      remoteI420FrameReadyDelegate = new I420FrameReadyInternalDelegate(
+        RaiseRemoteVideoFrameReady);
+      RegisterOnRemoteI420FrameReady(mPeerConnectionId, remoteI420FrameReadyDelegate);
+
+      localSdpReadytoSendDelegate = new LocalSdpReadytoSendInternalDelegate(
+        RaiseLocalSdpReadytoSend);
+      RegisterOnLocalSdpReadytoSend(mPeerConnectionId, localSdpReadytoSendDelegate);
+
+      iceCandidateReadytoSendDelegate =
+          new IceCandidateReadytoSendInternalDelegate(RaiseIceCandidateReadytoSend);
+      RegisterOnIceCandidateReadytoSend(
+          mPeerConnectionId, iceCandidateReadytoSendDelegate);
+    }
+
+    private void RaiseLocalDataChannelReady() {
+      if (OnLocalDataChannelReady != null)
+        OnLocalDataChannelReady(mPeerConnectionId);
+    }
+
+    private void RaiseDataFromDataChannelReady(string data) {
+      if (OnDataFromDataChannelReady != null)
+        OnDataFromDataChannelReady(mPeerConnectionId, data);
+    }
+
+    private void RaiseFailureMessage(string msg) {
+      if (OnFailureMessage != null)
+        OnFailureMessage(mPeerConnectionId, msg);
+    }
+
+    private void RaiseAudioBusReady(IntPtr data, int bitsPerSample,
+      int sampleRate, int numberOfChannels, int numberOfFrames) {
+      if (OnAudioBusReady != null)
+        OnAudioBusReady(mPeerConnectionId, data, bitsPerSample, sampleRate,
+            numberOfChannels, numberOfFrames);
+    }
+
+    private void RaiseLocalVideoFrameReady(
+        IntPtr dataY, IntPtr dataU, IntPtr dataV,
+        int strideY, int strideU, int strideV,
+        uint width, uint height) {
+      if (OnLocalVideoFrameReady != null)
+        OnLocalVideoFrameReady(mPeerConnectionId, dataY, dataU, dataV, strideY, strideU, strideV,
+          width, height);
+    }
+
+    private void RaiseRemoteVideoFrameReady(
+       IntPtr dataY, IntPtr dataU, IntPtr dataV,
+       int strideY, int strideU, int strideV,
+       uint width, uint height) {
+      if (OnRemoteVideoFrameReady != null)
+        OnRemoteVideoFrameReady(mPeerConnectionId, dataY, dataU, dataV, strideY, strideU, strideV,
+          width, height);
+    }
+
+
+    private void RaiseLocalSdpReadytoSend(string type, string sdp) {
+      if (OnLocalSdpReadytoSend != null)
+        OnLocalSdpReadytoSend(mPeerConnectionId, type, sdp);
+    }
+
+    private void RaiseIceCandidateReadytoSend(string candidate, int sdpMlineIndex, string sdpMid) {
+      if (OnIceCandidateReadytoSend != null)
+        OnIceCandidateReadytoSend(mPeerConnectionId, candidate, sdpMlineIndex, sdpMid);
+    }
+
+    public void AddQueuedIceCandidate(List<IceCandidate> iceCandidateQueue) {
+      if (iceCandidateQueue != null) {
+        foreach (IceCandidate ic in iceCandidateQueue) {
+          AddIceCandidate(mPeerConnectionId, ic.Candidate, ic.SdpMlineIndex, ic.SdpMid);
+        }
+      }
+    }
+
+    private LocalDataChannelReadyInternalDelegate localDataChannelReadyDelegate = null;
+    public event LocalDataChannelReadyDelegate OnLocalDataChannelReady;
+
+    private DataFromDataChannelReadyInternalDelegate dataFromDataChannelReadyDelegate = null;
+    public event DataFromDataChannelReadyDelegate OnDataFromDataChannelReady;
+
+    private FailureMessageInternalDelegate failureMessageDelegate = null;
+    public event FailureMessageDelegate OnFailureMessage;
+
+    private AudioBusReadyInternalDelegate audioBusReadyDelegate = null;
+    public event AudioBusReadyDelegate OnAudioBusReady;
+
+    private I420FrameReadyInternalDelegate localI420FrameReadyDelegate = null;
+    public event I420FrameReadyDelegate OnLocalVideoFrameReady;
+
+    private I420FrameReadyInternalDelegate remoteI420FrameReadyDelegate = null;
+    public event I420FrameReadyDelegate OnRemoteVideoFrameReady;
+
+    private LocalSdpReadytoSendInternalDelegate localSdpReadytoSendDelegate = null;
+    public event LocalSdpReadytoSendDelegate OnLocalSdpReadytoSend;
+
+    private IceCandidateReadytoSendInternalDelegate iceCandidateReadytoSendDelegate = null;
+    public event IceCandidateReadytoSendDelegate OnIceCandidateReadytoSend;
+
+    private int mPeerConnectionId = -1;
+  }
+}
diff --git a/third_party/libwebrtc/examples/unityplugin/class_reference_holder.cc b/third_party/libwebrtc/examples/unityplugin/class_reference_holder.cc
new file mode 100644
index 0000000000..00ca772e76
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/class_reference_holder.cc
@@ -0,0 +1,88 @@
+/*
+ *  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.
+ */
+#include "examples/unityplugin/class_reference_holder.h"
+
+#include <utility>
+
+#include "sdk/android/src/jni/jni_helpers.h"
+
+namespace unity_plugin {
+
+// ClassReferenceHolder holds global reference to Java classes in app/webrtc.
+class ClassReferenceHolder {
+ public:
+  explicit ClassReferenceHolder(JNIEnv* jni);
+  ~ClassReferenceHolder();
+
+  void FreeReferences(JNIEnv* jni);
+  jclass GetClass(const std::string& name);
+
+  void LoadClass(JNIEnv* jni, const std::string& name);
+
+ private:
+  std::map<std::string, jclass> classes_;
+};
+
+// Allocated in LoadGlobalClassReferenceHolder(),
+// freed in FreeGlobalClassReferenceHolder().
+static ClassReferenceHolder* g_class_reference_holder = nullptr;
+
+void LoadGlobalClassReferenceHolder() {
+  RTC_CHECK(g_class_reference_holder == nullptr);
+  g_class_reference_holder = new ClassReferenceHolder(webrtc::jni::GetEnv());
+}
+
+void FreeGlobalClassReferenceHolder() {
+  g_class_reference_holder->FreeReferences(
+      webrtc::jni::AttachCurrentThreadIfNeeded());
+  delete g_class_reference_holder;
+  g_class_reference_holder = nullptr;
+}
+
+ClassReferenceHolder::ClassReferenceHolder(JNIEnv* jni) {
+  LoadClass(jni, "org/webrtc/UnityUtility");
+}
+
+ClassReferenceHolder::~ClassReferenceHolder() {
+  RTC_CHECK(classes_.empty()) << "Must call FreeReferences() before dtor!";
+}
+
+void ClassReferenceHolder::FreeReferences(JNIEnv* jni) {
+  for (std::map<std::string, jclass>::const_iterator it = classes_.begin();
+       it != classes_.end(); ++it) {
+    jni->DeleteGlobalRef(it->second);
+  }
+  classes_.clear();
+}
+
+jclass ClassReferenceHolder::GetClass(const std::string& name) {
+  std::map<std::string, jclass>::iterator it = classes_.find(name);
+  RTC_CHECK(it != classes_.end()) << "Unexpected GetClass() call for: " << name;
+  return it->second;
+}
+
+void ClassReferenceHolder::LoadClass(JNIEnv* jni, const std::string& name) {
+  jclass localRef = jni->FindClass(name.c_str());
+  CHECK_EXCEPTION(jni) << "error during FindClass: " << name;
+  RTC_CHECK(localRef) << name;
+  jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef));
+  CHECK_EXCEPTION(jni) << "error during NewGlobalRef: " << name;
+  RTC_CHECK(globalRef) << name;
+  bool inserted = classes_.insert(std::make_pair(name, globalRef)).second;
+  RTC_CHECK(inserted) << "Duplicate class name: " << name;
+}
+
+// Returns a global reference guaranteed to be valid for the lifetime of the
+// process.
+jclass FindClass(JNIEnv* jni, const char* name) {
+  return g_class_reference_holder->GetClass(name);
+}
+
+}  // namespace unity_plugin
diff --git a/third_party/libwebrtc/examples/unityplugin/class_reference_holder.h b/third_party/libwebrtc/examples/unityplugin/class_reference_holder.h
new file mode 100644
index 0000000000..884d471ceb
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/class_reference_holder.h
@@ -0,0 +1,38 @@
+/*
+ *  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.
+ */
+
+// This is a supplement of webrtc::jni::ClassReferenceHolder.
+// The purpose of this ClassReferenceHolder is to load the example
+// specific java class into JNI c++ side, so that our c++ code can
+// call those java functions.
+
+#ifndef EXAMPLES_UNITYPLUGIN_CLASS_REFERENCE_HOLDER_H_
+#define EXAMPLES_UNITYPLUGIN_CLASS_REFERENCE_HOLDER_H_
+
+#include <jni.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace unity_plugin {
+
+// LoadGlobalClassReferenceHolder must be called in JNI_OnLoad.
+void LoadGlobalClassReferenceHolder();
+// FreeGlobalClassReferenceHolder must be called in JNI_UnLoad.
+void FreeGlobalClassReferenceHolder();
+
+// Returns a global reference guaranteed to be valid for the lifetime of the
+// process.
+jclass FindClass(JNIEnv* jni, const char* name);
+
+}  // namespace unity_plugin
+
+#endif  // EXAMPLES_UNITYPLUGIN_CLASS_REFERENCE_HOLDER_H_
diff --git a/third_party/libwebrtc/examples/unityplugin/java/src/org/webrtc/UnityUtility.java b/third_party/libwebrtc/examples/unityplugin/java/src/org/webrtc/UnityUtility.java
new file mode 100644
index 0000000000..bd8bbfa449
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/java/src/org/webrtc/UnityUtility.java
@@ -0,0 +1,68 @@
+/*
+ *  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 androidx.annotation.Nullable;
+
+public class UnityUtility {
+  private static final String VIDEO_CAPTURER_THREAD_NAME = "VideoCapturerThread";
+
+  public static SurfaceTextureHelper LoadSurfaceTextureHelper() {
+    final SurfaceTextureHelper surfaceTextureHelper =
+        SurfaceTextureHelper.create(VIDEO_CAPTURER_THREAD_NAME, null);
+    return surfaceTextureHelper;
+  }
+
+  private static boolean useCamera2() {
+    return Camera2Enumerator.isSupported(ContextUtils.getApplicationContext());
+  }
+
+  private static @Nullable VideoCapturer createCameraCapturer(CameraEnumerator enumerator) {
+    final String[] deviceNames = enumerator.getDeviceNames();
+
+    for (String deviceName : deviceNames) {
+      if (enumerator.isFrontFacing(deviceName)) {
+        VideoCapturer videoCapturer = enumerator.createCapturer(deviceName, null);
+
+        if (videoCapturer != null) {
+          return videoCapturer;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  public static VideoCapturer LinkCamera(
+      long nativeTrackSource, SurfaceTextureHelper surfaceTextureHelper) {
+    VideoCapturer capturer =
+        createCameraCapturer(new Camera2Enumerator(ContextUtils.getApplicationContext()));
+
+    VideoSource videoSource = new VideoSource(nativeTrackSource);
+
+    capturer.initialize(surfaceTextureHelper, ContextUtils.getApplicationContext(),
+        videoSource.getCapturerObserver());
+
+    capturer.startCapture(720, 480, 30);
+    return capturer;
+  }
+
+  public static void StopCamera(VideoCapturer camera) throws InterruptedException {
+    camera.stopCapture();
+    camera.dispose();
+  }
+
+  public static void InitializePeerConncectionFactory(Context context) throws InterruptedException {
+    PeerConnectionFactory.initialize(
+        PeerConnectionFactory.InitializationOptions.builder(context).createInitializationOptions());
+  }
+}
diff --git a/third_party/libwebrtc/examples/unityplugin/jni_onload.cc b/third_party/libwebrtc/examples/unityplugin/jni_onload.cc
new file mode 100644
index 0000000000..b9c92d5ef4
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/jni_onload.cc
@@ -0,0 +1,42 @@
+/*
+ *  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.
+ */
+
+#include <jni.h>
+#undef JNIEXPORT
+#define JNIEXPORT __attribute__((visibility("default")))
+
+#include "examples/unityplugin/class_reference_holder.h"
+#include "rtc_base/ssl_adapter.h"
+#include "sdk/android/native_api/jni/class_loader.h"
+#include "sdk/android/src/jni/jni_helpers.h"
+
+namespace webrtc {
+namespace jni {
+
+extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM* jvm, void* reserved) {
+  jint ret = InitGlobalJniVariables(jvm);
+  RTC_DCHECK_GE(ret, 0);
+  if (ret < 0)
+    return -1;
+
+  RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+  webrtc::InitClassLoader(GetEnv());
+  unity_plugin::LoadGlobalClassReferenceHolder();
+
+  return ret;
+}
+
+extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM* jvm, void* reserved) {
+  unity_plugin::FreeGlobalClassReferenceHolder();
+  RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
+}
+
+}  // namespace jni
+}  // namespace webrtc
diff --git a/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.cc b/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.cc
new file mode 100644
index 0000000000..861b22f29c
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.cc
@@ -0,0 +1,587 @@
+/*
+ *  Copyright (c) 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 "examples/unityplugin/simple_peer_connection.h"
+
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/create_peerconnection_factory.h"
+#include "media/engine/internal_decoder_factory.h"
+#include "media/engine/internal_encoder_factory.h"
+#include "media/engine/multiplex_codec_factory.h"
+#include "modules/audio_device/include/audio_device.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "modules/video_capture/video_capture_factory.h"
+#include "pc/video_track_source.h"
+#include "test/vcm_capturer.h"
+
+#if defined(WEBRTC_ANDROID)
+#include "examples/unityplugin/class_reference_holder.h"
+#include "modules/utility/include/helpers_android.h"
+#include "sdk/android/src/jni/android_video_track_source.h"
+#include "sdk/android/src/jni/jni_helpers.h"
+#endif
+
+// Names used for media stream ids.
+const char kAudioLabel[] = "audio_label";
+const char kVideoLabel[] = "video_label";
+const char kStreamId[] = "stream_id";
+
+namespace {
+static int g_peer_count = 0;
+static std::unique_ptr<rtc::Thread> g_worker_thread;
+static std::unique_ptr<rtc::Thread> g_signaling_thread;
+static rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+    g_peer_connection_factory;
+#if defined(WEBRTC_ANDROID)
+// Android case: the video track does not own the capturer, and it
+// relies on the app to dispose the capturer when the peerconnection
+// shuts down.
+static jobject g_camera = nullptr;
+#else
+class CapturerTrackSource : public webrtc::VideoTrackSource {
+ public:
+  static rtc::scoped_refptr<CapturerTrackSource> Create() {
+    const size_t kWidth = 640;
+    const size_t kHeight = 480;
+    const size_t kFps = 30;
+    const size_t kDeviceIndex = 0;
+    std::unique_ptr<webrtc::test::VcmCapturer> capturer = absl::WrapUnique(
+        webrtc::test::VcmCapturer::Create(kWidth, kHeight, kFps, kDeviceIndex));
+    if (!capturer) {
+      return nullptr;
+    }
+    return rtc::make_ref_counted<CapturerTrackSource>(std::move(capturer));
+  }
+
+ protected:
+  explicit CapturerTrackSource(
+      std::unique_ptr<webrtc::test::VcmCapturer> capturer)
+      : VideoTrackSource(/*remote=*/false), capturer_(std::move(capturer)) {}
+
+ private:
+  rtc::VideoSourceInterface<webrtc::VideoFrame>* source() override {
+    return capturer_.get();
+  }
+  std::unique_ptr<webrtc::test::VcmCapturer> capturer_;
+};
+
+#endif
+
+std::string GetEnvVarOrDefault(const char* env_var_name,
+                               const char* default_value) {
+  std::string value;
+  const char* env_var = getenv(env_var_name);
+  if (env_var)
+    value = env_var;
+
+  if (value.empty())
+    value = default_value;
+
+  return value;
+}
+
+std::string GetPeerConnectionString() {
+  return GetEnvVarOrDefault("WEBRTC_CONNECT", "stun:stun.l.google.com:19302");
+}
+
+class DummySetSessionDescriptionObserver
+    : public webrtc::SetSessionDescriptionObserver {
+ public:
+  static rtc::scoped_refptr<DummySetSessionDescriptionObserver> Create() {
+    return rtc::make_ref_counted<DummySetSessionDescriptionObserver>();
+  }
+  virtual void OnSuccess() { RTC_LOG(LS_INFO) << __FUNCTION__; }
+  virtual void OnFailure(webrtc::RTCError error) {
+    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << ToString(error.type()) << ": "
+                     << error.message();
+  }
+
+ protected:
+  DummySetSessionDescriptionObserver() {}
+  ~DummySetSessionDescriptionObserver() {}
+};
+
+}  // namespace
+
+bool SimplePeerConnection::InitializePeerConnection(const char** turn_urls,
+                                                    const int no_of_urls,
+                                                    const char* username,
+                                                    const char* credential,
+                                                    bool is_receiver) {
+  RTC_DCHECK(peer_connection_.get() == nullptr);
+
+  if (g_peer_connection_factory == nullptr) {
+    g_worker_thread = rtc::Thread::Create();
+    g_worker_thread->Start();
+    g_signaling_thread = rtc::Thread::Create();
+    g_signaling_thread->Start();
+
+    g_peer_connection_factory = webrtc::CreatePeerConnectionFactory(
+        g_worker_thread.get(), g_worker_thread.get(), g_signaling_thread.get(),
+        nullptr, webrtc::CreateBuiltinAudioEncoderFactory(),
+        webrtc::CreateBuiltinAudioDecoderFactory(),
+        std::unique_ptr<webrtc::VideoEncoderFactory>(
+            new webrtc::MultiplexEncoderFactory(
+                std::make_unique<webrtc::InternalEncoderFactory>())),
+        std::unique_ptr<webrtc::VideoDecoderFactory>(
+            new webrtc::MultiplexDecoderFactory(
+                std::make_unique<webrtc::InternalDecoderFactory>())),
+        nullptr, nullptr);
+  }
+  if (!g_peer_connection_factory.get()) {
+    DeletePeerConnection();
+    return false;
+  }
+
+  g_peer_count++;
+  if (!CreatePeerConnection(turn_urls, no_of_urls, username, credential)) {
+    DeletePeerConnection();
+    return false;
+  }
+
+  mandatory_receive_ = is_receiver;
+  return peer_connection_.get() != nullptr;
+}
+
+bool SimplePeerConnection::CreatePeerConnection(const char** turn_urls,
+                                                const int no_of_urls,
+                                                const char* username,
+                                                const char* credential) {
+  RTC_DCHECK(g_peer_connection_factory.get() != nullptr);
+  RTC_DCHECK(peer_connection_.get() == nullptr);
+
+  local_video_observer_.reset(new VideoObserver());
+  remote_video_observer_.reset(new VideoObserver());
+
+  // Add the turn server.
+  if (turn_urls != nullptr) {
+    if (no_of_urls > 0) {
+      webrtc::PeerConnectionInterface::IceServer turn_server;
+      for (int i = 0; i < no_of_urls; i++) {
+        std::string url(turn_urls[i]);
+        if (url.length() > 0)
+          turn_server.urls.push_back(turn_urls[i]);
+      }
+
+      std::string user_name(username);
+      if (user_name.length() > 0)
+        turn_server.username = username;
+
+      std::string password(credential);
+      if (password.length() > 0)
+        turn_server.password = credential;
+
+      config_.servers.push_back(turn_server);
+    }
+  }
+
+  // Add the stun server.
+  webrtc::PeerConnectionInterface::IceServer stun_server;
+  stun_server.uri = GetPeerConnectionString();
+  config_.servers.push_back(stun_server);
+
+  auto result = g_peer_connection_factory->CreatePeerConnectionOrError(
+      config_, webrtc::PeerConnectionDependencies(this));
+  if (!result.ok()) {
+    peer_connection_ = nullptr;
+    return false;
+  }
+  peer_connection_ = result.MoveValue();
+  return true;
+}
+
+void SimplePeerConnection::DeletePeerConnection() {
+  g_peer_count--;
+
+#if defined(WEBRTC_ANDROID)
+  if (g_camera) {
+    JNIEnv* env = webrtc::jni::GetEnv();
+    jclass pc_factory_class =
+        unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
+    jmethodID stop_camera_method = webrtc::GetStaticMethodID(
+        env, pc_factory_class, "StopCamera", "(Lorg/webrtc/VideoCapturer;)V");
+
+    env->CallStaticVoidMethod(pc_factory_class, stop_camera_method, g_camera);
+    CHECK_EXCEPTION(env);
+
+    g_camera = nullptr;
+  }
+#endif
+
+  CloseDataChannel();
+  peer_connection_ = nullptr;
+  active_streams_.clear();
+
+  if (g_peer_count == 0) {
+    g_peer_connection_factory = nullptr;
+    g_signaling_thread.reset();
+    g_worker_thread.reset();
+  }
+}
+
+bool SimplePeerConnection::CreateOffer() {
+  if (!peer_connection_.get())
+    return false;
+
+  webrtc::PeerConnectionInterface::RTCOfferAnswerOptions options;
+  if (mandatory_receive_) {
+    options.offer_to_receive_audio = true;
+    options.offer_to_receive_video = true;
+  }
+  peer_connection_->CreateOffer(this, options);
+  return true;
+}
+
+bool SimplePeerConnection::CreateAnswer() {
+  if (!peer_connection_.get())
+    return false;
+
+  webrtc::PeerConnectionInterface::RTCOfferAnswerOptions options;
+  if (mandatory_receive_) {
+    options.offer_to_receive_audio = true;
+    options.offer_to_receive_video = true;
+  }
+  peer_connection_->CreateAnswer(this, options);
+  return true;
+}
+
+void SimplePeerConnection::OnSuccess(
+    webrtc::SessionDescriptionInterface* desc) {
+  peer_connection_->SetLocalDescription(
+      DummySetSessionDescriptionObserver::Create().get(), desc);
+
+  std::string sdp;
+  desc->ToString(&sdp);
+
+  if (OnLocalSdpReady)
+    OnLocalSdpReady(desc->type().c_str(), sdp.c_str());
+}
+
+void SimplePeerConnection::OnFailure(webrtc::RTCError error) {
+  RTC_LOG(LS_ERROR) << ToString(error.type()) << ": " << error.message();
+
+  // TODO(hta): include error.type in the message
+  if (OnFailureMessage)
+    OnFailureMessage(error.message());
+}
+
+void SimplePeerConnection::OnIceCandidate(
+    const webrtc::IceCandidateInterface* candidate) {
+  RTC_LOG(LS_INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index();
+
+  std::string sdp;
+  if (!candidate->ToString(&sdp)) {
+    RTC_LOG(LS_ERROR) << "Failed to serialize candidate";
+    return;
+  }
+
+  if (OnIceCandidateReady)
+    OnIceCandidateReady(sdp.c_str(), candidate->sdp_mline_index(),
+                        candidate->sdp_mid().c_str());
+}
+
+void SimplePeerConnection::RegisterOnLocalI420FrameReady(
+    I420FRAMEREADY_CALLBACK callback) {
+  if (local_video_observer_)
+    local_video_observer_->SetVideoCallback(callback);
+}
+
+void SimplePeerConnection::RegisterOnRemoteI420FrameReady(
+    I420FRAMEREADY_CALLBACK callback) {
+  if (remote_video_observer_)
+    remote_video_observer_->SetVideoCallback(callback);
+}
+
+void SimplePeerConnection::RegisterOnLocalDataChannelReady(
+    LOCALDATACHANNELREADY_CALLBACK callback) {
+  OnLocalDataChannelReady = callback;
+}
+
+void SimplePeerConnection::RegisterOnDataFromDataChannelReady(
+    DATAFROMEDATECHANNELREADY_CALLBACK callback) {
+  OnDataFromDataChannelReady = callback;
+}
+
+void SimplePeerConnection::RegisterOnFailure(FAILURE_CALLBACK callback) {
+  OnFailureMessage = callback;
+}
+
+void SimplePeerConnection::RegisterOnAudioBusReady(
+    AUDIOBUSREADY_CALLBACK callback) {
+  OnAudioReady = callback;
+}
+
+void SimplePeerConnection::RegisterOnLocalSdpReadytoSend(
+    LOCALSDPREADYTOSEND_CALLBACK callback) {
+  OnLocalSdpReady = callback;
+}
+
+void SimplePeerConnection::RegisterOnIceCandidateReadytoSend(
+    ICECANDIDATEREADYTOSEND_CALLBACK callback) {
+  OnIceCandidateReady = callback;
+}
+
+bool SimplePeerConnection::SetRemoteDescription(const char* type,
+                                                const char* sdp) {
+  if (!peer_connection_)
+    return false;
+
+  std::string remote_desc(sdp);
+  std::string desc_type(type);
+  webrtc::SdpParseError error;
+  webrtc::SessionDescriptionInterface* session_description(
+      webrtc::CreateSessionDescription(desc_type, remote_desc, &error));
+  if (!session_description) {
+    RTC_LOG(LS_WARNING) << "Can't parse received session description message. "
+                           "SdpParseError was: "
+                        << error.description;
+    return false;
+  }
+  RTC_LOG(LS_INFO) << " Received session description :" << remote_desc;
+  peer_connection_->SetRemoteDescription(
+      DummySetSessionDescriptionObserver::Create().get(), session_description);
+
+  return true;
+}
+
+bool SimplePeerConnection::AddIceCandidate(const char* candidate,
+                                           const int sdp_mlineindex,
+                                           const char* sdp_mid) {
+  if (!peer_connection_)
+    return false;
+
+  webrtc::SdpParseError error;
+  std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate(
+      webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, candidate, &error));
+  if (!ice_candidate.get()) {
+    RTC_LOG(LS_WARNING) << "Can't parse received candidate message. "
+                           "SdpParseError was: "
+                        << error.description;
+    return false;
+  }
+  if (!peer_connection_->AddIceCandidate(ice_candidate.get())) {
+    RTC_LOG(LS_WARNING) << "Failed to apply the received candidate";
+    return false;
+  }
+  RTC_LOG(LS_INFO) << " Received candidate :" << candidate;
+  return true;
+}
+
+void SimplePeerConnection::SetAudioControl(bool is_mute, bool is_record) {
+  is_mute_audio_ = is_mute;
+  is_record_audio_ = is_record;
+
+  SetAudioControl();
+}
+
+void SimplePeerConnection::SetAudioControl() {
+  if (!remote_stream_)
+    return;
+  webrtc::AudioTrackVector tracks = remote_stream_->GetAudioTracks();
+  if (tracks.empty())
+    return;
+
+  rtc::scoped_refptr<webrtc::AudioTrackInterface>& audio_track = tracks[0];
+  if (is_record_audio_)
+    audio_track->AddSink(this);
+  else
+    audio_track->RemoveSink(this);
+
+  for (auto& track : tracks) {
+    if (is_mute_audio_)
+      track->set_enabled(false);
+    else
+      track->set_enabled(true);
+  }
+}
+
+void SimplePeerConnection::OnAddStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+  RTC_LOG(LS_INFO) << __FUNCTION__ << " " << stream->id();
+  remote_stream_ = stream;
+  if (remote_video_observer_ && !remote_stream_->GetVideoTracks().empty()) {
+    remote_stream_->GetVideoTracks()[0]->AddOrUpdateSink(
+        remote_video_observer_.get(), rtc::VideoSinkWants());
+  }
+  SetAudioControl();
+}
+
+void SimplePeerConnection::AddStreams(bool audio_only) {
+  if (active_streams_.find(kStreamId) != active_streams_.end())
+    return;  // Already added.
+
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+      g_peer_connection_factory->CreateLocalMediaStream(kStreamId);
+
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+      g_peer_connection_factory->CreateAudioTrack(
+          kAudioLabel,
+          g_peer_connection_factory->CreateAudioSource(cricket::AudioOptions())
+              .get()));
+  stream->AddTrack(audio_track);
+
+  if (!audio_only) {
+#if defined(WEBRTC_ANDROID)
+    JNIEnv* env = webrtc::jni::GetEnv();
+    jclass pc_factory_class =
+        unity_plugin::FindClass(env, "org/webrtc/UnityUtility");
+    jmethodID load_texture_helper_method = webrtc::GetStaticMethodID(
+        env, pc_factory_class, "LoadSurfaceTextureHelper",
+        "()Lorg/webrtc/SurfaceTextureHelper;");
+    jobject texture_helper = env->CallStaticObjectMethod(
+        pc_factory_class, load_texture_helper_method);
+    CHECK_EXCEPTION(env);
+    RTC_DCHECK(texture_helper != nullptr)
+        << "Cannot get the Surface Texture Helper.";
+
+    auto source = rtc::make_ref_counted<webrtc::jni::AndroidVideoTrackSource>(
+        g_signaling_thread.get(), env, /*is_screencast=*/false,
+        /*align_timestamps=*/true);
+
+    // link with VideoCapturer (Camera);
+    jmethodID link_camera_method = webrtc::GetStaticMethodID(
+        env, pc_factory_class, "LinkCamera",
+        "(JLorg/webrtc/SurfaceTextureHelper;)Lorg/webrtc/VideoCapturer;");
+    jobject camera_tmp =
+        env->CallStaticObjectMethod(pc_factory_class, link_camera_method,
+                                    (jlong)source.get(), texture_helper);
+    CHECK_EXCEPTION(env);
+    g_camera = (jobject)env->NewGlobalRef(camera_tmp);
+
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+        g_peer_connection_factory->CreateVideoTrack(kVideoLabel,
+                                                    source.release()));
+    stream->AddTrack(video_track);
+#else
+    rtc::scoped_refptr<CapturerTrackSource> video_device =
+        CapturerTrackSource::Create();
+    if (video_device) {
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+          g_peer_connection_factory->CreateVideoTrack(kVideoLabel,
+                                                      video_device.get()));
+
+      stream->AddTrack(video_track);
+    }
+#endif
+    if (local_video_observer_ && !stream->GetVideoTracks().empty()) {
+      stream->GetVideoTracks()[0]->AddOrUpdateSink(local_video_observer_.get(),
+                                                   rtc::VideoSinkWants());
+    }
+  }
+
+  if (!peer_connection_->AddStream(stream.get())) {
+    RTC_LOG(LS_ERROR) << "Adding stream to PeerConnection failed";
+  }
+
+  typedef std::pair<std::string,
+                    rtc::scoped_refptr<webrtc::MediaStreamInterface>>
+      MediaStreamPair;
+  active_streams_.insert(MediaStreamPair(stream->id(), stream));
+}
+
+bool SimplePeerConnection::CreateDataChannel() {
+  struct webrtc::DataChannelInit init;
+  init.ordered = true;
+  init.reliable = true;
+  auto result = peer_connection_->CreateDataChannelOrError("Hello", &init);
+  if (result.ok()) {
+    data_channel_ = result.MoveValue();
+    data_channel_->RegisterObserver(this);
+    RTC_LOG(LS_INFO) << "Succeeds to create data channel";
+    return true;
+  } else {
+    RTC_LOG(LS_INFO) << "Fails to create data channel";
+    return false;
+  }
+}
+
+void SimplePeerConnection::CloseDataChannel() {
+  if (data_channel_.get()) {
+    data_channel_->UnregisterObserver();
+    data_channel_->Close();
+  }
+  data_channel_ = nullptr;
+}
+
+bool SimplePeerConnection::SendDataViaDataChannel(const std::string& data) {
+  if (!data_channel_.get()) {
+    RTC_LOG(LS_INFO) << "Data channel is not established";
+    return false;
+  }
+  webrtc::DataBuffer buffer(data);
+  data_channel_->Send(buffer);
+  return true;
+}
+
+// Peerconnection observer
+void SimplePeerConnection::OnDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
+  channel->RegisterObserver(this);
+}
+
+void SimplePeerConnection::OnStateChange() {
+  if (data_channel_) {
+    webrtc::DataChannelInterface::DataState state = data_channel_->state();
+    if (state == webrtc::DataChannelInterface::kOpen) {
+      if (OnLocalDataChannelReady)
+        OnLocalDataChannelReady();
+      RTC_LOG(LS_INFO) << "Data channel is open";
+    }
+  }
+}
+
+//  A data buffer was successfully received.
+void SimplePeerConnection::OnMessage(const webrtc::DataBuffer& buffer) {
+  size_t size = buffer.data.size();
+  char* msg = new char[size + 1];
+  memcpy(msg, buffer.data.data(), size);
+  msg[size] = 0;
+  if (OnDataFromDataChannelReady)
+    OnDataFromDataChannelReady(msg);
+  delete[] msg;
+}
+
+// AudioTrackSinkInterface implementation.
+void SimplePeerConnection::OnData(const void* audio_data,
+                                  int bits_per_sample,
+                                  int sample_rate,
+                                  size_t number_of_channels,
+                                  size_t number_of_frames) {
+  if (OnAudioReady)
+    OnAudioReady(audio_data, bits_per_sample, sample_rate,
+                 static_cast<int>(number_of_channels),
+                 static_cast<int>(number_of_frames));
+}
+
+std::vector<uint32_t> SimplePeerConnection::GetRemoteAudioTrackSsrcs() {
+  std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>> receivers =
+      peer_connection_->GetReceivers();
+
+  std::vector<uint32_t> ssrcs;
+  for (const auto& receiver : receivers) {
+    if (receiver->media_type() != cricket::MEDIA_TYPE_AUDIO)
+      continue;
+
+    std::vector<webrtc::RtpEncodingParameters> params =
+        receiver->GetParameters().encodings;
+
+    for (const auto& param : params) {
+      uint32_t ssrc = param.ssrc.value_or(0);
+      if (ssrc > 0)
+        ssrcs.push_back(ssrc);
+    }
+  }
+
+  return ssrcs;
+}
diff --git a/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.h b/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.h
new file mode 100644
index 0000000000..de652ef118
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/simple_peer_connection.h
@@ -0,0 +1,135 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#ifndef EXAMPLES_UNITYPLUGIN_SIMPLE_PEER_CONNECTION_H_
+#define EXAMPLES_UNITYPLUGIN_SIMPLE_PEER_CONNECTION_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "api/data_channel_interface.h"
+#include "api/media_stream_interface.h"
+#include "api/peer_connection_interface.h"
+#include "examples/unityplugin/unity_plugin_apis.h"
+#include "examples/unityplugin/video_observer.h"
+
+class SimplePeerConnection : public webrtc::PeerConnectionObserver,
+                             public webrtc::CreateSessionDescriptionObserver,
+                             public webrtc::DataChannelObserver,
+                             public webrtc::AudioTrackSinkInterface {
+ public:
+  SimplePeerConnection() {}
+  ~SimplePeerConnection() {}
+
+  bool InitializePeerConnection(const char** turn_urls,
+                                int no_of_urls,
+                                const char* username,
+                                const char* credential,
+                                bool is_receiver);
+  void DeletePeerConnection();
+  void AddStreams(bool audio_only);
+  bool CreateDataChannel();
+  bool CreateOffer();
+  bool CreateAnswer();
+  bool SendDataViaDataChannel(const std::string& data);
+  void SetAudioControl(bool is_mute, bool is_record);
+
+  // Register callback functions.
+  void RegisterOnLocalI420FrameReady(I420FRAMEREADY_CALLBACK callback);
+  void RegisterOnRemoteI420FrameReady(I420FRAMEREADY_CALLBACK callback);
+  void RegisterOnLocalDataChannelReady(LOCALDATACHANNELREADY_CALLBACK callback);
+  void RegisterOnDataFromDataChannelReady(
+      DATAFROMEDATECHANNELREADY_CALLBACK callback);
+  void RegisterOnFailure(FAILURE_CALLBACK callback);
+  void RegisterOnAudioBusReady(AUDIOBUSREADY_CALLBACK callback);
+  void RegisterOnLocalSdpReadytoSend(LOCALSDPREADYTOSEND_CALLBACK callback);
+  void RegisterOnIceCandidateReadytoSend(
+      ICECANDIDATEREADYTOSEND_CALLBACK callback);
+  bool SetRemoteDescription(const char* type, const char* sdp);
+  bool AddIceCandidate(const char* sdp,
+                       int sdp_mlineindex,
+                       const char* sdp_mid);
+
+ protected:
+  // create a peerconneciton and add the turn servers info to the configuration.
+  bool CreatePeerConnection(const char** turn_urls,
+                            int no_of_urls,
+                            const char* username,
+                            const char* credential);
+  void CloseDataChannel();
+  void SetAudioControl();
+
+  // PeerConnectionObserver implementation.
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override {}
+  void OnAddStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+  void OnRemoveStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
+  void OnDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> channel) override;
+  void OnRenegotiationNeeded() override {}
+  void OnIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {}
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {}
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
+  void OnIceConnectionReceivingChange(bool receiving) override {}
+
+  // CreateSessionDescriptionObserver implementation.
+  void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
+  void OnFailure(webrtc::RTCError error) override;
+
+  // DataChannelObserver implementation.
+  void OnStateChange() override;
+  void OnMessage(const webrtc::DataBuffer& buffer) override;
+
+  // AudioTrackSinkInterface implementation.
+  void OnData(const void* audio_data,
+              int bits_per_sample,
+              int sample_rate,
+              size_t number_of_channels,
+              size_t number_of_frames) override;
+
+  // Get remote audio tracks ssrcs.
+  std::vector<uint32_t> GetRemoteAudioTrackSsrcs();
+
+ private:
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel_;
+  std::map<std::string, rtc::scoped_refptr<webrtc::MediaStreamInterface> >
+      active_streams_;
+
+  std::unique_ptr<VideoObserver> local_video_observer_;
+  std::unique_ptr<VideoObserver> remote_video_observer_;
+
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream_ = nullptr;
+  webrtc::PeerConnectionInterface::RTCConfiguration config_;
+
+  LOCALDATACHANNELREADY_CALLBACK OnLocalDataChannelReady = nullptr;
+  DATAFROMEDATECHANNELREADY_CALLBACK OnDataFromDataChannelReady = nullptr;
+  FAILURE_CALLBACK OnFailureMessage = nullptr;
+  AUDIOBUSREADY_CALLBACK OnAudioReady = nullptr;
+
+  LOCALSDPREADYTOSEND_CALLBACK OnLocalSdpReady = nullptr;
+  ICECANDIDATEREADYTOSEND_CALLBACK OnIceCandidateReady = nullptr;
+
+  bool is_mute_audio_ = false;
+  bool is_record_audio_ = false;
+  bool mandatory_receive_ = false;
+
+  // disallow copy-and-assign
+  SimplePeerConnection(const SimplePeerConnection&) = delete;
+  SimplePeerConnection& operator=(const SimplePeerConnection&) = delete;
+};
+
+#endif  // EXAMPLES_UNITYPLUGIN_SIMPLE_PEER_CONNECTION_H_
diff --git a/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.cc b/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.cc
new file mode 100644
index 0000000000..6e34d7e1e0
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.cc
@@ -0,0 +1,196 @@
+/*
+ *  Copyright (c) 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 "examples/unityplugin/unity_plugin_apis.h"
+
+#include <map>
+#include <string>
+
+#include "examples/unityplugin/simple_peer_connection.h"
+
+namespace {
+static int g_peer_connection_id = 1;
+static std::map<int, rtc::scoped_refptr<SimplePeerConnection>>
+    g_peer_connection_map;
+}  // namespace
+
+int CreatePeerConnection(const char** turn_urls,
+                         const int no_of_urls,
+                         const char* username,
+                         const char* credential,
+                         bool mandatory_receive_video) {
+  g_peer_connection_map[g_peer_connection_id] =
+      rtc::make_ref_counted<SimplePeerConnection>();
+
+  if (!g_peer_connection_map[g_peer_connection_id]->InitializePeerConnection(
+          turn_urls, no_of_urls, username, credential, mandatory_receive_video))
+    return -1;
+
+  return g_peer_connection_id++;
+}
+
+bool ClosePeerConnection(int peer_connection_id) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->DeletePeerConnection();
+  g_peer_connection_map.erase(peer_connection_id);
+  return true;
+}
+
+bool AddStream(int peer_connection_id, bool audio_only) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->AddStreams(audio_only);
+  return true;
+}
+
+bool AddDataChannel(int peer_connection_id) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  return g_peer_connection_map[peer_connection_id]->CreateDataChannel();
+}
+
+bool CreateOffer(int peer_connection_id) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  return g_peer_connection_map[peer_connection_id]->CreateOffer();
+}
+
+bool CreateAnswer(int peer_connection_id) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  return g_peer_connection_map[peer_connection_id]->CreateAnswer();
+}
+
+bool SendDataViaDataChannel(int peer_connection_id, const char* data) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  std::string s(data);
+  g_peer_connection_map[peer_connection_id]->SendDataViaDataChannel(s);
+
+  return true;
+}
+
+bool SetAudioControl(int peer_connection_id, bool is_mute, bool is_record) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->SetAudioControl(is_mute,
+                                                             is_record);
+  return true;
+}
+
+bool SetRemoteDescription(int peer_connection_id,
+                          const char* type,
+                          const char* sdp) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  return g_peer_connection_map[peer_connection_id]->SetRemoteDescription(type,
+                                                                         sdp);
+}
+
+bool AddIceCandidate(const int peer_connection_id,
+                     const char* candidate,
+                     const int sdp_mlineindex,
+                     const char* sdp_mid) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  return g_peer_connection_map[peer_connection_id]->AddIceCandidate(
+      candidate, sdp_mlineindex, sdp_mid);
+}
+
+// Register callback functions.
+bool RegisterOnLocalI420FrameReady(int peer_connection_id,
+                                   I420FRAMEREADY_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnLocalI420FrameReady(
+      callback);
+  return true;
+}
+
+bool RegisterOnRemoteI420FrameReady(int peer_connection_id,
+                                    I420FRAMEREADY_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnRemoteI420FrameReady(
+      callback);
+  return true;
+}
+
+bool RegisterOnLocalDataChannelReady(int peer_connection_id,
+                                     LOCALDATACHANNELREADY_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnLocalDataChannelReady(
+      callback);
+  return true;
+}
+
+bool RegisterOnDataFromDataChannelReady(
+    int peer_connection_id,
+    DATAFROMEDATECHANNELREADY_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnDataFromDataChannelReady(
+      callback);
+  return true;
+}
+
+bool RegisterOnFailure(int peer_connection_id, FAILURE_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnFailure(callback);
+  return true;
+}
+
+bool RegisterOnAudioBusReady(int peer_connection_id,
+                             AUDIOBUSREADY_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnAudioBusReady(callback);
+  return true;
+}
+
+// Singnaling channel related functions.
+bool RegisterOnLocalSdpReadytoSend(int peer_connection_id,
+                                   LOCALSDPREADYTOSEND_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnLocalSdpReadytoSend(
+      callback);
+  return true;
+}
+
+bool RegisterOnIceCandidateReadytoSend(
+    int peer_connection_id,
+    ICECANDIDATEREADYTOSEND_CALLBACK callback) {
+  if (!g_peer_connection_map.count(peer_connection_id))
+    return false;
+
+  g_peer_connection_map[peer_connection_id]->RegisterOnIceCandidateReadytoSend(
+      callback);
+  return true;
+}
diff --git a/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.h b/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.h
new file mode 100644
index 0000000000..9790dc57b9
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/unity_plugin_apis.h
@@ -0,0 +1,108 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+// This file provides an example of unity native plugin APIs.
+
+#ifndef EXAMPLES_UNITYPLUGIN_UNITY_PLUGIN_APIS_H_
+#define EXAMPLES_UNITYPLUGIN_UNITY_PLUGIN_APIS_H_
+
+#include <stdint.h>
+
+// Definitions of callback functions.
+typedef void (*I420FRAMEREADY_CALLBACK)(const uint8_t* data_y,
+                                        const uint8_t* data_u,
+                                        const uint8_t* data_v,
+                                        const uint8_t* data_a,
+                                        int stride_y,
+                                        int stride_u,
+                                        int stride_v,
+                                        int stride_a,
+                                        uint32_t width,
+                                        uint32_t height);
+typedef void (*LOCALDATACHANNELREADY_CALLBACK)();
+typedef void (*DATAFROMEDATECHANNELREADY_CALLBACK)(const char* msg);
+typedef void (*FAILURE_CALLBACK)(const char* msg);
+typedef void (*LOCALSDPREADYTOSEND_CALLBACK)(const char* type, const char* sdp);
+typedef void (*ICECANDIDATEREADYTOSEND_CALLBACK)(const char* candidate,
+                                                 int sdp_mline_index,
+                                                 const char* sdp_mid);
+typedef void (*AUDIOBUSREADY_CALLBACK)(const void* audio_data,
+                                       int bits_per_sample,
+                                       int sample_rate,
+                                       int number_of_channels,
+                                       int number_of_frames);
+
+#if defined(WEBRTC_WIN)
+#define WEBRTC_PLUGIN_API __declspec(dllexport)
+#elif defined(WEBRTC_ANDROID)
+#define WEBRTC_PLUGIN_API __attribute__((visibility("default")))
+#endif
+extern "C" {
+// Create a peerconnection and return a unique peer connection id.
+WEBRTC_PLUGIN_API int CreatePeerConnection(const char** turn_urls,
+                                           int no_of_urls,
+                                           const char* username,
+                                           const char* credential,
+                                           bool mandatory_receive_video);
+// Close a peerconnection.
+WEBRTC_PLUGIN_API bool ClosePeerConnection(int peer_connection_id);
+// Add a audio stream. If audio_only is true, the stream only has an audio
+// track and no video track.
+WEBRTC_PLUGIN_API bool AddStream(int peer_connection_id, bool audio_only);
+// Add a data channel to peer connection.
+WEBRTC_PLUGIN_API bool AddDataChannel(int peer_connection_id);
+// Create a peer connection offer.
+WEBRTC_PLUGIN_API bool CreateOffer(int peer_connection_id);
+// Create a peer connection answer.
+WEBRTC_PLUGIN_API bool CreateAnswer(int peer_connection_id);
+// Send data through data channel.
+WEBRTC_PLUGIN_API bool SendDataViaDataChannel(int peer_connection_id,
+                                              const char* data);
+// Set audio control. If is_mute=true, no audio will playout. If is_record=true,
+// AUDIOBUSREADY_CALLBACK will be called every 10 ms.
+WEBRTC_PLUGIN_API bool SetAudioControl(int peer_connection_id,
+                                       bool is_mute,
+                                       bool is_record);
+// Set remote sdp.
+WEBRTC_PLUGIN_API bool SetRemoteDescription(int peer_connection_id,
+                                            const char* type,
+                                            const char* sdp);
+// Add ice candidate.
+WEBRTC_PLUGIN_API bool AddIceCandidate(int peer_connection_id,
+                                       const char* candidate,
+                                       int sdp_mlineindex,
+                                       const char* sdp_mid);
+
+// Register callback functions.
+WEBRTC_PLUGIN_API bool RegisterOnLocalI420FrameReady(
+    int peer_connection_id,
+    I420FRAMEREADY_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnRemoteI420FrameReady(
+    int peer_connection_id,
+    I420FRAMEREADY_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnLocalDataChannelReady(
+    int peer_connection_id,
+    LOCALDATACHANNELREADY_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnDataFromDataChannelReady(
+    int peer_connection_id,
+    DATAFROMEDATECHANNELREADY_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnFailure(int peer_connection_id,
+                                         FAILURE_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnAudioBusReady(int peer_connection_id,
+                                               AUDIOBUSREADY_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnLocalSdpReadytoSend(
+    int peer_connection_id,
+    LOCALSDPREADYTOSEND_CALLBACK callback);
+WEBRTC_PLUGIN_API bool RegisterOnIceCandidateReadytoSend(
+    int peer_connection_id,
+    ICECANDIDATEREADYTOSEND_CALLBACK callback);
+}
+
+#endif  // EXAMPLES_UNITYPLUGIN_UNITY_PLUGIN_APIS_H_
diff --git a/third_party/libwebrtc/examples/unityplugin/video_observer.cc b/third_party/libwebrtc/examples/unityplugin/video_observer.cc
new file mode 100644
index 0000000000..7e33b08e27
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/video_observer.cc
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 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 "examples/unityplugin/video_observer.h"
+
+void VideoObserver::SetVideoCallback(I420FRAMEREADY_CALLBACK callback) {
+  std::lock_guard<std::mutex> lock(mutex);
+  OnI420FrameReady = callback;
+}
+
+void VideoObserver::OnFrame(const webrtc::VideoFrame& frame) {
+  std::unique_lock<std::mutex> lock(mutex);
+  if (!OnI420FrameReady)
+    return;
+
+  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+      frame.video_frame_buffer());
+
+  if (buffer->type() != webrtc::VideoFrameBuffer::Type::kI420A) {
+    rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =
+        buffer->ToI420();
+    OnI420FrameReady(i420_buffer->DataY(), i420_buffer->DataU(),
+                     i420_buffer->DataV(), nullptr, i420_buffer->StrideY(),
+                     i420_buffer->StrideU(), i420_buffer->StrideV(), 0,
+                     frame.width(), frame.height());
+
+  } else {
+    // The buffer has alpha channel.
+    const webrtc::I420ABufferInterface* i420a_buffer = buffer->GetI420A();
+
+    OnI420FrameReady(i420a_buffer->DataY(), i420a_buffer->DataU(),
+                     i420a_buffer->DataV(), i420a_buffer->DataA(),
+                     i420a_buffer->StrideY(), i420a_buffer->StrideU(),
+                     i420a_buffer->StrideV(), i420a_buffer->StrideA(),
+                     frame.width(), frame.height());
+  }
+}
diff --git a/third_party/libwebrtc/examples/unityplugin/video_observer.h b/third_party/libwebrtc/examples/unityplugin/video_observer.h
new file mode 100644
index 0000000000..01ccd2191a
--- /dev/null
+++ b/third_party/libwebrtc/examples/unityplugin/video_observer.h
@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#ifndef EXAMPLES_UNITYPLUGIN_VIDEO_OBSERVER_H_
+#define EXAMPLES_UNITYPLUGIN_VIDEO_OBSERVER_H_
+
+#include <mutex>
+
+#include "api/media_stream_interface.h"
+#include "api/video/video_sink_interface.h"
+#include "examples/unityplugin/unity_plugin_apis.h"
+
+class VideoObserver : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+ public:
+  VideoObserver() {}
+  ~VideoObserver() {}
+  void SetVideoCallback(I420FRAMEREADY_CALLBACK callback);
+
+ protected:
+  // VideoSinkInterface implementation
+  void OnFrame(const webrtc::VideoFrame& frame) override;
+
+ private:
+  I420FRAMEREADY_CALLBACK OnI420FrameReady = nullptr;
+  std::mutex mutex;
+};
+
+#endif  // EXAMPLES_UNITYPLUGIN_VIDEO_OBSERVER_H_