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;

[o1ka, 2016/04/01 15:11:41]

This part I haven't processed entirely yet. What if SetMediaStreamAudioTrack()
is called twice? And what if AddSink() is called before it?

[o1ka, 2016/04/06 18:39:10]

The interface does set any expectations on SetMediaStreamAudioTrack: when it is
called, or how many times. But from implementation it looks like it's expected
that it's called only once and before any AddSink calls. If it's called after
AddSink(), then the previously added sink won't be added to the track, but on
RemoveSink() there will be an attempt to remove it from the track. Also, AddSink
can race with SetMediaStreamAudioTrack.

[miu, 2016/04/19 00:40:23]

No longer applicable (Patch Set 4).

[miu, 2016/04/19 00:40:23]

No longer applicable (Patch Set 4).  See my prior e-mail about refactoring this
class so weird things like this are no longer needed.

 }
 
 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