[Audible Metrics] Check for tab muting

We should not record audible tab metrics if the tab
is muted.

BUG=907671

Change-Id: Ie852abb55bf4c0bb7f202bdd774b12ba5291f945
Reviewed-on: https://chromium-review.googlesource.com/c/1346993Reviewed-by: Chrome Cunningham <chcunningham@chromium.org>
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611439}

content/browser/media/audible_metrics.h

@@ -31,6 +31,10 @@ class CONTENT_EXPORT AudibleMetrics {
 
   void SetClockForTest(const base::TickClock* test_clock);
 
+  int GetAudibleWebContentsSizeForTest() const {
+    return audible_web_contents_.size();
+  }
+
  private:
   void AddAudibleWebContents(const WebContents* web_contents);
   void RemoveAudibleWebContents(const WebContents* web_contents);

content/browser/media/audible_metrics_unittest.cc

@@ -8,6 +8,10 @@
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/metrics/user_action_tester.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "content/browser/media/media_web_contents_observer.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/test/test_web_contents.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -31,17 +35,23 @@ class AudibleMetricsTest : public testing::Test {
   AudibleMetricsTest() = default;
 
   void SetUp() override {
+    audible_metrics_ = std::make_unique<AudibleMetrics>();
+    browser_context_ = std::make_unique<TestBrowserContext>();
+
     // Set the clock to a value different than 0 so the time it gives is
     // recognized as initialized.
     clock_.Advance(base::TimeDelta::FromMilliseconds(1));
-    audible_metrics_.SetClockForTest(&clock_);
+    audible_metrics_->SetClockForTest(&clock_);
+  }
+
+  void TearDown() override {
+    audible_metrics_.reset();
+    browser_context_.reset();
   }
 
   base::SimpleTestTickClock* clock() { return &clock_; }
 
-  AudibleMetrics* audible_metrics() {
-    return &audible_metrics_;
-  };
+  AudibleMetrics* audible_metrics() { return audible_metrics_.get(); };
 
   const base::UserActionTester& user_action_tester() const {
     return user_action_tester_;
@@ -52,9 +62,18 @@ class AudibleMetricsTest : public testing::Test {
     return histogram_tester_.GetHistogramSamplesSinceCreation(name);
   }
 
+  std::unique_ptr<WebContentsImpl> CreateWebContents() {
+    return TestWebContents::Create(
+        browser_context_.get(), SiteInstance::Create(browser_context_.get()));
+  }
+
  private:
+  TestBrowserThreadBundle test_browser_thread_bundle_;
+
+  std::unique_ptr<AudibleMetrics> audible_metrics_;
+  std::unique_ptr<TestBrowserContext> browser_context_;
+
   base::SimpleTestTickClock clock_;
-  AudibleMetrics audible_metrics_;
   base::HistogramTester histogram_tester_;
   base::UserActionTester user_action_tester_;
 
@@ -352,4 +371,65 @@ TEST_F(AudibleMetricsTest, ConcurrentTabsTimeRunsAsLongAsTwoAudibleTabs) {
   }
 }
 
+TEST_F(AudibleMetricsTest, MediaWebContentsObserver_Audible_Muted) {
+  std::unique_ptr<WebContentsImpl> web_contents(CreateWebContents());
+  MediaWebContentsObserver media_observer(web_contents.get());
+  media_observer.SetAudibleMetricsForTest(audible_metrics());
+
+  web_contents->SetAudioMuted(true);
+  web_contents->audio_stream_monitor()->set_is_currently_audible_for_testing(
+      true);
+
+  EXPECT_TRUE(web_contents->audio_stream_monitor()->IsCurrentlyAudible());
+  EXPECT_TRUE(web_contents->IsAudioMuted());
+
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+  media_observer.MaybeUpdateAudibleState();
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+}
+
+TEST_F(AudibleMetricsTest, MediaWebContentsObserver_Audible_NotMuted) {
+  std::unique_ptr<WebContentsImpl> web_contents(CreateWebContents());
+  MediaWebContentsObserver media_observer(web_contents.get());
+  media_observer.SetAudibleMetricsForTest(audible_metrics());
+
+  web_contents->audio_stream_monitor()->set_is_currently_audible_for_testing(
+      true);
+
+  EXPECT_TRUE(web_contents->audio_stream_monitor()->IsCurrentlyAudible());
+  EXPECT_FALSE(web_contents->IsAudioMuted());
+
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+  media_observer.MaybeUpdateAudibleState();
+  EXPECT_EQ(1, audible_metrics()->GetAudibleWebContentsSizeForTest());
+}
+
+TEST_F(AudibleMetricsTest, MediaWebContentsObserver_NotAudible_Muted) {
+  std::unique_ptr<WebContentsImpl> web_contents(CreateWebContents());
+  MediaWebContentsObserver media_observer(web_contents.get());
+  media_observer.SetAudibleMetricsForTest(audible_metrics());
+
+  web_contents->SetAudioMuted(true);
+
+  EXPECT_FALSE(web_contents->audio_stream_monitor()->IsCurrentlyAudible());
+  EXPECT_TRUE(web_contents->IsAudioMuted());
+
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+  media_observer.MaybeUpdateAudibleState();
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+}
+
+TEST_F(AudibleMetricsTest, MediaWebContentsObserver_NotAudible_NotMuted) {
+  std::unique_ptr<WebContentsImpl> web_contents(CreateWebContents());
+  MediaWebContentsObserver media_observer(web_contents.get());
+  media_observer.SetAudibleMetricsForTest(audible_metrics());
+
+  EXPECT_FALSE(web_contents->audio_stream_monitor()->IsCurrentlyAudible());
+  EXPECT_FALSE(web_contents->IsAudioMuted());
+
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+  media_observer.MaybeUpdateAudibleState();
+  EXPECT_EQ(0, audible_metrics()->GetAudibleWebContentsSizeForTest());
+}
+
 }  // namespace content

