Onion soup content/renderer/media/stream/remote_media_stream_track_adapter.cc|h

This is part of the 4.3 phase on the design document [1]. It prepares
ground for dependent mediastream classes to be Onion soup'ed.

[1] https://docs.google.com/document/d/1rHJGi1U72qZsOGIctIf7GKRaY8d7BgtVW8MaMYumzYY/edit

BUG=704136
R=guidou@chromium.org, haraken@chromium.org

Change-Id: Ib56eb8a4dc4c00f653d1a6b750eb526263b68976
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1672800
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#672132}

content/renderer/BUILD.gn

@@ -220,8 +220,6 @@ target(link_target_type, "renderer") {
     "media/stream/media_stream_renderer_factory_impl.h",
     "media/stream/processed_local_audio_source.cc",
     "media/stream/processed_local_audio_source.h",
-    "media/stream/remote_media_stream_track_adapter.cc",
-    "media/stream/remote_media_stream_track_adapter.h",
     "media/stream/track_audio_renderer.cc",
     "media/stream/track_audio_renderer.h",
     "media/stream/user_media_client_impl.cc",

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.cc

@@ -209,7 +209,8 @@ void WebRtcMediaStreamTrackAdapter::InitializeRemoteAudioTrack(
   DCHECK_EQ(webrtc_audio_track->kind(),
             webrtc::MediaStreamTrackInterface::kAudioKind);
   remote_audio_track_adapter_ =
-      new RemoteAudioTrackAdapter(main_thread_, webrtc_audio_track.get());
+      base::MakeRefCounted<blink::RemoteAudioTrackAdapter>(
+          main_thread_, webrtc_audio_track.get());
   webrtc_track_ = webrtc_audio_track;
   // Set the initial volume to zero. When the track is put in an audio tag for
   // playout, its volume is set to that of the tag. Without this, we could end
@@ -231,7 +232,8 @@ void WebRtcMediaStreamTrackAdapter::InitializeRemoteVideoTrack(
   DCHECK_EQ(webrtc_video_track->kind(),
             webrtc::MediaStreamTrackInterface::kVideoKind);
   remote_video_track_adapter_ =
-      new RemoteVideoTrackAdapter(main_thread_, webrtc_video_track.get());
+      base::MakeRefCounted<blink::RemoteVideoTrackAdapter>(
+          main_thread_, webrtc_video_track.get());
   webrtc_track_ = webrtc_video_track;
   remote_track_can_complete_initialization_.Signal();
   main_thread_->PostTask(

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.h

@@ -10,12 +10,12 @@
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/common/content_export.h"
-#include "content/renderer/media/stream/remote_media_stream_track_adapter.h"
 #include "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h"
 #include "content/renderer/media/webrtc/webrtc_audio_sink.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter.h"
 #include "third_party/blink/public/platform/web_media_stream.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
+#include "third_party/blink/public/web/modules/mediastream/remote_media_stream_track_adapter.h"
 #include "third_party/webrtc/api/media_stream_interface.h"
 
 namespace content {
@@ -70,10 +70,10 @@ class CONTENT_EXPORT WebRtcMediaStreamTrackAdapter
   MediaStreamVideoWebRtcSink* GetLocalTrackVideoSinkForTesting() {
     return local_track_video_sink_.get();
   }
-  RemoteAudioTrackAdapter* GetRemoteAudioTrackAdapterForTesting() {
+  blink::RemoteAudioTrackAdapter* GetRemoteAudioTrackAdapterForTesting() {
     return remote_audio_track_adapter_.get();
   }
-  RemoteVideoTrackAdapter* GetRemoteVideoTrackAdapterForTesting() {
+  blink::RemoteVideoTrackAdapter* GetRemoteVideoTrackAdapterForTesting() {
     return remote_video_track_adapter_.get();
   }
 
@@ -130,8 +130,8 @@ class CONTENT_EXPORT WebRtcMediaStreamTrackAdapter
   std::unique_ptr<MediaStreamVideoWebRtcSink> local_track_video_sink_;
   // If the track is remote, an adapter is used that listens to notifications on
   // the remote webrtc track and notifies Blink.
-  scoped_refptr<RemoteAudioTrackAdapter> remote_audio_track_adapter_;
-  scoped_refptr<RemoteVideoTrackAdapter> remote_video_track_adapter_;
+  scoped_refptr<blink::RemoteAudioTrackAdapter> remote_audio_track_adapter_;
+  scoped_refptr<blink::RemoteVideoTrackAdapter> remote_video_track_adapter_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcMediaStreamTrackAdapter);
 };

third_party/blink/public/BUILD.gn

@@ -374,6 +374,7 @@ source_set("blink_headers") {
     "web/modules/mediastream/media_stream_video_sink.h",
     "web/modules/mediastream/media_stream_video_source.h",
     "web/modules/mediastream/media_stream_video_track.h",
+    "web/modules/mediastream/remote_media_stream_track_adapter.h",
     "web/modules/mediastream/video_track_adapter_settings.h",
     "web/modules/mediastream/web_media_stream_utils.h",
     "web/modules/mediastream/webaudio_media_stream_audio_sink.h",

content/renderer/media/stream/remote_media_stream_track_adapter.h → third_party/blink/public/web/modules/mediastream/remote_media_stream_track_adapter.h

@@ -2,31 +2,34 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_MEDIA_STREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_
-#define CONTENT_RENDERER_MEDIA_STREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIASTREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_
+#define THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIASTREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_
 
-#include <string>
-
-#include "base/bind.h"
-#include "base/callback_forward.h"
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
+#include "third_party/blink/public/platform/web_common.h"
 #include "third_party/blink/public/platform/web_media_stream_source.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
+#include "third_party/blink/public/platform/web_string.h"
 #include "third_party/webrtc/api/media_stream_interface.h"
 
-namespace blink {
-class TrackObserver;
+namespace base {
+class SingleThreadTaskRunner;
 }
 
-namespace content {
+namespace blink {
+
+class TrackObserver;
 
 // Base class used for mapping between webrtc and blink MediaStream tracks.
 // RemoteMediaStreamImpl has a RemoteMediaStreamTrackAdapter per remote audio
 // (RemoteAudioTrackAdapter) and video (RemoteVideoTrackAdapter) track.
+//
+// TODO(crbug.com/704136): Move these classes out of the Blink exposed API
+// when all users of it have been Onion souped.
 template <typename WebRtcMediaStreamTrackType>
-class RemoteMediaStreamTrackAdapter
+class BLINK_MODULES_EXPORT RemoteMediaStreamTrackAdapter
     : public base::RefCountedThreadSafe<
           RemoteMediaStreamTrackAdapter<WebRtcMediaStreamTrackType>> {
  public:
@@ -35,19 +38,19 @@ class RemoteMediaStreamTrackAdapter
       WebRtcMediaStreamTrackType* webrtc_track)
       : main_thread_(main_thread),
         webrtc_track_(webrtc_track),
-        id_(webrtc_track->id()) {}
+        id_(WebString::FromUTF8(webrtc_track->id())) {}
 
   const scoped_refptr<WebRtcMediaStreamTrackType>& observed_track() {
     return webrtc_track_;
   }
 
-  blink::WebMediaStreamTrack* web_track() {
+  WebMediaStreamTrack* web_track() {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(!web_track_.IsNull());
     return &web_track_;
   }
 
-  const std::string& id() const { return id_; }
+  WebString id() const { return id_; }
 
   bool initialized() const {
     DCHECK(main_thread_->BelongsToCurrentThread());
@@ -57,8 +60,7 @@ class RemoteMediaStreamTrackAdapter
   void Initialize() {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(!initialized());
-    web_initialize_.Run();
-    web_initialize_.Reset();
+    std::move(web_initialize_).Run();
     DCHECK(initialized());
   }
 
@@ -70,14 +72,13 @@ class RemoteMediaStreamTrackAdapter
     DCHECK(main_thread_->BelongsToCurrentThread());
   }
 
-  void InitializeWebTrack(blink::WebMediaStreamSource::Type type) {
+  void InitializeWebTrack(WebMediaStreamSource::Type type) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(web_track_.IsNull());
 
-    blink::WebString web_track_id(blink::WebString::FromUTF8(id_));
-    blink::WebMediaStreamSource web_source;
-    web_source.Initialize(web_track_id, type, web_track_id, true /* remote */);
-    web_track_.Initialize(web_track_id, web_source);
+    WebMediaStreamSource web_source;
+    web_source.Initialize(id_, type, id_, true /* remote */);
+    web_track_.Initialize(id_, web_source);
     DCHECK(!web_track_.IsNull());
   }
 
@@ -86,19 +87,19 @@ class RemoteMediaStreamTrackAdapter
   // 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 web object(s).
-  base::Callback<void()> web_initialize_;
+  base::OnceClosure web_initialize_;
 
  private:
   const scoped_refptr<WebRtcMediaStreamTrackType> webrtc_track_;
-  blink::WebMediaStreamTrack web_track_;
+  WebMediaStreamTrack web_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_;
+  const WebString id_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackAdapter);
 };
 
-class RemoteVideoTrackAdapter
+class BLINK_MODULES_EXPORT RemoteVideoTrackAdapter
     : public RemoteMediaStreamTrackAdapter<webrtc::VideoTrackInterface> {
  public:
   // Called on the signaling thread.
@@ -110,14 +111,14 @@ class RemoteVideoTrackAdapter
   ~RemoteVideoTrackAdapter() override;
 
  private:
-  void InitializeWebVideoTrack(std::unique_ptr<blink::TrackObserver> observer,
+  void InitializeWebVideoTrack(std::unique_ptr<TrackObserver> observer,
                                bool enabled);
 };
 
 // RemoteAudioTrackAdapter is responsible for listening on state
 // change notifications on a remote webrtc audio MediaStreamTracks and notify
 // Blink.
-class RemoteAudioTrackAdapter
+class BLINK_MODULES_EXPORT RemoteAudioTrackAdapter
     : public RemoteMediaStreamTrackAdapter<webrtc::AudioTrackInterface>,
       public webrtc::ObserverInterface {
  public:
@@ -150,6 +151,6 @@ class RemoteAudioTrackAdapter
   DISALLOW_COPY_AND_ASSIGN(RemoteAudioTrackAdapter);
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_RENDERER_MEDIA_STREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_MEDIASTREAM_REMOTE_MEDIA_STREAM_TRACK_ADAPTER_H_

third_party/blink/renderer/modules/mediastream/BUILD.gn

@@ -44,6 +44,7 @@ blink_modules_sources("mediastream") {
     "navigator_user_media.h",
     "overconstrained_error.cc",
     "overconstrained_error.h",
+    "remote_media_stream_track_adapter.cc",
     "user_media_client.cc",
     "user_media_client.h",
     "user_media_controller.cc",

content/renderer/media/stream/remote_media_stream_track_adapter.cc → third_party/blink/renderer/modules/mediastream/remote_media_stream_track_adapter.cc

@@ -2,55 +2,66 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/media/stream/remote_media_stream_track_adapter.h"
+#include "third_party/blink/public/web/modules/mediastream/remote_media_stream_track_adapter.h"
 
+#include "base/single_thread_task_runner.h"
 #include "media/base/limits.h"
 #include "third_party/blink/public/platform/modules/mediastream/media_stream_audio_source.h"
 #include "third_party/blink/public/platform/modules/webrtc/peer_connection_remote_audio_source.h"
 #include "third_party/blink/public/platform/modules/webrtc/track_observer.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_track.h"
 #include "third_party/blink/public/web/modules/peerconnection/media_stream_remote_video_source.h"
+#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
+#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
+#include "third_party/blink/renderer/platform/wtf/functional.h"
 
-namespace content {
+namespace blink {
 
 RemoteVideoTrackAdapter::RemoteVideoTrackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     webrtc::VideoTrackInterface* webrtc_track)
     : RemoteMediaStreamTrackAdapter(main_thread, webrtc_track) {
-  std::unique_ptr<blink::TrackObserver> observer(
-      new blink::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());
+  std::unique_ptr<TrackObserver> observer(
+      new TrackObserver(main_thread, observed_track().get()));
+  // Here, we use CrossThreadUnretained() to avoid a circular reference.
+  //
+  // TODO(crbug.com/963574): Remove the use of ConvertToBaseOnceCallback here
+  // once the file that includes remote_media_stream_track_adapter.h (namely
+  // webrtc_media_stream_track_adapter.h) is Onion souped.
+  web_initialize_ = ConvertToBaseOnceCallback(
+      CrossThreadBindOnce(&RemoteVideoTrackAdapter::InitializeWebVideoTrack,
+                          CrossThreadUnretained(this), std::move(observer),
+                          observed_track()->enabled()));
 }
 
 RemoteVideoTrackAdapter::~RemoteVideoTrackAdapter() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   if (initialized()) {
-    static_cast<blink::MediaStreamRemoteVideoSource*>(
+    // TODO(crbug.com/704136): When moving RemoteVideoTrackAdapter out of the
+    // public API, make this managed by Oilpan. Note that, the destructor will
+    // not allowed to touch other on-heap objects like web_track().
+    static_cast<MediaStreamRemoteVideoSource*>(
         web_track()->Source().GetPlatformSource())
         ->OnSourceTerminated();
   }
 }
 
 void RemoteVideoTrackAdapter::InitializeWebVideoTrack(
-    std::unique_ptr<blink::TrackObserver> observer,
+    std::unique_ptr<TrackObserver> observer,
     bool enabled) {
   DCHECK(main_thread_->BelongsToCurrentThread());
-  auto video_source_ptr = std::make_unique<blink::MediaStreamRemoteVideoSource>(
-      std::move(observer));
-  blink::MediaStreamRemoteVideoSource* video_source = video_source_ptr.get();
-  InitializeWebTrack(blink::WebMediaStreamSource::kTypeVideo);
+  auto video_source_ptr =
+      std::make_unique<MediaStreamRemoteVideoSource>(std::move(observer));
+  MediaStreamRemoteVideoSource* video_source = video_source_ptr.get();
+  InitializeWebTrack(WebMediaStreamSource::kTypeVideo);
   web_track()->Source().SetPlatformSource(std::move(video_source_ptr));
 
-  blink::WebMediaStreamSource::Capabilities capabilities;
-  capabilities.device_id = blink::WebString::FromUTF8(id());
+  WebMediaStreamSource::Capabilities capabilities;
+  capabilities.device_id = id();
   web_track()->Source().SetCapabilities(capabilities);
 
-  web_track()->SetPlatformTrack(std::make_unique<blink::MediaStreamVideoTrack>(
-      video_source, blink::MediaStreamVideoSource::ConstraintsCallback(),
-      enabled));
+  web_track()->SetPlatformTrack(std::make_unique<MediaStreamVideoTrack>(
+      video_source, MediaStreamVideoSource::ConstraintsCallback(), enabled));
 }
 
 RemoteAudioTrackAdapter::RemoteAudioTrackAdapter(
@@ -61,12 +72,16 @@ RemoteAudioTrackAdapter::RemoteAudioTrackAdapter(
       unregistered_(false),
 #endif
       state_(observed_track()->state()) {
-  // TODO(tommi): Use blink::TrackObserver instead.
+  // 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), main_thread);
+  // Here, we use CrossThreadUnretained() to avoid a circular reference.
+  //
+  // TODO(crbug.com/963574): Remove the use of ConvertToBaseOnceCallback here
+  // once the file that includes remote_media_stream_track_adapter.h (namely
+  // webrtc_media_stream_track_adapter.h) is Onion souped.
+  web_initialize_ = ConvertToBaseOnceCallback(
+      CrossThreadBindOnce(&RemoteAudioTrackAdapter::InitializeWebAudioTrack,
+                          CrossThreadUnretained(this), main_thread));
 }
 
 RemoteAudioTrackAdapter::~RemoteAudioTrackAdapter() {
@@ -85,32 +100,34 @@ void RemoteAudioTrackAdapter::Unregister() {
 
 void RemoteAudioTrackAdapter::InitializeWebAudioTrack(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread) {
-  InitializeWebTrack(blink::WebMediaStreamSource::kTypeAudio);
+  InitializeWebTrack(WebMediaStreamSource::kTypeAudio);
 
-  blink::MediaStreamAudioSource* const source =
-      new blink::PeerConnectionRemoteAudioSource(observed_track().get(),
-                                                 main_thread);
+  auto source = std::make_unique<PeerConnectionRemoteAudioSource>(
+      observed_track().get(), main_thread);
+  auto* source_ptr = source.get();
   web_track()->Source().SetPlatformSource(
-      base::WrapUnique(source));  // Takes ownership.
-
-  blink::WebMediaStreamSource::Capabilities capabilities;
-  capabilities.device_id = blink::WebString::FromUTF8(id());
-  capabilities.echo_cancellation = std::vector<bool>({false});
-  capabilities.auto_gain_control = std::vector<bool>({false});
-  capabilities.noise_suppression = std::vector<bool>({false});
+      std::move(source));  // Takes ownership.
+
+  WebMediaStreamSource::Capabilities capabilities;
+  capabilities.device_id = id();
+  bool values[] = {false};
+  capabilities.echo_cancellation = WebVector<bool>(values, 1u);
+  capabilities.auto_gain_control = WebVector<bool>(values, 1u);
+  capabilities.noise_suppression = WebVector<bool>(values, 1u);
   capabilities.sample_size = {
       media::SampleFormatToBitsPerChannel(media::kSampleFormatS16),  // min
       media::SampleFormatToBitsPerChannel(media::kSampleFormatS16)   // max
   };
   web_track()->Source().SetCapabilities(capabilities);
 
-  source->ConnectToTrack(*(web_track()));
+  source_ptr->ConnectToTrack(*(web_track()));
 }
 
 void RemoteAudioTrackAdapter::OnChanged() {
-  main_thread_->PostTask(
-      FROM_HERE, base::BindOnce(&RemoteAudioTrackAdapter::OnChangedOnMainThread,
-                                this, observed_track()->state()));
+  PostCrossThreadTask(
+      *main_thread_, FROM_HERE,
+      CrossThreadBindOnce(&RemoteAudioTrackAdapter::OnChangedOnMainThread,
+                          WrapRefCounted(this), observed_track()->state()));
 }
 
 void RemoteAudioTrackAdapter::OnChangedOnMainThread(
@@ -125,11 +142,11 @@ void RemoteAudioTrackAdapter::OnChangedOnMainThread(
   switch (state) {
     case webrtc::MediaStreamTrackInterface::kLive:
       web_track()->Source().SetReadyState(
-          blink::WebMediaStreamSource::kReadyStateLive);
+          WebMediaStreamSource::kReadyStateLive);
       break;
     case webrtc::MediaStreamTrackInterface::kEnded:
       web_track()->Source().SetReadyState(
-          blink::WebMediaStreamSource::kReadyStateEnded);
+          WebMediaStreamSource::kReadyStateEnded);
       break;
     default:
       NOTREACHED();
@@ -137,4 +154,4 @@ void RemoteAudioTrackAdapter::OnChangedOnMainThread(
   }
 }
 
-}  // namespace content
+}  // namespace blink

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -620,6 +620,9 @@ _CONFIG = [
         'allowed': [
             'media::.+',
             'base::AutoLock',
+            'webrtc::AudioTrackInterface',
+            'webrtc::VideoTrackInterface',
+            'webrtc::MediaStreamTrackInterface',
         ]
     },
     {