WebRtcMediaStreamTrackAdapter, maps 1 webrtc and 1 blink track

content/renderer/media/remote_media_stream_track_adapter.cc

Index: content/renderer/media/remote_media_stream_track_adapter.cc
diff --git a/content/renderer/media/remote_media_stream_track_adapter.cc b/content/renderer/media/remote_media_stream_track_adapter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..540c1f02eb0c5fd98bffc9abbcea9e752551106c
--- /dev/null
+++ b/content/renderer/media/remote_media_stream_track_adapter.cc
@@ -0,0 +1,119 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/renderer/media/remote_media_stream_track_adapter.h"
+
+#include "content/renderer/media/media_stream_audio_source.h"
+#include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/webrtc/media_stream_remote_video_source.h"
+#include "content/renderer/media/webrtc/peer_connection_remote_audio_source.h"
+#include "content/renderer/media/webrtc/track_observer.h"
+
+namespace content {
+
+RemoteVideoTrackAdapter::RemoteVideoTrackAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
+    webrtc::VideoTrackInterface* webrtc_track)
+    : RemoteMediaStreamTrackAdapter(main_thread, webrtc_track) {
+  std::unique_ptr<TrackObserver> observer(
+      new TrackObserver(main_thread, observed_track().get()));
+  // Here, we use base::Unretained() to avoid a circular reference.
+  web_initialize_ = base::Bind(
+      &RemoteVideoTrackAdapter::InitializeWebVideoTrack, base::Unretained(this),
+      base::Passed(&observer), observed_track()->enabled());
+}
+
+RemoteVideoTrackAdapter::~RemoteVideoTrackAdapter() {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  if (initialized()) {
+    static_cast<MediaStreamRemoteVideoSource*>(
+        web_track()->Source().GetExtraData())
+        ->OnSourceTerminated();
+  }
+}
+
+void RemoteVideoTrackAdapter::InitializeWebVideoTrack(
+    std::unique_ptr<TrackObserver> observer,
+    bool enabled) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  std::unique_ptr<MediaStreamRemoteVideoSource> video_source(
+      new MediaStreamRemoteVideoSource(std::move(observer)));
+  InitializeWebTrack(blink::WebMediaStreamSource::kTypeVideo);
+  web_track()->Source().SetExtraData(video_source.get());
+  MediaStreamVideoTrack* media_stream_track = new MediaStreamVideoTrack(
+      video_source.release(), MediaStreamVideoSource::ConstraintsCallback(),
+      enabled);
+  web_track()->SetTrackData(media_stream_track);
+}
+
+RemoteAudioTrackAdapter::RemoteAudioTrackAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
+    webrtc::AudioTrackInterface* webrtc_track)
+    : RemoteMediaStreamTrackAdapter(main_thread, webrtc_track),
+#if DCHECK_IS_ON()
+      unregistered_(false),
+#endif
+      state_(observed_track()->state()) {
+  // TODO(tommi): Use TrackObserver instead.
+  observed_track()->RegisterObserver(this);
+  // Here, we use base::Unretained() to avoid a circular reference.
+  web_initialize_ =
+      base::Bind(&RemoteAudioTrackAdapter::InitializeWebAudioTrack,
+                 base::Unretained(this));
+}
+
+RemoteAudioTrackAdapter::~RemoteAudioTrackAdapter() {
+#if DCHECK_IS_ON()
+  DCHECK(unregistered_);
+#endif
+}
+
+void RemoteAudioTrackAdapter::Unregister() {
+#if DCHECK_IS_ON()
+  DCHECK(!unregistered_);
+  unregistered_ = true;
+#endif
+  observed_track()->UnregisterObserver(this);
+}
+
+void RemoteAudioTrackAdapter::InitializeWebAudioTrack() {
+  InitializeWebTrack(blink::WebMediaStreamSource::kTypeAudio);
+
+  MediaStreamAudioSource* const source =
+      new PeerConnectionRemoteAudioSource(observed_track().get());
+  web_track()->Source().SetExtraData(source);  // Takes ownership.
+  source->ConnectToTrack(*(web_track()));
+}
+
+void RemoteAudioTrackAdapter::OnChanged() {
+  main_thread_->PostTask(
+      FROM_HERE, base::Bind(&RemoteAudioTrackAdapter::OnChangedOnMainThread,
+                            this, observed_track()->state()));
+}
+
+void RemoteAudioTrackAdapter::OnChangedOnMainThread(
+    webrtc::MediaStreamTrackInterface::TrackState state) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+
+  if (state == state_ || !initialized())
+    return;
+
+  state_ = state;
+
+  switch (state) {
+    case webrtc::MediaStreamTrackInterface::kLive:
+      web_track()->Source().SetReadyState(
+          blink::WebMediaStreamSource::kReadyStateLive);
+      break;
+    case webrtc::MediaStreamTrackInterface::kEnded:
+      web_track()->Source().SetReadyState(
+          blink::WebMediaStreamSource::kReadyStateEnded);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+}  // namespace content