[AudioStreamMonitor] Adds API to collect frame-level audibility.

content/browser/media/audio_stream_monitor_unittest.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/browser/media/audio_stream_monitor.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
@@ skipping 12 matching lines @@
 using ::testing::InvokeWithoutArgs;
 
 namespace content {
 
 namespace {
 
 const int kRenderProcessId = 1;
 const int kAnotherRenderProcessId = 2;
 const int kStreamId = 3;
 const int kAnotherStreamId = 6;
+const int kRenderFrameId = 4;
+const int kAnotherRenderFrameId = 8;
 
 // Used to confirm audio indicator state changes occur at the correct times.
 class MockWebContentsDelegate : public WebContentsDelegate {
  public:
   MOCK_METHOD2(NavigationStateChanged,
                void(WebContents* source, InvalidateTypes changed_flags));
 };
 
 }  // namespace
 
@@ skipping 26 matching lines @@
   }
 
   void SetStreamPower(int stream_id, float power) {
     current_power_[stream_id] = power;
   }
 
   void SimulatePollTimerFired() { monitor_->Poll(); }
 
   void SimulateOffTimerFired() { monitor_->MaybeToggle(); }
 
-  void ExpectIsPolling(int render_process_id, int stream_id, bool is_polling) {
-    const AudioStreamMonitor::StreamID key(render_process_id, stream_id);
+  void ExpectIsPolling(int render_process_id,
+                       int render_frame_id,
+                       int stream_id,
+                       bool is_polling) {
+    const AudioStreamMonitor::StreamID key = {render_process_id,
+                                              render_frame_id, stream_id};
     EXPECT_EQ(is_polling, monitor_->poll_callbacks_.find(key) !=
                               monitor_->poll_callbacks_.end());
     EXPECT_EQ(!monitor_->poll_callbacks_.empty(),
               power_level_monitoring_available()
                   ? monitor_->poll_timer_.IsRunning()
                   : monitor_->IsCurrentlyAudible());
   }
 
   void ExpectTabWasRecentlyAudible(bool was_audible,
                                    const base::TimeTicks& last_blurt_time) {
@@ skipping 42 matching lines @@
            static_cast<int>(AudioStreamMonitor::kPowerMeasurementsPerSecond);
   }
 
   static base::TimeDelta holding_period() {
     return base::TimeDelta::FromMilliseconds(
         AudioStreamMonitor::kHoldOnMilliseconds);
   }
 
   void StartMonitoring(
       int render_process_id,
+      int render_frame_id,
       int stream_id,
       const AudioStreamMonitor::ReadPowerAndClipCallback& callback) {
     if (!power_level_monitoring_available() &&
         monitor_->poll_callbacks_.empty()) {
       ExpectCurrentlyAudibleChangeNotification(true);
     }
-    monitor_->StartMonitoringStreamOnUIThread(render_process_id, stream_id,
-                                              callback);
+    monitor_->StartMonitoringStreamOnUIThread(
+        render_process_id, render_frame_id, stream_id, callback);
   }
 
-  void StopMonitoring(int render_process_id, int stream_id) {
+  void StopMonitoring(int render_process_id,
+                      int render_frame_id,
+                      int stream_id) {
     if (!power_level_monitoring_available() &&
         monitor_->poll_callbacks_.size() == 1u) {
       ExpectCurrentlyAudibleChangeNotification(false);
     }
-    monitor_->StopMonitoringStreamOnUIThread(render_process_id, stream_id);
+    monitor_->StopMonitoringStreamOnUIThread(render_process_id, render_frame_id,
+                                             stream_id);
   }
 
   bool power_level_monitoring_available() {
     return AudioStreamMonitor::power_level_monitoring_available();
   }
 
  protected:
   AudioStreamMonitor* monitor_;
 
  private:
@@ skipping 17 matching lines @@
 };
 
 // Tests that AudioStreamMonitor is polling while it has a
 // ReadPowerAndClipCallback, and is not polling at other times.
 TEST_F(AudioStreamMonitorTest, PollsWhenProvidedACallback) {
   if (!power_level_monitoring_available())
     return;
 
   EXPECT_FALSE(monitor_->WasRecentlyAudible());
   ExpectNotCurrentlyAudible();
-  ExpectIsPolling(kRenderProcessId, kStreamId, false);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, false);
 
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
   EXPECT_FALSE(monitor_->WasRecentlyAudible());
   ExpectNotCurrentlyAudible();
-  ExpectIsPolling(kRenderProcessId, kStreamId, true);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, true);
 
-  StopMonitoring(kRenderProcessId, kStreamId);
+  StopMonitoring(kRenderProcessId, kRenderFrameId, kStreamId);
   EXPECT_FALSE(monitor_->WasRecentlyAudible());
   ExpectNotCurrentlyAudible();
