Add a 'remote' property to MediaSourceInterface. Also adding an implementation to the relevant sour…

talk/app/webrtc/audiotrack.cc

Index: talk/app/webrtc/audiotrack.cc
diff --git a/talk/app/webrtc/audiotrack.cc b/talk/app/webrtc/audiotrack.cc
index 63bd87cb4176c0c41e629d66aa45057385fdabc9..9660c30020c378658acc18d89fc640a7414638aa 100644
--- a/talk/app/webrtc/audiotrack.cc
+++ b/talk/app/webrtc/audiotrack.cc
@@ -27,27 +27,78 @@
 
 #include "talk/app/webrtc/audiotrack.h"
 
-#include <string>
+#include "webrtc/base/checks.h"
+
+using rtc::scoped_refptr;
 
 namespace webrtc {
 
 const char MediaStreamTrackInterface::kAudioKind[] = "audio";
 
+// static
+scoped_refptr<AudioTrack> AudioTrack::Create(
+    const std::string& id,
+    const scoped_refptr<AudioSourceInterface>& source) {
+  return new rtc::RefCountedObject<AudioTrack>(id, source);
+}
+
 AudioTrack::AudioTrack(const std::string& label,
-                       AudioSourceInterface* audio_source)
-    : MediaStreamTrack<AudioTrackInterface>(label),
-      audio_source_(audio_source) {
+                       const scoped_refptr<AudioSourceInterface>& source)
+    : MediaStreamTrack<AudioTrackInterface>(label), audio_source_(source) {
+  if (audio_source_) {
+    audio_source_->RegisterObserver(this);
+    TrackState new_state = kInitializing;
+    switch (audio_source_->state()) {
+      case MediaSourceInterface::kLive:
+      case MediaSourceInterface::kMuted:
+        new_state = kLive;
+        break;
+      case MediaSourceInterface::kEnded:
+        new_state = kEnded;
+        break;
+      case MediaSourceInterface::kInitializing:
+      default:
+        // kInitializing;
+        break;
+    }
+    set_state(new_state);
+  }
+}
+
+AudioTrack::~AudioTrack() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  set_state(MediaStreamTrackInterface::kEnded);
+  if (audio_source_)
+    audio_source_->UnregisterObserver(this);
 }
 
 std::string AudioTrack::kind() const {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return kAudioKind;
 }
 
-rtc::scoped_refptr<AudioTrack> AudioTrack::Create(
-    const std::string& id, AudioSourceInterface* source) {
-  rtc::RefCountedObject<AudioTrack>* track =
-      new rtc::RefCountedObject<AudioTrack>(id, source);
-  return track;
+AudioSourceInterface* AudioTrack::GetSource() const {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  return audio_source_.get();
+}
+
+void AudioTrack::AddSink(AudioTrackSinkInterface* sink) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (audio_source_)
+    audio_source_->AddSink(sink);
+}
+
+void AudioTrack::RemoveSink(AudioTrackSinkInterface* sink) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (audio_source_)
+    audio_source_->RemoveSink(sink);
+}
+
+void AudioTrack::OnChanged() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  // |audio_source_| must be non-null if we ever get here.
+  if (audio_source_->state() == MediaSourceInterface::kEnded)

[perkj_webrtc, 2015/12/15 10:15:31]

Should we allow the track to change to live again? 
I know the spec does not allow it but I think that we do it with video on
Android when we start the camera and later stop it if the user jumps to another
app. When you jump back to the application, the source is restarted instead of
recreated.

[tommi, 2015/12/15 11:00:54]

Interesting. OK, moved the switch() statement in the ctor to here and call
OnChanged from the constructor.  The only state that we can't "recover" a track
from will be kFailed.

+    set_state(MediaStreamTrackInterface::kEnded);
 }
 
 }  // namespace webrtc