WebRtcMediaStreamTrackAdapter, maps 1 webrtc and 1 blink track

content/renderer/media/remote_media_stream_impl.cc

 // Copyright (c) 2013 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_impl.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/remote_media_stream_track_adapter.h"

[hbos_chromium, 2017/05/18 11:41:51]

RemoteMediaStreamTrackAdapter, RemoteVideoTrackAdapter and
RemoteVideoTrackAdapter are moved into
content/renderer/media/remote_media_stream_track_adapter.[h/cc].

 #include "content/renderer/media/webrtc/media_stream_remote_video_source.h"
-#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
-#include "content/renderer/media/webrtc/peer_connection_remote_audio_source.h"
-#include "content/renderer/media/webrtc/track_observer.h"
-#include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 namespace {
 
 template <typename WebRtcTrackVector, typename AdapterType>
 void CreateAdaptersForTracks(
     const WebRtcTrackVector& tracks,
     std::vector<scoped_refptr<AdapterType>>* observers,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread) {
   for (auto& track : tracks)
     observers->push_back(new AdapterType(main_thread, track));
 }
 
 template<typename VectorType>
 bool IsTrackInVector(const VectorType& v, const std::string& id) {
   for (const auto& t : v) {
     if (t->id() == id)
       return true;
   }
   return false;
 }
 }  // namespace
 