-  ExpectIsPolling(kRenderProcessId, kStreamId, false);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, false);
 }
 
 // Tests that AudioStreamMonitor debounces the power level readings it's taking,
 // which could be fluctuating rapidly between the audible versus silence
 // threshold.  See comments in audio_stream_monitor.h for expected behavior.
 TEST_F(AudioStreamMonitorTest,
        ImpulsesKeepIndicatorOnUntilHoldingPeriodHasPassed) {
   if (!power_level_monitoring_available())
     return;
 
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
 
   // Expect WebContents will get one call form AudioStreamMonitor to toggle the
   // indicator on upon the very first poll.
   ExpectRecentlyAudibleChangeNotification(true);
 
   // Loop, each time testing a slightly longer period of polled silence.  The
   // recently audible state should not change while the currently audible one
   // should.
   int num_silence_polls = 1;
   base::TimeTicks last_blurt_time;
@@ skipping 34 matching lines @@
     AdvanceClock(one_polling_interval());
   }
 }
 
 // Tests that the AudioStreamMonitor correctly processes the blurts from two
 // different streams in the same tab.
 TEST_F(AudioStreamMonitorTest, HandlesMultipleStreamsBlurting) {
   if (!power_level_monitoring_available())
     return;
 
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
-  StartMonitoring(
-      kRenderProcessId, kAnotherStreamId, CreatePollCallback(kAnotherStreamId));
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
+  StartMonitoring(kRenderProcessId, kAnotherRenderFrameId, kAnotherStreamId,
+                  CreatePollCallback(kAnotherStreamId));
 
   base::TimeTicks last_blurt_time;
   ExpectTabWasRecentlyAudible(false, last_blurt_time);
   ExpectNotCurrentlyAudible();
 
   // Measure audible sound from the first stream and silence from the second.
   // The tab becomes audible.
   ExpectRecentlyAudibleChangeNotification(true);
   ExpectCurrentlyAudibleChangeNotification(true);
 
@@ skipping 63 matching lines @@
   // silent.
   for (int i = 0; i < 100; ++i) {
     AdvanceClock(one_polling_interval());
     SimulatePollTimerFired();
     ExpectTabWasRecentlyAudible(false, last_blurt_time);
     ExpectNotCurrentlyAudible();
   }
 }
 
 TEST_F(AudioStreamMonitorTest, MultipleRendererProcesses) {
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
-  StartMonitoring(
-      kAnotherRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
-  ExpectIsPolling(kRenderProcessId, kStreamId, true);
-  ExpectIsPolling(kAnotherRenderProcessId, kStreamId, true);
-  StopMonitoring(kAnotherRenderProcessId, kStreamId);
-  ExpectIsPolling(kRenderProcessId, kStreamId, true);
-  ExpectIsPolling(kAnotherRenderProcessId, kStreamId, false);
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
+  StartMonitoring(kAnotherRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, true);
+  ExpectIsPolling(kAnotherRenderProcessId, kRenderFrameId, kStreamId, true);
+  StopMonitoring(kAnotherRenderProcessId, kRenderFrameId, kStreamId);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, true);
+  ExpectIsPolling(kAnotherRenderProcessId, kRenderFrameId, kStreamId, false);
 }
 
 TEST_F(AudioStreamMonitorTest, RenderProcessGone) {
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
-  StartMonitoring(kAnotherRenderProcessId, kStreamId,
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
                   CreatePollCallback(kStreamId));
-  ExpectIsPolling(kRenderProcessId, kStreamId, true);
-  ExpectIsPolling(kAnotherRenderProcessId, kStreamId, true);
+  StartMonitoring(kAnotherRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, true);
+  ExpectIsPolling(kAnotherRenderProcessId, kRenderFrameId, kStreamId, true);
   monitor_->RenderProcessGone(kRenderProcessId);
-  ExpectIsPolling(kRenderProcessId, kStreamId, false);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, false);
   if (!power_level_monitoring_available())
     ExpectCurrentlyAudibleChangeNotification(false);
   monitor_->RenderProcessGone(kAnotherRenderProcessId);
-  ExpectIsPolling(kAnotherRenderProcessId, kStreamId, false);
+  ExpectIsPolling(kAnotherRenderProcessId, kRenderFrameId, kStreamId, false);
 }
 
 TEST_F(AudioStreamMonitorTest, NoPowerLevelMonitoring) {
   if (power_level_monitoring_available())
     return;
 
   ExpectNotCurrentlyAudible();
-  StartMonitoring(kRenderProcessId, kStreamId, CreatePollCallback(kStreamId));
-  ExpectIsCurrentlyAudible();
-  ExpectIsPolling(kRenderProcessId, kStreamId, true);
-
-  StartMonitoring(kAnotherRenderProcessId, kStreamId,
+  StartMonitoring(kRenderProcessId, kRenderFrameId, kStreamId,
                   CreatePollCallback(kStreamId));
   ExpectIsCurrentlyAudible();
-  ExpectIsPolling(kAnotherRenderProcessId, kStreamId, true);
+  ExpectIsPolling(kRenderProcessId, kRenderFrameId, kStreamId, true);
 
-  StopMonitoring(kRenderProcessId, kStreamId);
+  StartMonitoring(kAnotherRenderProcessId, kRenderFrameId, kStreamId,
+                  CreatePollCallback(kStreamId));
   ExpectIsCurrentlyAudible();
-  StopMonitoring(kAnotherRenderProcessId, kStreamId);
+  ExpectIsPolling(kAnotherRenderProcessId, kRenderFrameId, kStreamId, true);
+
+  StopMonitoring(kRenderProcessId, kRenderFrameId, kStreamId);
+  ExpectIsCurrentlyAudible();
+  StopMonitoring(kAnotherRenderProcessId, kRenderFrameId, kStreamId);
   ExpectNotCurrentlyAudible();
 }
 
 }  // namespace content