Replace AudioSilenceDetector with an AudioPowerMonitor.

content/browser/renderer_host/media/audio_renderer_host.cc

 // 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.
 
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
@@ skipping 45 matching lines @@
   }
 
   media::AudioOutputController::SyncReader* reader() const {
     return reader_.get();
   }
 
  private:
   // media::AudioOutputController::EventHandler implementation.
   virtual void OnCreated() OVERRIDE;
   virtual void OnPlaying() OVERRIDE;
-  virtual void OnAudible(bool is_audible) OVERRIDE;
+  virtual void OnPowerMeasured(float power_dbfs, bool clipped) OVERRIDE;
   virtual void OnPaused() OVERRIDE;
   virtual void OnError() OVERRIDE;
   virtual void OnDeviceChange(int new_buffer_size, int new_sample_rate)
       OVERRIDE;
 
   AudioRendererHost* const host_;
   const int stream_id_;
 
   // The routing ID of the source render view.
   const int render_view_id_;
@@ skipping 60 matching lines @@
 }
 
 void AudioRendererHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void AudioRendererHost::AudioEntry::OnCreated() {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&AudioRendererHost::DoCompleteCreation, host_, this));
+      base::Bind(&AudioRendererHost::DoCompleteCreation, host_, stream_id_));
 }
 
 void AudioRendererHost::AudioEntry::OnPlaying() {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&AudioRendererHost::Send), host_,
           new AudioMsg_NotifyStreamStateChanged(
               stream_id_, media::AudioOutputIPCDelegate::kPlaying)));
 }
 
-void AudioRendererHost::AudioEntry::OnAudible(bool is_audible) {
+void AudioRendererHost::AudioEntry::OnPowerMeasured(float power_dbfs,
+                                                    bool clipped) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&AudioRendererHost::DoNotifyAudibleState, host_,
-                 this, is_audible));
+      base::Bind(&AudioRendererHost::DoNotifyAudioPowerLevel, host_,
+                 stream_id_, power_dbfs, clipped));
 }
 
 void AudioRendererHost::AudioEntry::OnPaused() {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&AudioRendererHost::Send), host_,
           new AudioMsg_NotifyStreamStateChanged(
               stream_id_, media::AudioOutputIPCDelegate::kPaused)));
 }
 
 void AudioRendererHost::AudioEntry::OnError() {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioRendererHost::ReportErrorAndClose, host_, stream_id_));
 }
 
 void AudioRendererHost::AudioEntry::OnDeviceChange(int new_buffer_size,
                                                    int new_sample_rate) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(base::IgnoreResult(&AudioRendererHost::Send), host_,
                  new AudioMsg_NotifyDeviceChanged(
                      stream_id_, new_buffer_size, new_sample_rate)));
 }
 
-void AudioRendererHost::DoCompleteCreation(AudioEntry* entry) {
+void AudioRendererHost::DoCompleteCreation(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!PeerHandle()) {
     NOTREACHED() << "Renderer process handle is invalid.";
-    ReportErrorAndClose(entry->stream_id());
+    ReportErrorAndClose(stream_id);
     return;
   }
 
+  AudioEntry* const entry = LookupById(stream_id);
+  if (!entry) {
+    ReportErrorAndClose(stream_id);
+    return;
+  }
+
   // Once the audio stream is created then complete the creation process by
   // mapping shared memory and sharing with the renderer process.
   base::SharedMemoryHandle foreign_memory_handle;
   if (!entry->shared_memory()->ShareToProcess(PeerHandle(),
                                               &foreign_memory_handle)) {
     // If we failed to map and share the shared memory then close the audio
     // stream and send an error message.
     ReportErrorAndClose(entry->stream_id());
     return;
   }
@@ skipping 14 matching lines @@
     return;
   }
 
   Send(new AudioMsg_NotifyStreamCreated(
       entry->stream_id(),
       foreign_memory_handle,
       foreign_socket_handle,
       media::PacketSizeInBytes(entry->shared_memory()->requested_size())));
 }
 
-void AudioRendererHost::DoNotifyAudibleState(AudioEntry* entry,
-                                             bool is_audible) {
+void AudioRendererHost::DoNotifyAudioPowerLevel(int stream_id,
+                                                float power_dbfs,
+                                                bool clipped) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer) {
-    DVLOG(1) << "AudioRendererHost@" << this
-             << "::DoNotifyAudibleState(is_audible=" << is_audible
-             << ") for stream_id=" << entry->stream_id();
-
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableAudibleNotifications)) {
-      media_observer->OnAudioStreamPlayingChanged(
-          render_process_id_, entry->render_view_id(), entry->stream_id(),
-          is_audible);
+      AudioEntry* const entry = LookupById(stream_id);
+      if (entry) {
+        media_observer->OnAudioStreamPlayingChanged(
+            render_process_id_, entry->render_view_id(), entry->stream_id(),
+            true, power_dbfs, clipped);
+      }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IPC Messages handler
 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message,
                                           bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(AudioRendererHost, message, *message_was_ok)
@@ skipping 161 matching lines @@
 }
 
 void AudioRendererHost::DeleteEntry(scoped_ptr<AudioEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // At this point, make the final "say" in audio playback state.
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer) {
     media_observer->OnAudioStreamPlayingChanged(
-        render_process_id_, entry->render_view_id(), entry->stream_id(), false);
+        render_process_id_, entry->render_view_id(), entry->stream_id(),
+        false, -std::numeric_limits<float>::infinity(), false);
   }
 
   // Notify the media observer.
   if (media_internals_)
     media_internals_->OnDeleteAudioStream(this, entry->stream_id());
 
   // Note: |entry| will be deleted upon leaving this scope.
 }
 
 void AudioRendererHost::ReportErrorAndClose(int stream_id) {
@@ skipping 14 matching lines @@
 }
 
 AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntryMap::const_iterator i = audio_entries_.find(stream_id);
   return i != audio_entries_.end() ? i->second : NULL;
 }
 
 }  // namespace content