-// Base class used for mapping between webrtc and blink MediaStream tracks.
-// An instance of a RemoteMediaStreamTrackAdapter is stored in
-// RemoteMediaStreamImpl per remote audio and video track.
-template<typename WebRtcMediaStreamTrackType>
-class RemoteMediaStreamTrackAdapter
-    : public base::RefCountedThreadSafe<
-          RemoteMediaStreamTrackAdapter<WebRtcMediaStreamTrackType>> {
- public:
-  RemoteMediaStreamTrackAdapter(
-      const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
-      WebRtcMediaStreamTrackType* webrtc_track)
-      : main_thread_(main_thread), webrtc_track_(webrtc_track),
-        id_(webrtc_track->id()) {
-  }
-
-  const scoped_refptr<WebRtcMediaStreamTrackType>& observed_track() {
-    return webrtc_track_;
-  }
-
-  blink::WebMediaStreamTrack* webkit_track() {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    DCHECK(!webkit_track_.IsNull());
-    return &webkit_track_;
-  }
-
-  const std::string& id() const { return id_; }
-
-  bool initialized() const {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    return !webkit_track_.IsNull();
-  }
-
-  void Initialize() {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    DCHECK(!initialized());
-    webkit_initialize_.Run();
-    webkit_initialize_.Reset();
-    DCHECK(initialized());
-  }
-
- protected:
-  friend class base::RefCountedThreadSafe<
-      RemoteMediaStreamTrackAdapter<WebRtcMediaStreamTrackType>>;
-
-  virtual ~RemoteMediaStreamTrackAdapter() {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-  }
-
-  void InitializeWebkitTrack(blink::WebMediaStreamSource::Type type) {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    DCHECK(webkit_track_.IsNull());
-
-    blink::WebString webkit_track_id(blink::WebString::FromUTF8(id_));
-    blink::WebMediaStreamSource webkit_source;
-    webkit_source.Initialize(webkit_track_id, type, webkit_track_id,
-                             true /* remote */);
-    webkit_track_.Initialize(webkit_track_id, webkit_source);
-    DCHECK(!webkit_track_.IsNull());
-  }
-
-  const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
-  // This callback will be run when Initialize() is called and then freed.
-  // The callback is used by derived classes to bind objects that need to be
-  // instantiated and initialized on the signaling thread but then moved to
-  // and used on the main thread when initializing the webkit object(s).
-  base::Callback<void()> webkit_initialize_;
-
- private:
-  const scoped_refptr<WebRtcMediaStreamTrackType> webrtc_track_;
-  blink::WebMediaStreamTrack webkit_track_;
-  // const copy of the webrtc track id that allows us to check it from both the
-  // main and signaling threads without incurring a synchronous thread hop.
-  const std::string id_;
-
-  DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackAdapter);
-};
-
-class RemoteVideoTrackAdapter
-    : public RemoteMediaStreamTrackAdapter<webrtc::VideoTrackInterface> {
- public:
-  // Called on the signaling thread
-  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.
-    webkit_initialize_ = base::Bind(
-        &RemoteVideoTrackAdapter::InitializeWebkitVideoTrack,
-        base::Unretained(this), base::Passed(&observer),
-        observed_track()->enabled());
-  }
-
- protected:
-  ~RemoteVideoTrackAdapter() override {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    if (initialized()) {
-      static_cast<MediaStreamRemoteVideoSource*>(
-          webkit_track()->Source().GetExtraData())
-          ->OnSourceTerminated();
-    }
-  }
-
- private:
-  void InitializeWebkitVideoTrack(std::unique_ptr<TrackObserver> observer,
-                                  bool enabled) {
-    DCHECK(main_thread_->BelongsToCurrentThread());
-    std::unique_ptr<MediaStreamRemoteVideoSource> video_source(
-        new MediaStreamRemoteVideoSource(std::move(observer)));
-    InitializeWebkitTrack(blink::WebMediaStreamSource::kTypeVideo);
-    webkit_track()->Source().SetExtraData(video_source.get());
-    MediaStreamVideoTrack* media_stream_track = new MediaStreamVideoTrack(
-        video_source.release(), MediaStreamVideoSource::ConstraintsCallback(),
-        enabled);
-    webkit_track()->SetTrackData(media_stream_track);
-  }
-};
-
-// RemoteAudioTrackAdapter is responsible for listening on state
-// change notifications on a remote webrtc audio MediaStreamTracks and notify
-// WebKit.
-class RemoteAudioTrackAdapter
-    : public RemoteMediaStreamTrackAdapter<webrtc::AudioTrackInterface>,
-      public webrtc::ObserverInterface {
- public:
-  RemoteAudioTrackAdapter(
-      const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
-      webrtc::AudioTrackInterface* webrtc_track);
-
-  void Unregister();
-
- protected:
-  ~RemoteAudioTrackAdapter() override;
-
- private:
-  void InitializeWebkitAudioTrack();
-
-  // webrtc::ObserverInterface implementation.
-  void OnChanged() override;
-
-  void OnChangedOnMainThread(
-      webrtc::MediaStreamTrackInterface::TrackState state);
-
-#if DCHECK_IS_ON()
-  bool unregistered_;
-#endif
-
-  webrtc::MediaStreamTrackInterface::TrackState state_;
-
-  DISALLOW_COPY_AND_ASSIGN(RemoteAudioTrackAdapter);
-};
-
-// Called on the signaling thread.
-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.
-  webkit_initialize_ =
-      base::Bind(&RemoteAudioTrackAdapter::InitializeWebkitAudioTrack,
-                 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::InitializeWebkitAudioTrack() {
-  InitializeWebkitTrack(blink::WebMediaStreamSource::kTypeAudio);
-
-  MediaStreamAudioSource* const source =
-      new PeerConnectionRemoteAudioSource(observed_track().get());
-  webkit_track()->Source().SetExtraData(source);  // Takes ownership.
-  source->ConnectToTrack(*(webkit_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:
-      webkit_track()->Source().SetReadyState(
-          blink::WebMediaStreamSource::kReadyStateLive);
-      break;
-    case webrtc::MediaStreamTrackInterface::kEnded:
-      webkit_track()->Source().SetReadyState(
-          blink::WebMediaStreamSource::kReadyStateEnded);
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
 RemoteMediaStreamImpl::Observer::Observer(
     const base::WeakPtr<RemoteMediaStreamImpl>& media_stream,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     webrtc::MediaStreamInterface* webrtc_stream)
     : media_stream_(media_stream),
       main_thread_(main_thread),
       webrtc_stream_(webrtc_stream) {
   webrtc_stream_->RegisterObserver(this);
 }
 
@@ skipping 135 matching lines @@
   // Unregister all the audio track observers that were not used.
   // We need to do this before destruction since the observers can't unregister
   // from within the dtor due to a race.
   for (auto& track : *audio_tracks.get()) {
     if (track.get())
       track->Unregister();
   }
 }
 
 }  // namespace content