Implements the GetSignalLevel and GetStats interface for the local audio track.

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/logging.h"
+#include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/webrtc/webrtc_audio_sink_adapter.h"
 #include "content/renderer/media/webrtc_local_audio_track.h"
+#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 namespace content {
 
 static const char kAudioTrackKind[] = "audio";
 
 scoped_refptr<WebRtcLocalAudioTrackAdapter>
 WebRtcLocalAudioTrackAdapter::Create(
     const std::string& label,
     webrtc::AudioSourceInterface* track_source) {
   talk_base::RefCountedObject<WebRtcLocalAudioTrackAdapter>* adapter =
       new talk_base::RefCountedObject<WebRtcLocalAudioTrackAdapter>(
           label, track_source);
   return adapter;
 }
 
 WebRtcLocalAudioTrackAdapter::WebRtcLocalAudioTrackAdapter(
     const std::string& label,
     webrtc::AudioSourceInterface* track_source)
     : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label),
       owner_(NULL),
-      track_source_(track_source) {
+      track_source_(track_source),
+      signal_level_(0) {
 }
 
 WebRtcLocalAudioTrackAdapter::~WebRtcLocalAudioTrackAdapter() {
 }
 
 void WebRtcLocalAudioTrackAdapter::Initialize(WebRtcLocalAudioTrack* owner) {
   DCHECK(!owner_);
   DCHECK(owner);
   owner_ = owner;
 }
 
+void WebRtcLocalAudioTrackAdapter::SetAudioProcessor(
+    const scoped_refptr<MediaStreamAudioProcessor>& processor) {
+  base::AutoLock auto_lock(lock_);
+  audio_processor_ = processor;
+}
+
 std::string WebRtcLocalAudioTrackAdapter::kind() const {
   return kAudioTrackKind;
 }
 
 void WebRtcLocalAudioTrackAdapter::AddSink(
     webrtc::AudioTrackSinkInterface* sink) {
   DCHECK(sink);
 #ifndef NDEBUG
   // Verify that |sink| has not been added.
   for (ScopedVector<WebRtcAudioSinkAdapter>::const_iterator it =
@@ skipping 16 matching lines @@
            sink_adapters_.begin();
        it != sink_adapters_.end(); ++it) {
     if ((*it)->IsEqual(sink)) {
       owner_->RemoveSink(*it);
       sink_adapters_.erase(it);
       return;
     }
   }
 }
 
+bool WebRtcLocalAudioTrackAdapter::GetSignalLevel(int* level) {
+  base::AutoLock auto_lock(lock_);
+  *level = signal_level_;
+  return true;
+}
+
+talk_base::scoped_refptr<webrtc::AudioProcessorInterface>
+WebRtcLocalAudioTrackAdapter::GetAudioProcessor() {
+  base::AutoLock auto_lock(lock_);
+  return audio_processor_.get();
+}
+
 std::vector<int> WebRtcLocalAudioTrackAdapter::VoeChannels() const {
   base::AutoLock auto_lock(lock_);
   return voe_channels_;
 }
 
 void WebRtcLocalAudioTrackAdapter::SetSignalLevel(int signal_level) {
-  // TODO(xians): Implements this.
+  base::AutoLock auto_lock(lock_);
+  signal_level_ = signal_level;
 }
 
 void WebRtcLocalAudioTrackAdapter::AddChannel(int channel_id) {
   DVLOG(1) << "WebRtcLocalAudioTrack::AddChannel(channel_id="
            << channel_id << ")";
   base::AutoLock auto_lock(lock_);
   if (std::find(voe_channels_.begin(), voe_channels_.end(), channel_id) !=
       voe_channels_.end()) {
     // We need to handle the case when the same channel is connected to the
     // track more than once.
@@ skipping 15 matching lines @@
 
 webrtc::AudioSourceInterface* WebRtcLocalAudioTrackAdapter::GetSource() const {
   return track_source_;
 }
 
 cricket::AudioRenderer* WebRtcLocalAudioTrackAdapter::GetRenderer() {
   return this;
 }
 
 }  // namespace content