MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/media/webrtc/webrtc_local_audio_track_adapter.cc

 // Copyright 2014 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/webrtc/webrtc_local_audio_track_adapter.h"
 
+#include <limits>
+
+#include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/synchronization/waitable_event.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
+#include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/webrtc_audio_sink_adapter.h"
-#include "content/renderer/media/webrtc_local_audio_track.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 
 namespace content {
 
 static const char kAudioTrackKind[] = "audio";
 
 scoped_refptr<WebRtcLocalAudioTrackAdapter>
 WebRtcLocalAudioTrackAdapter::Create(
     const std::string& label,
@@ skipping 15 matching lines @@
       new rtc::RefCountedObject<WebRtcLocalAudioTrackAdapter>(
           label, track_source, std::move(signaling_task_runner));
   return adapter;
 }
 
 WebRtcLocalAudioTrackAdapter::WebRtcLocalAudioTrackAdapter(
     const std::string& label,
     webrtc::AudioSourceInterface* track_source,
     scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner)
     : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label),
-      owner_(NULL),
       track_source_(track_source),
       signaling_task_runner_(std::move(signaling_task_runner)) {}
 
 WebRtcLocalAudioTrackAdapter::~WebRtcLocalAudioTrackAdapter() {
 }
 
-void WebRtcLocalAudioTrackAdapter::Initialize(WebRtcLocalAudioTrack* owner) {
-  DCHECK(!owner_);
-  DCHECK(owner);
-  owner_ = owner;
+void WebRtcLocalAudioTrackAdapter::SetMediaStreamAudioTrack(
+    base::WeakPtr<MediaStreamAudioTrack> track) {
+  // Note: Single-threaded unit tests might not provide a task runner (or even a
+  // main-thread MessageLoop).
+  if (base::MessageLoop* main_loop = base::MessageLoop::current())
+    main_task_runner_ = main_loop->task_runner();
+  track_ = track;
 }
 
 void WebRtcLocalAudioTrackAdapter::SetAudioProcessor(
     scoped_refptr<MediaStreamAudioProcessor> processor) {
   DCHECK(processor.get());
   DCHECK(!audio_processor_);
   audio_processor_ = std::move(processor);
 }
 
 void WebRtcLocalAudioTrackAdapter::SetLevel(
@@ skipping 18 matching lines @@
             this, enable));
     return true;
   }
 
   return webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>::
       set_enabled(enable);
 }
 
 void WebRtcLocalAudioTrackAdapter::AddSink(
     webrtc::AudioTrackSinkInterface* sink) {
-  DCHECK(!signaling_task_runner_ ||
-         signaling_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(sink);
+
+  // The MediaStream object graph may only be modified on the main thread, so
+  // trampoline if necessary.
+  if (main_task_runner_ && !main_task_runner_->RunsTasksOnCurrentThread()) {
+    main_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&WebRtcLocalAudioTrackAdapter::AddSink, this, sink));
+    return;
+  }
+
 #ifndef NDEBUG
   // Verify that |sink| has not been added.
-  for (ScopedVector<WebRtcAudioSinkAdapter>::const_iterator it =
-           sink_adapters_.begin();
-       it != sink_adapters_.end(); ++it) {
-    DCHECK(!(*it)->IsEqual(sink));
-  }
+  for (const auto& adapter : sink_adapters_)
+    DCHECK(!adapter->IsEqual(sink));
 #endif
 
-  scoped_ptr<WebRtcAudioSinkAdapter> adapter(
-      new WebRtcAudioSinkAdapter(sink));
-  owner_->AddSink(adapter.get());
-  sink_adapters_.push_back(adapter.release());
+  if (track_) {
+    scoped_ptr<WebRtcAudioSinkAdapter> adapter(
+        new WebRtcAudioSinkAdapter(sink));
+    track_->AddSink(adapter.get());
+    sink_adapters_.push_back(std::move(adapter));
+  }
 }
 
 void WebRtcLocalAudioTrackAdapter::RemoveSink(
     webrtc::AudioTrackSinkInterface* sink) {
-  DCHECK(!signaling_task_runner_ ||
-         signaling_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(sink);
-  for (ScopedVector<WebRtcAudioSinkAdapter>::iterator it =
-           sink_adapters_.begin();
-       it != sink_adapters_.end(); ++it) {
-    if ((*it)->IsEqual(sink)) {
-      owner_->RemoveSink(*it);
-      sink_adapters_.erase(it);
-      return;
-    }
+
+  // The MediaStream object graph may only be modified on the main thread, so
+  // trampoline if necessary.  Furthermore, block the current thread until the
+  // task has completed because the interface contract requires the audio flow
+  // to |sink| be stopped when this method returns.
+  if (main_task_runner_ && !main_task_runner_->RunsTasksOnCurrentThread()) {
+    base::WaitableEvent done_event(false, false);
+    main_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&WebRtcLocalAudioTrackAdapter::RemoveSinkOnMainThread, this,
+                   sink, &done_event));
+    done_event.Wait();
+  } else {
+    RemoveSinkOnMainThread(sink, nullptr);
   }
 }
 
+void WebRtcLocalAudioTrackAdapter::RemoveSinkOnMainThread(
+    webrtc::AudioTrackSinkInterface* sink,
+    base::WaitableEvent* done_event) {
+  DCHECK(!main_task_runner_ || main_task_runner_->RunsTasksOnCurrentThread());
+  for (auto it = sink_adapters_.begin(); it != sink_adapters_.end(); ++it) {
+    if ((*it)->IsEqual(sink)) {
+      if (track_)
+        track_->RemoveSink(it->get());
+      sink_adapters_.erase(it);
+      break;
+    }
+  }
+  if (done_event)
+    done_event->Signal();
+}
+
 bool WebRtcLocalAudioTrackAdapter::GetSignalLevel(int* level) {
   DCHECK(!signaling_task_runner_ ||
          signaling_task_runner_->RunsTasksOnCurrentThread());
 
   // |level_| is only set once, so it's safe to read without first acquiring a
   // mutex.
   if (!level_)
     return false;
   const float signal_level = level_->GetCurrent();
   DCHECK_GE(signal_level, 0.0f);
@@ skipping 11 matching lines @@
   return audio_processor_.get();
 }
 
 webrtc::AudioSourceInterface* WebRtcLocalAudioTrackAdapter::GetSource() const {
   DCHECK(!signaling_task_runner_ ||
          signaling_task_runner_->RunsTasksOnCurrentThread());
   return track_source_;
 }
 
 }  // namespace content