MediaStream audio object graph untangling and clean-ups.

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 "base/location.h"
 #include "base/logging.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
@@ skipping 28 matching lines @@
   return adapter;
 }
 
 WebRtcLocalAudioTrackAdapter::WebRtcLocalAudioTrackAdapter(
     const std::string& label,
     webrtc::AudioSourceInterface* track_source,
     const scoped_refptr<base::SingleThreadTaskRunner>& signaling_thread)
     : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label),
       owner_(NULL),
       track_source_(track_source),
-      signaling_thread_(signaling_thread),
-      signal_level_(0) {
+      signaling_thread_(signaling_thread) {
   signaling_thread_checker_.DetachFromThread();

[mcasas, 2016/02/26 01:28:19]

DCHECK(signaling_thread_);
(this should not happen but probably some
or another unit tests will roll with it by 
skipping some functionality, in that case
probs the Create() method in l.34 should
add an
#if !defined(NDEBUG)
  if(!signalling_thread.get())
    signaling_thread = base::ThreadTaskRunnerHandle::Get();
#endif
WDYT?

[miu, 2016/02/27 03:46:36]

I actually have some threading fixes to this class that I'll be introducing in
my next CL.  ;-)  Basically, the AddSink() and RemoveSink() methods are
currently called on the WebRTC signaling thread, but all other MediaStream code
adds and removes sinks/tracks/whatever on the main thread.  So, my next CL will
make things more consistent.

   capture_thread_.DetachFromThread();
 }
 
 WebRtcLocalAudioTrackAdapter::~WebRtcLocalAudioTrackAdapter() {
 }
 
 void WebRtcLocalAudioTrackAdapter::Initialize(WebRtcLocalAudioTrack* owner) {
   DCHECK(!owner_);
   DCHECK(owner);
   owner_ = owner;
 }
 
 void WebRtcLocalAudioTrackAdapter::SetAudioProcessor(
     const scoped_refptr<MediaStreamAudioProcessor>& processor) {
   // SetAudioProcessor will be called when a new capture thread has been
   // initialized, so we need to detach from any current capture thread we're
   // checking and attach to the current one.
   capture_thread_.DetachFromThread();
   DCHECK(capture_thread_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   audio_processor_ = processor;
 }
 
+void WebRtcLocalAudioTrackAdapter::SetLevel(
+    scoped_refptr<MediaStreamAudioLevelCalculator::Level> level) {

[mcasas, 2016/02/26 01:28:19]

Paranoia nit:

DCHECK(capture_thread_.CalledOnValidThread() ||
       signaling_thread_checker_.CalledOnValidThread());

?
(Here and in l.134) ?

[miu, 2016/02/27 03:46:36]

Actually, it's not called from either of those threads; it's called from the
main thread.  It really does not matter what thread calls this since it is just
set once before the audio flow begins and then left alone forever after.

+  base::AutoLock auto_lock(lock_);
+  level_ = level;
+}
+
 std::string WebRtcLocalAudioTrackAdapter::kind() const {
   return kAudioTrackKind;
 }
 
 bool WebRtcLocalAudioTrackAdapter::set_enabled(bool enable) {
   // If we're not called on the signaling thread, we need to post a task to
   // change the state on the correct thread.
   if (signaling_thread_.get() && !signaling_thread_->BelongsToCurrentThread()) {
     signaling_thread_->PostTask(FROM_HERE,
         base::Bind(
@@ skipping 34 matching lines @@
        it != sink_adapters_.end(); ++it) {
     if ((*it)->IsEqual(sink)) {
       owner_->RemoveSink(*it);
       sink_adapters_.erase(it);
       return;
     }
   }
 }
 
 bool WebRtcLocalAudioTrackAdapter::GetSignalLevel(int* level) {
-  DCHECK(signaling_thread_checker_.CalledOnValidThread());
-
-  base::AutoLock auto_lock(lock_);
-  *level = signal_level_;
+  // Note: Called on the signaling thread by WebRtc.
+  float signal_level = 0.0f;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (!level_)
+      return false;
+    signal_level = level_->GetCurrent();
+  }
+  DCHECK_GE(signal_level, 0.0f);
+  DCHECK_LE(signal_level, 1.0f);
+  // Convert from float in range [0.0,1.0] to an int in range [0,32767].
+  *level = static_cast<int>(signal_level * std::numeric_limits<int16_t>::max() +
+                            0.5f /* rounding to nearest int */);
   return true;
 }
 
 rtc::scoped_refptr<webrtc::AudioProcessorInterface>
 WebRtcLocalAudioTrackAdapter::GetAudioProcessor() {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   return audio_processor_.get();
 }
 
-void WebRtcLocalAudioTrackAdapter::SetSignalLevel(int signal_level) {
-  DCHECK(capture_thread_.CalledOnValidThread());
-  base::AutoLock auto_lock(lock_);
-  signal_level_ = signal_level;
-}
-
 webrtc::AudioSourceInterface* WebRtcLocalAudioTrackAdapter::GetSource() const {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   return track_source_;
 }
 
 }  // namespace content