Finish dismantling blink::MediaStreamCenter

This is how the methods got distributed:

* modules/mediastream/media_stream_utils.cc|h (added):
  - DidCreateMediaStreamTrack()
  - CreateNativeAudioMediaStreamTrack()

* modules/mediastream/media_stream_track.cc
  - DidCloneMediaStreamTrack()
  - DidSetMediaStreamTrackEnabled()
  - CloneNativeVideoMediaStreamTrack()
  - CreateWebAudioSourceFromMediaStreamTrack()

* modules/mediacapturefromelement/canvas_capture_media_stream_track.cc:
  - DidCreateMediaStreamTrack()

* modules/webaudio/media_stream_audio_destination_node.cc

  - DidCreateMediaStreamAndTracks()

* modules/mediacapturefromelement/html_media_element_capture.cc:
  - DidStopMediaStreamSource()

Additionally, the following midfield files/classes got removed:

* WebMediaStreamCenter - third_party/blink/public/platform/web_media_stream_center.h
* content::MediaStreamCenter - content/renderer/media/stream/media_stream_center.h

BUG=704136,919392
R=guidou@chromium.org, haraken@chromium.org
TBR=jam@chromium.org

Change-Id: I490ad2fc5eddb03a2c342731713fef7e2f12d952
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1726573
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@{#682721}

content/public/renderer/content_renderer_client.cc

@@ -6,7 +6,6 @@
 
 #include "media/base/renderer_factory.h"
 #include "third_party/blink/public/platform/web_audio_device.h"
-#include "third_party/blink/public/platform/web_media_stream_center.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
 #include "third_party/blink/public/platform/web_speech_synthesizer.h"
 #include "third_party/blink/public/web/modules/mediastream/web_media_stream_renderer_factory.h"

content/renderer/BUILD.gn

@@ -198,8 +198,6 @@ target(link_target_type, "renderer") {
     "media/renderer_webmediaplayer_delegate.h",
     "media/stream/apply_constraints_processor.cc",
     "media/stream/apply_constraints_processor.h",
-    "media/stream/media_stream_center.cc",
-    "media/stream/media_stream_center.h",
     "media/stream/user_media_client_impl.cc",
     "media/stream/user_media_client_impl.h",
     "media/stream/user_media_processor.cc",

content/renderer/media/stream/media_stream_center.h

-// Copyright (c) 2012 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.
-
-#ifndef CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_CENTER_H_
-#define CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_CENTER_H_
-
-#include "third_party/blink/public/platform/web_media_stream_center.h"
-
-#include "base/macros.h"
-#include "base/single_thread_task_runner.h"
-#include "content/common/content_export.h"
-#include "third_party/blink/public/platform/web_media_stream_track.h"
-
-namespace blink {
-class WebAudioSourceProvider;
-}
-
-namespace content {
-
-class CONTENT_EXPORT MediaStreamCenter : public blink::WebMediaStreamCenter {
- public:
-  MediaStreamCenter(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-  ~MediaStreamCenter() override;
-
- private:
-  void DidCreateMediaStreamTrack(
-      const blink::WebMediaStreamTrack& track) override;
-
-  void DidCloneMediaStreamTrack(
-      const blink::WebMediaStreamTrack& original,
-      const blink::WebMediaStreamTrack& clone) override;
-
-  void DidEnableMediaStreamTrack(
-      const blink::WebMediaStreamTrack& track) override;
-
-  void DidDisableMediaStreamTrack(
-      const blink::WebMediaStreamTrack& track) override;
-
-  blink::WebAudioSourceProvider* CreateWebAudioSourceFromMediaStreamTrack(
-      const blink::WebMediaStreamTrack& track,
-      int context_sample_rate) override;
-
-  void DidStopMediaStreamSource(
-      const blink::WebMediaStreamSource& web_source) override;
-
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaStreamCenter);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_RENDERER_MEDIA_STREAM_MEDIA_STREAM_CENTER_H_

content/renderer/render_thread_impl.cc

@@ -91,7 +91,6 @@
 #include "content/renderer/media/audio/audio_renderer_mixer_manager.h"
 #include "content/renderer/media/gpu/gpu_video_accelerator_factories_impl.h"
 #include "content/renderer/media/render_media_client.h"
-#include "content/renderer/media/stream/media_stream_center.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/rtc_peer_connection_handler.h"
@@ -1994,13 +1993,6 @@ RenderThreadImpl::GetAssociatedInterfaceRegistry() {
   return &associated_interfaces_;
 }
 
-std::unique_ptr<blink::WebMediaStreamCenter>
-RenderThreadImpl::CreateMediaStreamCenter() {
-  DCHECK(main_thread_runner()->BelongsToCurrentThread());
-  // TODO(hajimehoshi): Pass a per-frame task runner if possible.
-  return std::make_unique<MediaStreamCenter>(main_thread_runner());
-}
-
 PeerConnectionDependencyFactory*
 RenderThreadImpl::GetPeerConnectionDependencyFactory() {
   return peer_connection_factory_.get();

content/renderer/render_thread_impl.h

@@ -69,7 +69,6 @@ class SkBitmap;
 
 namespace blink {
 class WebVideoCaptureImplManager;
-class WebMediaStreamCenter;
 }
 
 namespace base {
@@ -298,10 +297,6 @@ class CONTENT_EXPORT RenderThreadImpl
   bool EnableStreamTextureCopy();
 #endif
 
-  // Creates the embedder implementation of WebMediaStreamCenter.
-  // The resulting object is owned by WebKit and deleted by WebKit at tear-down.
-  std::unique_ptr<blink::WebMediaStreamCenter> CreateMediaStreamCenter();
-
   BrowserPluginManager* browser_plugin_manager() const {
     return browser_plugin_manager_.get();
   }

content/renderer/renderer_blink_platform_impl.cc

@@ -89,7 +89,6 @@
 #include "third_party/blink/public/platform/url_conversion.h"
 #include "third_party/blink/public/platform/web_audio_latency_hint.h"
 #include "third_party/blink/public/platform/web_blob_registry.h"
-#include "third_party/blink/public/platform/web_media_stream_center.h"
 #include "third_party/blink/public/platform/web_rtc_certificate_generator.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
 #include "third_party/blink/public/platform/web_security_origin.h"
@@ -120,7 +119,6 @@ using blink::Platform;
 using blink::WebAudioDevice;
 using blink::WebAudioLatencyHint;
 using blink::WebBlobRegistry;
-using blink::WebMediaStreamCenter;
 using blink::WebMediaStreamTrack;
 using blink::WebRTCPeerConnectionHandler;
 using blink::WebRTCPeerConnectionHandlerClient;
@@ -566,15 +564,6 @@ RendererBlinkPlatformImpl::CreateRTCCertificateGenerator() {
 
 //------------------------------------------------------------------------------
 
-std::unique_ptr<WebMediaStreamCenter>
-RendererBlinkPlatformImpl::CreateMediaStreamCenter() {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  if (!render_thread)
-    return nullptr;
-  return render_thread->CreateMediaStreamCenter();
-}
-
 // static
 bool RendererBlinkPlatformImpl::SetSandboxEnabledForTesting(bool enable) {
   bool was_enabled = g_sandbox_enabled;

content/renderer/renderer_blink_platform_impl.h

@@ -134,8 +134,6 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   std::unique_ptr<blink::WebRTCCertificateGenerator>
   CreateRTCCertificateGenerator() override;
-  std::unique_ptr<blink::WebMediaStreamCenter> CreateMediaStreamCenter()
-      override;
   scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcWorkerThread() override;
   rtc::Thread* GetWebRtcWorkerThreadRtcThread() override;
   scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcSignalingTaskRunner()

content/shell/renderer/web_test/web_test_content_renderer_client.cc

@@ -34,7 +34,6 @@
 #include "media/base/mime_util.h"
 #include "media/media_buildflags.h"
 #include "third_party/blink/public/platform/web_audio_latency_hint.h"
-#include "third_party/blink/public/platform/web_media_stream_center.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
 #include "third_party/blink/public/platform/web_runtime_features.h"
 #include "third_party/blink/public/web/blink.h"
@@ -47,7 +46,6 @@
 using blink::WebAudioDevice;
 using blink::WebFrame;
 using blink::WebLocalFrame;
-using blink::WebMediaStreamCenter;
 using blink::WebPlugin;
 using blink::WebPluginParams;
 using blink::WebRTCPeerConnectionHandler;

third_party/blink/public/BUILD.gn

@@ -276,7 +276,6 @@ source_set("blink_headers") {
     "platform/web_media_player_source.h",
     "platform/web_media_source.h",
     "platform/web_media_stream.h",
-    "platform/web_media_stream_center.h",
     "platform/web_media_stream_source.h",
     "platform/web_media_stream_track.h",
     "platform/web_memory_pressure_level.h",

third_party/blink/public/platform/platform.h

@@ -122,7 +122,6 @@ class WebDedicatedWorker;
 class WebGraphicsContext3DProvider;
 class WebLocalFrame;
 class WebMediaCapabilitiesClient;
-class WebMediaStreamCenter;
 class WebPrescientNetworking;
 class WebPublicSuffixList;
 class WebRtcAudioDeviceImpl;
@@ -584,10 +583,6 @@ class BLINK_PLATFORM_EXPORT Platform {
   virtual std::unique_ptr<WebRTCCertificateGenerator>
   CreateRTCCertificateGenerator();
 
-  // May return null if WebRTC functionality is not available or out of
-  // resources.
-  virtual std::unique_ptr<WebMediaStreamCenter> CreateMediaStreamCenter();
-
   // Returns the SingleThreadTaskRunner suitable for running WebRTC networking.
   // An rtc::Thread will have already been created.
   // May return null if WebRTC functionality is not implemented.

third_party/blink/public/platform/web_media_stream_center.h

-/*
- * Copyright (C) 2012 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_MEDIA_STREAM_CENTER_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_MEDIA_STREAM_CENTER_H_
-
-#include "third_party/blink/public/platform/web_media_stream_track.h"
-
-namespace blink {
-
-class WebAudioSourceProvider;
-class WebMediaStreamTrack;
-class WebMediaStreamSource;
-
-class WebMediaStreamCenter {
- public:
-  virtual ~WebMediaStreamCenter() = default;
-
-  // Track functionality.
-  virtual void DidCreateMediaStreamTrack(const WebMediaStreamTrack&) {}
-  virtual void DidCloneMediaStreamTrack(const WebMediaStreamTrack& original,
-                                        const WebMediaStreamTrack& clone) {}
-  virtual void DidEnableMediaStreamTrack(const WebMediaStreamTrack&) {}
-  virtual void DidDisableMediaStreamTrack(const WebMediaStreamTrack&) {}
-
-  // Source functionality.
-  virtual void DidStopMediaStreamSource(const WebMediaStreamSource&) {}
-
-  // Caller must take the ownership of the returned |WebAudioSourceProvider|
-  // object.
-  virtual WebAudioSourceProvider* CreateWebAudioSourceFromMediaStreamTrack(
-      const WebMediaStreamTrack&,
-      int context_sample_rate) {
-    return nullptr;
-  }
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_MEDIA_STREAM_CENTER_H_

third_party/blink/renderer/modules/mediacapturefromelement/canvas_capture_media_stream_track.cc

@@ -9,7 +9,7 @@
 #include "third_party/blink/renderer/modules/mediacapturefromelement/auto_canvas_draw_listener.h"
 #include "third_party/blink/renderer/modules/mediacapturefromelement/on_request_canvas_draw_listener.h"
 #include "third_party/blink/renderer/modules/mediacapturefromelement/timed_canvas_draw_listener.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_center.h"
+#include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h"
 
 namespace blink {
 
@@ -27,7 +27,7 @@ CanvasCaptureMediaStreamTrack* CanvasCaptureMediaStreamTrack::clone(
   CanvasCaptureMediaStreamTrack* cloned_track =
       MakeGarbageCollected<CanvasCaptureMediaStreamTrack>(*this,
                                                           cloned_component);
-  MediaStreamCenter::Instance().DidCreateMediaStreamTrack(cloned_component);
+  MediaStreamUtils::DidCreateMediaStreamTrack(cloned_component);
   return cloned_track;
 }
 

third_party/blink/renderer/modules/mediacapturefromelement/html_media_element_capture.cc

@@ -22,7 +22,7 @@
 #include "third_party/blink/renderer/modules/mediacapturefromelement/html_audio_element_capturer_source.h"
 #include "third_party/blink/renderer/modules/mediacapturefromelement/html_video_element_capturer_source.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_center.h"
+#include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h"
 #include "third_party/blink/renderer/platform/wtf/uuid.h"
 
 namespace blink {
@@ -220,6 +220,15 @@ void MediaElementEventListener::Invoke(ExecutionContext* context,
   UpdateSources(context);
 }
 
+void DidStopMediaStreamSource(const WebMediaStreamSource& source) {
+  if (source.IsNull())
+    return;
+  blink::WebPlatformMediaStreamSource* const platform_source =
+      source.GetPlatformSource();
+  DCHECK(platform_source);
+  platform_source->StopSource();
+}
+
 void MediaElementEventListener::UpdateSources(ExecutionContext* context) {
   for (auto track : media_stream_->getTracks())
     sources_.insert(track->Component()->Source());
@@ -227,7 +236,7 @@ void MediaElementEventListener::UpdateSources(ExecutionContext* context) {
   if (!media_element_->currentSrc().IsEmpty() &&
       !media_element_->IsMediaDataCorsSameOrigin()) {
     for (auto source : sources_)
-      MediaStreamCenter::Instance().DidStopMediaStreamSource(source);
+      DidStopMediaStreamSource(source.Get());
   }
 }
 

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

@@ -41,6 +41,8 @@ blink_modules_sources("mediastream") {
     "media_stream_track_content_hint.h",
     "media_stream_track_event.cc",
     "media_stream_track_event.h",
+    "media_stream_utils.cc",
+    "media_stream_utils.h",
     "media_stream_video_capturer_source.cc",
     "media_stream_video_renderer_sink.cc",
     "media_stream_video_renderer_sink.h",

third_party/blink/renderer/modules/mediastream/media_stream_track.cc

@@ -28,6 +28,9 @@
 #include <memory>
 
 #include "third_party/blink/public/platform/web_media_stream_track.h"
+#include "third_party/blink/public/web/modules/mediastream/media_stream_video_source.h"
+#include "third_party/blink/public/web/modules/mediastream/media_stream_video_track.h"
+#include "third_party/blink/public/web/modules/mediastream/webaudio_media_stream_audio_sink.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
@@ -38,6 +41,7 @@
 #include "third_party/blink/renderer/modules/mediastream/apply_constraints_request.h"
 #include "third_party/blink/renderer/modules/mediastream/media_constraints_impl.h"
 #include "third_party/blink/renderer/modules/mediastream/media_stream.h"
+#include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h"
 #include "third_party/blink/renderer/modules/mediastream/media_track_capabilities.h"
 #include "third_party/blink/renderer/modules/mediastream/media_track_constraints.h"
 #include "third_party/blink/renderer/modules/mediastream/media_track_settings.h"
@@ -45,9 +49,10 @@
 #include "third_party/blink/renderer/modules/mediastream/user_media_controller.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/heap/heap_allocator.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_center.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_web_audio_source.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
 
@@ -141,6 +146,67 @@ bool ConstraintsHaveImageCapture(const MediaTrackConstraints* constraints) {
   return ConstraintsSatisfyCondition(ConstraintSetHasImageCapture, constraints);
 }
 
+// Caller must take the ownership of the returned |WebAudioSourceProvider|
+// object.
+std::unique_ptr<WebAudioSourceProvider>
+CreateWebAudioSourceFromMediaStreamTrack(const WebMediaStreamTrack& track,
+                                         int context_sample_rate) {
+  WebPlatformMediaStreamTrack* media_stream_track = track.GetPlatformTrack();
+  if (!media_stream_track) {
+    DLOG(ERROR) << "Native track missing for webaudio source.";
+    return nullptr;
+  }
+
+  WebMediaStreamSource source = track.Source();
+  DCHECK_EQ(source.GetType(), WebMediaStreamSource::kTypeAudio);
+
+  return std::make_unique<WebAudioMediaStreamAudioSink>(track,
+                                                        context_sample_rate);
+}
+
+void CloneNativeVideoMediaStreamTrack(const WebMediaStreamTrack& original,
+                                      WebMediaStreamTrack clone) {
+  DCHECK(!clone.GetPlatformTrack());
+  WebMediaStreamSource source = clone.Source();
+  DCHECK_EQ(source.GetType(), WebMediaStreamSource::kTypeVideo);
+  MediaStreamVideoSource* native_source =
+      MediaStreamVideoSource::GetVideoSource(source);
+  DCHECK(native_source);
+  MediaStreamVideoTrack* original_track =
+      MediaStreamVideoTrack::GetVideoTrack(original);
+  DCHECK(original_track);
+  clone.SetPlatformTrack(std::make_unique<MediaStreamVideoTrack>(
+      native_source, original_track->adapter_settings(),
+      original_track->noise_reduction(), original_track->is_screencast(),
+      original_track->min_frame_rate(),
+      MediaStreamVideoSource::ConstraintsCallback(), clone.IsEnabled()));
+}
+
+void DidSetMediaStreamTrackEnabled(MediaStreamComponent* component) {
+  const WebMediaStreamTrack track(component);
+  auto* native_track = WebPlatformMediaStreamTrack::GetTrack(track);
+  if (native_track)
+    native_track->SetEnabled(component->Enabled());
+}
+
+void DidCloneMediaStreamTrack(const WebMediaStreamTrack& original,
+                              const WebMediaStreamTrack& clone) {
+  DCHECK(!clone.IsNull());
+  DCHECK(!clone.GetPlatformTrack());
+  DCHECK(!clone.Source().IsNull());
+
+  switch (clone.Source().GetType()) {
+    case WebMediaStreamSource::kTypeAudio:
+      // TODO(crbug.com/704136): Use per thread task runner.
+      MediaStreamUtils::CreateNativeAudioMediaStreamTrack(
+          clone, Thread::MainThread()->GetTaskRunner());
+      break;
+    case WebMediaStreamSource::kTypeVideo:
+      CloneNativeVideoMediaStreamTrack(original, clone);
+      break;
+  }
+}
+
 }  // namespace
 
 MediaStreamTrack* MediaStreamTrack::Create(ExecutionContext* context,
@@ -213,8 +279,7 @@ void MediaStreamTrack::setEnabled(bool enabled) {
   component_->SetEnabled(enabled);
 
   if (!Ended())
-    MediaStreamCenter::Instance().DidSetMediaStreamTrackEnabled(
-        component_.Get());
+    DidSetMediaStreamTrackEnabled(component_.Get());
 }
 
 bool MediaStreamTrack::muted() const {
@@ -317,8 +382,7 @@ MediaStreamTrack* MediaStreamTrack::clone(ScriptState* script_state) {
   MediaStreamTrack* cloned_track = MakeGarbageCollected<MediaStreamTrack>(
       ExecutionContext::From(script_state), cloned_component, ready_state_,
       stopped_);
-  MediaStreamCenter::Instance().DidCloneMediaStreamTrack(Component(),
-                                                         cloned_component);
+  DidCloneMediaStreamTrack(Component(), cloned_component);
   return cloned_track;
 }
 
@@ -697,8 +761,9 @@ bool MediaStreamTrack::HasPendingActivity() const {
 
 std::unique_ptr<AudioSourceProvider> MediaStreamTrack::CreateWebAudioSource(
     int context_sample_rate) {
-  return MediaStreamCenter::Instance().CreateWebAudioSourceFromMediaStreamTrack(
-      Component(), context_sample_rate);
+  return std::make_unique<MediaStreamWebAudioSource>(
+      CreateWebAudioSourceFromMediaStreamTrack(Component(),
+                                               context_sample_rate));
 }
 
 void MediaStreamTrack::RegisterMediaStream(MediaStream* media_stream) {

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

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2019 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/stream/media_stream_center.h"
+#include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h"
 
-#include <stddef.h>
-
-#include <string>
-#include <vector>
-
-#include "base/logging.h"
-#include "media/base/sample_format.h"
-#include "third_party/blink/public/platform/modules/mediastream/web_platform_media_stream_source.h"
+#include "base/single_thread_task_runner.h"
+#include "third_party/blink/public/platform/modules/mediastream/media_stream_audio_source.h"
 #include "third_party/blink/public/platform/modules/mediastream/webaudio_media_stream_source.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_vector.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_source.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_track.h"
-#include "third_party/blink/public/web/modules/mediastream/processed_local_audio_source.h"
-#include "third_party/blink/public/web/modules/mediastream/webaudio_media_stream_audio_sink.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_descriptor.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
 
-namespace content {
+namespace blink {
 
 namespace {
 
-void CreateNativeAudioMediaStreamTrack(
+void CreateNativeVideoMediaStreamTrack(blink::WebMediaStreamTrack track) {
+  DCHECK(!track.GetPlatformTrack());
+  blink::WebMediaStreamSource source = track.Source();
+  DCHECK_EQ(source.GetType(), blink::WebMediaStreamSource::kTypeVideo);
+  blink::MediaStreamVideoSource* native_source =
+      blink::MediaStreamVideoSource::GetVideoSource(source);
+  DCHECK(native_source);
+  track.SetPlatformTrack(std::make_unique<blink::MediaStreamVideoTrack>(
+      native_source, blink::MediaStreamVideoSource::ConstraintsCallback(),
+      track.IsEnabled()));
+}
+
+}  // namespace
+
+void MediaStreamUtils::CreateNativeAudioMediaStreamTrack(
     const blink::WebMediaStreamTrack& track,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  blink::WebMediaStreamSource source = track.Source();
-  blink::MediaStreamAudioSource* media_stream_source =
+  WebMediaStreamSource source = track.Source();
+  MediaStreamAudioSource* media_stream_source =
       blink::MediaStreamAudioSource::From(source);
 
   // At this point, a MediaStreamAudioSource instance must exist. The one
@@ -48,6 +54,7 @@ void CreateNativeAudioMediaStreamTrack(
 
     blink::WebMediaStreamSource::Capabilities capabilities;
     capabilities.device_id = source.Id();
+    // TODO(crbug.com/704136): Switch away from std::vector.
     capabilities.echo_cancellation = std::vector<bool>({false});
     capabilities.auto_gain_control = std::vector<bool>({false});
     capabilities.noise_suppression = std::vector<bool>({false});
@@ -72,54 +79,18 @@ void CreateNativeAudioMediaStreamTrack(
     LOG(DFATAL) << "WebMediaStreamSource missing its MediaStreamAudioSource.";
 }
 
-void CreateNativeVideoMediaStreamTrack(blink::WebMediaStreamTrack track) {
-  DCHECK(track.GetPlatformTrack() == nullptr);
-  blink::WebMediaStreamSource source = track.Source();
-  DCHECK_EQ(source.GetType(), blink::WebMediaStreamSource::kTypeVideo);
-  blink::MediaStreamVideoSource* native_source =
-      blink::MediaStreamVideoSource::GetVideoSource(source);
-  DCHECK(native_source);
-  track.SetPlatformTrack(std::make_unique<blink::MediaStreamVideoTrack>(
-      native_source, blink::MediaStreamVideoSource::ConstraintsCallback(),
-      track.IsEnabled()));
-}
-
-void CloneNativeVideoMediaStreamTrack(
-    const blink::WebMediaStreamTrack& original,
-    blink::WebMediaStreamTrack clone) {
-  DCHECK(!clone.GetPlatformTrack());
-  blink::WebMediaStreamSource source = clone.Source();
-  DCHECK_EQ(source.GetType(), blink::WebMediaStreamSource::kTypeVideo);
-  blink::MediaStreamVideoSource* native_source =
-      blink::MediaStreamVideoSource::GetVideoSource(source);
-  DCHECK(native_source);
-  blink::MediaStreamVideoTrack* original_track =
-      blink::MediaStreamVideoTrack::GetVideoTrack(original);
-  DCHECK(original_track);
-  clone.SetPlatformTrack(std::make_unique<blink::MediaStreamVideoTrack>(
-      native_source, original_track->adapter_settings(),
-      original_track->noise_reduction(), original_track->is_screencast(),
-      original_track->min_frame_rate(),
-      blink::MediaStreamVideoSource::ConstraintsCallback(), clone.IsEnabled()));
-}
-
-}  // namespace
-
-MediaStreamCenter::MediaStreamCenter(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : task_runner_(task_runner) {}
-
-MediaStreamCenter::~MediaStreamCenter() = default;
-
-void MediaStreamCenter::DidCreateMediaStreamTrack(
-    const blink::WebMediaStreamTrack& track) {
-  DVLOG(1) << "MediaStreamCenter::didCreateMediaStreamTrack";
+// TODO(crbug.com/704136): Change this method to take the task
+// runner instance, and use per thread task runner on the call site.
+void MediaStreamUtils::DidCreateMediaStreamTrack(
+    MediaStreamComponent* component) {
+  WebMediaStreamTrack track(component);
   DCHECK(!track.IsNull() && !track.GetPlatformTrack());
   DCHECK(!track.Source().IsNull());
 
   switch (track.Source().GetType()) {
     case blink::WebMediaStreamSource::kTypeAudio:
-      CreateNativeAudioMediaStreamTrack(track, task_runner_);
+      CreateNativeAudioMediaStreamTrack(track,
+                                        Thread::MainThread()->GetTaskRunner());
       break;
     case blink::WebMediaStreamSource::kTypeVideo:
       CreateNativeVideoMediaStreamTrack(track);
@@ -127,65 +98,4 @@ void MediaStreamCenter::DidCreateMediaStreamTrack(
   }
 }
 
-void MediaStreamCenter::DidCloneMediaStreamTrack(
-    const blink::WebMediaStreamTrack& original,
-    const blink::WebMediaStreamTrack& clone) {
-  DCHECK(!clone.IsNull());
-  DCHECK(!clone.GetPlatformTrack());
-  DCHECK(!clone.Source().IsNull());
-
-  switch (clone.Source().GetType()) {
-    case blink::WebMediaStreamSource::kTypeAudio:
-      CreateNativeAudioMediaStreamTrack(clone, task_runner_);
-      break;
-    case blink::WebMediaStreamSource::kTypeVideo:
-      CloneNativeVideoMediaStreamTrack(original, clone);
-      break;
-  }
-}
-
-void MediaStreamCenter::DidEnableMediaStreamTrack(
-    const blink::WebMediaStreamTrack& track) {
-  blink::WebPlatformMediaStreamTrack* native_track =
-      blink::WebPlatformMediaStreamTrack::GetTrack(track);
-  if (native_track)
-    native_track->SetEnabled(true);
-}
-
-void MediaStreamCenter::DidDisableMediaStreamTrack(
-    const blink::WebMediaStreamTrack& track) {
-  blink::WebPlatformMediaStreamTrack* native_track =
-      blink::WebPlatformMediaStreamTrack::GetTrack(track);
-  if (native_track)
-    native_track->SetEnabled(false);
-}
-
-blink::WebAudioSourceProvider*
-MediaStreamCenter::CreateWebAudioSourceFromMediaStreamTrack(
-    const blink::WebMediaStreamTrack& track,
-    int context_sample_rate) {
-  DVLOG(1) << "MediaStreamCenter::createWebAudioSourceFromMediaStreamTrack";
-  blink::WebPlatformMediaStreamTrack* media_stream_track =
-      track.GetPlatformTrack();
-  if (!media_stream_track) {
-    DLOG(ERROR) << "Native track missing for webaudio source.";
-    return nullptr;
-  }
-
-  blink::WebMediaStreamSource source = track.Source();
-  DCHECK_EQ(source.GetType(), blink::WebMediaStreamSource::kTypeAudio);
-
-  return new blink::WebAudioMediaStreamAudioSink(track, context_sample_rate);
-}
-
-void MediaStreamCenter::DidStopMediaStreamSource(
-    const blink::WebMediaStreamSource& web_source) {
-  if (web_source.IsNull())
-    return;
-  blink::WebPlatformMediaStreamSource* const source =
-      web_source.GetPlatformSource();
-  DCHECK(source);
-  source->StopSource();
-}
-
-}  // namespace content
+}  // namespace blink

third_party/blink/renderer/modules/mediastream/media_stream_utils.h

+// Copyright (c) 2019 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_STREAM_UTILS_H_
+#define THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_STREAM_UTILS_H_
+
+#include "base/memory/scoped_refptr.h"
+#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace blink {
+
+class MediaStreamComponent;
+class WebMediaStreamTrack;
+
+class MediaStreamUtils {
+  STATIC_ONLY(MediaStreamUtils);
+
+ public:
+  static void CreateNativeAudioMediaStreamTrack(
+      const WebMediaStreamTrack&,
+      scoped_refptr<base::SingleThreadTaskRunner>);
+
+  static void DidCreateMediaStreamTrack(MediaStreamComponent*);
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_STREAM_UTILS_H_

third_party/blink/renderer/modules/webaudio/media_stream_audio_destination_node.cc

@@ -26,6 +26,7 @@
 #include "third_party/blink/renderer/modules/webaudio/media_stream_audio_destination_node.h"
 
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
+#include "third_party/blink/renderer/modules/mediastream/media_stream_utils.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_context.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_node_input.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_node_options.h"
@@ -33,11 +34,22 @@
 #include "third_party/blink/renderer/platform/bindings/exception_messages.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_center.h"
 #include "third_party/blink/renderer/platform/wtf/uuid.h"
 
 namespace blink {
 
+namespace {
+
+void DidCreateMediaStreamAndTracks(MediaStreamDescriptor* stream) {
+  for (uint32_t i = 0; i < stream->NumberOfAudioComponents(); ++i)
+    MediaStreamUtils::DidCreateMediaStreamTrack(stream->AudioComponent(i));
+
+  for (uint32_t i = 0; i < stream->NumberOfVideoComponents(); ++i)
+    MediaStreamUtils::DidCreateMediaStreamTrack(stream->VideoComponent(i));
+}
+
+}  // namespace
+
 // WebAudioCapturerSource ignores the channel count beyond 8, so we set the
 // block here to avoid anything can cause the crash.
 static const uint32_t kMaxChannelCount = 8;
@@ -186,8 +198,7 @@ MediaStreamAudioDestinationNode::MediaStreamAudioDestinationNode(
                                   MakeGarbageCollected<MediaStreamDescriptor>(
                                       MediaStreamSourceVector({source_.Get()}),
                                       MediaStreamSourceVector()))) {
-  MediaStreamCenter::Instance().DidCreateMediaStreamAndTracks(
-      stream_->Descriptor());
+  DidCreateMediaStreamAndTracks(stream_->Descriptor());
   SetHandler(
       MediaStreamAudioDestinationHandler::Create(*this, number_of_channels));
 }

third_party/blink/renderer/platform/BUILD.gn

@@ -1193,8 +1193,6 @@ jumbo_component("platform") {
     "mediastream/aec_dump_agent_impl.h",
     "mediastream/audio_service_audio_processor_proxy.cc",
     "mediastream/audio_service_audio_processor_proxy.h",
-    "mediastream/media_stream_center.cc",
-    "mediastream/media_stream_center.h",
     "mediastream/media_stream_component.cc",
     "mediastream/media_stream_component.h",
     "mediastream/media_stream_descriptor.cc",

third_party/blink/renderer/platform/exported/platform.cc

@@ -43,7 +43,6 @@
 #include "third_party/blink/public/platform/interface_provider.h"
 #include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
 #include "third_party/blink/public/platform/web_graphics_context_3d_provider.h"
-#include "third_party/blink/public/platform/web_media_stream_center.h"
 #include "third_party/blink/public/platform/web_prerendering_support.h"
 #include "third_party/blink/public/platform/web_rtc_certificate_generator.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
@@ -341,10 +340,6 @@ Platform::CreateRTCCertificateGenerator() {
   return nullptr;
 }
 
-std::unique_ptr<WebMediaStreamCenter> Platform::CreateMediaStreamCenter() {
-  return nullptr;
-}
-
 std::unique_ptr<webrtc::RtpCapabilities> Platform::GetRtpSenderCapabilities(
     const WebString& kind) {
   return nullptr;

third_party/blink/renderer/platform/mediastream/media_stream_center.cc

-/*
- * Copyright (C) 2011 Ericsson AB. All rights reserved.
- * Copyright (C) 2012 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer
- *    in the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name of Ericsson nor the names of its contributors
- *    may be used to endorse or promote products derived from this
- *    software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "third_party/blink/renderer/platform/mediastream/media_stream_center.h"
-
-#include <memory>
-
-#include "base/memory/ptr_util.h"
-#include "third_party/blink/public/platform/platform.h"
-#include "third_party/blink/public/platform/web_audio_source_provider.h"
-#include "third_party/blink/public/platform/web_media_stream.h"
-#include "third_party/blink/public/platform/web_media_stream_center.h"
-#include "third_party/blink/public/platform/web_media_stream_source.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_descriptor.h"
-#include "third_party/blink/renderer/platform/mediastream/media_stream_web_audio_source.h"
-#include "third_party/blink/renderer/platform/wtf/assertions.h"
-
-namespace blink {
-
-MediaStreamCenter& MediaStreamCenter::Instance() {
-  DCHECK(IsMainThread());
-  DEFINE_STATIC_LOCAL(MediaStreamCenter, center, ());
-  return center;
-}
-
-MediaStreamCenter::MediaStreamCenter()
-    : private_(Platform::Current()->CreateMediaStreamCenter()) {}
-
-MediaStreamCenter::~MediaStreamCenter() = default;
-
-void MediaStreamCenter::DidSetMediaStreamTrackEnabled(
-    MediaStreamComponent* component) {
-  if (private_) {
-    if (component->Enabled()) {
-      private_->DidEnableMediaStreamTrack(component);
-    } else {
-      private_->DidDisableMediaStreamTrack(component);
-    }
-  }
-}
-
-void MediaStreamCenter::DidCreateMediaStreamAndTracks(
-    MediaStreamDescriptor* stream) {
-  if (!private_)
-    return;
-
-  for (uint32_t i = 0; i < stream->NumberOfAudioComponents(); ++i)
-    DidCreateMediaStreamTrack(stream->AudioComponent(i));
-
-  for (uint32_t i = 0; i < stream->NumberOfVideoComponents(); ++i)
-    DidCreateMediaStreamTrack(stream->VideoComponent(i));
-}
-
-void MediaStreamCenter::DidCreateMediaStreamTrack(MediaStreamComponent* track) {
-  if (private_)
-    private_->DidCreateMediaStreamTrack(track);
-}
-
-void MediaStreamCenter::DidCloneMediaStreamTrack(MediaStreamComponent* original,
-                                                 MediaStreamComponent* clone) {
-  if (private_)
-    private_->DidCloneMediaStreamTrack(original, clone);
-}
-
-std::unique_ptr<AudioSourceProvider>
-MediaStreamCenter::CreateWebAudioSourceFromMediaStreamTrack(
-    MediaStreamComponent* track,
-    int context_sample_rate) {
-  DCHECK(track);
-  if (private_) {
-    return std::make_unique<MediaStreamWebAudioSource>(
-        base::WrapUnique(private_->CreateWebAudioSourceFromMediaStreamTrack(
-            track, context_sample_rate)));
-  }
-
-  return nullptr;
-}
-
-void MediaStreamCenter::DidStopMediaStreamSource(MediaStreamSource* source) {
-  if (private_)
-    private_->DidStopMediaStreamSource(source);
-}
-
-}  // namespace blink

third_party/blink/renderer/platform/mediastream/media_stream_center.h

-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer
- *    in the documentation and/or other materials provided with the
- *    distribution.
- * 3. Neither the name of Ericsson nor the names of its contributors
- *    may be used to endorse or promote products derived from this
- *    software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIASTREAM_MEDIA_STREAM_CENTER_H_
-#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIASTREAM_MEDIA_STREAM_CENTER_H_
-
-#include <memory>
-
-#include "base/macros.h"
-#include "base/memory/scoped_refptr.h"
-#include "third_party/blink/public/platform/web_media_stream_track.h"
-#include "third_party/blink/renderer/platform/heap/handle.h"
-#include "third_party/blink/renderer/platform/platform_export.h"
-#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
-#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
-
-namespace blink {
-
-class AudioSourceProvider;
-class MediaStreamComponent;
-class MediaStreamDescriptor;
-class MediaStreamSource;
-class WebMediaStreamCenter;
-
-class PLATFORM_EXPORT MediaStreamCenter {
-  USING_FAST_MALLOC(MediaStreamCenter);
-
- public:
-  ~MediaStreamCenter();
-
-  static MediaStreamCenter& Instance();
-
-  void DidCreateMediaStreamTrack(MediaStreamComponent*);
-  void DidCloneMediaStreamTrack(MediaStreamComponent* original,
-                                MediaStreamComponent* clone);
-  void DidSetMediaStreamTrackEnabled(MediaStreamComponent*);
-  std::unique_ptr<AudioSourceProvider> CreateWebAudioSourceFromMediaStreamTrack(
-      MediaStreamComponent*,
-      int context_sample_rate);
-
-  void DidCreateMediaStreamAndTracks(MediaStreamDescriptor*);
-
-  void DidStopMediaStreamSource(MediaStreamSource*);
-
- private:
-  MediaStreamCenter();
-
-  std::unique_ptr<WebMediaStreamCenter> private_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaStreamCenter);
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_MEDIASTREAM_MEDIA_STREAM_CENTER_H_

third_party/blink/renderer/platform/mediastream/media_stream_web_audio_source.h

@@ -37,13 +37,14 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "third_party/blink/renderer/platform/audio/audio_source_provider.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/wtf/threading_primitives.h"
 
 namespace blink {
 
 class WebAudioSourceProvider;
 
-class MediaStreamWebAudioSource : public AudioSourceProvider {
+class PLATFORM_EXPORT MediaStreamWebAudioSource : public AudioSourceProvider {
  public:
   explicit MediaStreamWebAudioSource(std::unique_ptr<WebAudioSourceProvider>);
   ~MediaStreamWebAudioSource() override;