content/browser/media/media_web_contents_observer.cc

@@ -58,12 +58,13 @@ bool MediaPlayerEntryExists(
 
 MediaWebContentsObserver::MediaWebContentsObserver(WebContents* web_contents)
     : WebContentsObserver(web_contents),
+      audible_metrics_(GetAudibleMetrics()),
       session_controllers_manager_(this) {}
 
 MediaWebContentsObserver::~MediaWebContentsObserver() = default;
 
 void MediaWebContentsObserver::WebContentsDestroyed() {
-  GetAudibleMetrics()->UpdateAudibleWebContentsState(web_contents(), false);
+  audible_metrics_->UpdateAudibleWebContentsState(web_contents(), false);
 }
 
 void MediaWebContentsObserver::RenderFrameDeleted(
@@ -92,8 +93,9 @@ void MediaWebContentsObserver::MaybeUpdateAudibleState() {
   else
     CancelAudioLock();
 
-  GetAudibleMetrics()->UpdateAudibleWebContentsState(
-      web_contents(), audio_stream_monitor->IsCurrentlyAudible());
+  audible_metrics_->UpdateAudibleWebContentsState(
+      web_contents(), audio_stream_monitor->IsCurrentlyAudible() &&
+                          !web_contents()->IsAudioMuted());
 }
 
 bool MediaWebContentsObserver::HasActiveEffectivelyFullscreenVideo() const {

content/browser/media/media_web_contents_observer.h

@@ -40,6 +40,8 @@ class SurfaceId;
 
 namespace content {
 
+class AudibleMetrics;
+
 // This class manages all RenderFrame based media related managers at the
 // browser side. It receives IPC messages from media RenderFrameObservers and
 // forwards them to the corresponding managers. The managers are responsible
@@ -106,6 +108,10 @@ class CONTENT_EXPORT MediaWebContentsObserver : public WebContentsObserver {
 
   bool has_video_wake_lock_for_testing() const { return has_video_wake_lock_; }
 
+  void SetAudibleMetricsForTest(AudibleMetrics* audible_metrics) {
+    audible_metrics_ = audible_metrics;
+  }
+
  protected:
   MediaSessionControllersManager* session_controllers_manager() {
     return &session_controllers_manager_;
@@ -181,6 +187,9 @@ class CONTENT_EXPORT MediaWebContentsObserver : public WebContentsObserver {
   // Convenience method that casts web_contents() to a WebContentsImpl*.
   WebContentsImpl* web_contents_impl() const;
 
+  // Helper class for recording audible metrics.
+  AudibleMetrics* audible_metrics_;
+
   // Tracking variables and associated wake locks for media playback.
   ActiveMediaPlayerMap active_audio_players_;
   ActiveMediaPlayerMap active_video_players_;