chrome/browser/metrics/tab_stats_tracker_unittest.cc

// Copyright 2017 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 "chrome/browser/metrics/tab_stats_tracker.h"

#include <algorithm>

#include "base/test/metrics/histogram_tester.h"
#include "base/test/power_monitor_test_base.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/chrome_render_view_host_test_harness.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/testing_pref_service.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/web_contents_tester.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace metrics {

namespace {

using TabsStats = TabStatsDataStore::TabsStats;

class TestTabStatsTracker : public TabStatsTracker {
 public:
  using TabStatsTracker::OnInitialOrInsertedTab;
  using TabStatsTracker::OnInterval;
  using TabStatsTracker::OnHeartbeatEvent;
  using TabStatsTracker::TabChangedAt;
  using UmaStatsReportingDelegate = TabStatsTracker::UmaStatsReportingDelegate;

  explicit TestTabStatsTracker(PrefService* pref_service);
  ~TestTabStatsTracker() override {}

  // Helper functions to update the number of tabs/windows.

  size_t AddTabs(size_t tab_count,
                 ChromeRenderViewHostTestHarness* test_harness) {
    EXPECT_TRUE(test_harness);
    for (size_t i = 0; i < tab_count; ++i) {
      std::unique_ptr<content::WebContents> tab =
          test_harness->CreateTestWebContents();
      tab_stats_data_store()->OnTabAdded(tab.get());
      tabs_.emplace_back(std::move(tab));
    }
    return tab_stats_data_store()->tab_stats().total_tab_count;
  }

  size_t RemoveTabs(size_t tab_count) {
    EXPECT_LE(tab_count, tab_stats_data_store()->tab_stats().total_tab_count);
    EXPECT_LE(tab_count, tabs_.size());
    for (size_t i = 0; i < tab_count; ++i) {
      tab_stats_data_store()->OnTabRemoved(tabs_.back().get());
      tabs_.pop_back();
    }
    return tab_stats_data_store()->tab_stats().total_tab_count;
  }

  size_t AddWindows(size_t window_count) {
    for (size_t i = 0; i < window_count; ++i)
      tab_stats_data_store()->OnWindowAdded();
    return tab_stats_data_store()->tab_stats().window_count;
  }

  size_t RemoveWindows(size_t window_count) {
    EXPECT_LE(window_count, tab_stats_data_store()->tab_stats().window_count);
    for (size_t i = 0; i < window_count; ++i)
      tab_stats_data_store()->OnWindowRemoved();
    return tab_stats_data_store()->tab_stats().window_count;
  }

  void CheckDailyEventInterval() { daily_event_for_testing()->CheckInterval(); }

  void TriggerDailyEvent() {
    // Reset the daily event to allow triggering the DailyEvent::OnInterval
    // manually several times in the same test.
    reset_daily_event_for_testing(
        new DailyEvent(pref_service_, prefs::kTabStatsDailySample,
                       kTabStatsDailyEventHistogramName));
    daily_event_for_testing()->AddObserver(
        std::make_unique<TabStatsDailyObserver>(
            reporting_delegate_for_testing(), tab_stats_data_store()));

    // Update the daily event registry to the previous day and trigger it.
    base::Time last_time = base::Time::Now() - base::TimeDelta::FromHours(25);
    pref_service_->SetInt64(prefs::kTabStatsDailySample,
                            last_time.since_origin().InMicroseconds());
    CheckDailyEventInterval();

    // The daily event registry should have been updated.
    EXPECT_NE(last_time.since_origin().InMicroseconds(),
              pref_service_->GetInt64(prefs::kTabStatsDailySample));
  }

  TabStatsDataStore* data_store() { return tab_stats_data_store(); }

 private:
  PrefService* pref_service_;

  std::vector<std::unique_ptr<content::WebContents>> tabs_;

  DISALLOW_COPY_AND_ASSIGN(TestTabStatsTracker);
};

class TestUmaStatsReportingDelegate
    : public TestTabStatsTracker::UmaStatsReportingDelegate {
 public:
  using TestTabStatsTracker::UmaStatsReportingDelegate::
      GetIntervalHistogramName;
  TestUmaStatsReportingDelegate() {}

 protected:
  // Skip the check that ensures that there's at least one visible window as
  // there's no window in the context of these tests.
  bool IsChromeBackgroundedWithoutWindows() override { return false; }

 private:
  DISALLOW_COPY_AND_ASSIGN(TestUmaStatsReportingDelegate);
};

class TabStatsTrackerTest : public ChromeRenderViewHostTestHarness {
 public:
  using UmaStatsReportingDelegate =
      TestTabStatsTracker::UmaStatsReportingDelegate;

  TabStatsTrackerTest() {
    power_monitor_source_ = new base::PowerMonitorTestSource();
    power_monitor_.reset(new base::PowerMonitor(
        std::unique_ptr<base::PowerMonitorSource>(power_monitor_source_)));

    TabStatsTracker::RegisterPrefs(pref_service_.registry());

    // The tab stats tracker has to be created after the power monitor as it's
    // using it.
    tab_stats_tracker_.reset(new TestTabStatsTracker(&pref_service_));
  }

  void TearDown() override {
    tab_stats_tracker_.reset(nullptr);
    ChromeRenderViewHostTestHarness::TearDown();
  }

  // The tabs stat tracker instance, it should be created in the SetUp
  std::unique_ptr<TestTabStatsTracker> tab_stats_tracker_;

  // Used to simulate power events.
  base::PowerMonitorTestSource* power_monitor_source_;
  std::unique_ptr<base::PowerMonitor> power_monitor_;

  // Used to make sure that the metrics are reported properly.
  base::HistogramTester histogram_tester_;

  TestingPrefServiceSimple pref_service_;

 private:
  DISALLOW_COPY_AND_ASSIGN(TabStatsTrackerTest);
};

TestTabStatsTracker::TestTabStatsTracker(PrefService* pref_service)
    : TabStatsTracker(pref_service), pref_service_(pref_service) {
  // Stop the timer to ensure that the stats don't get reported (and reset)
  // while running the tests.
  EXPECT_TRUE(daily_event_timer_for_testing()->IsRunning());
  daily_event_timer_for_testing()->Stop();

  // Stop the usage interval timers so they don't trigger while running the
  // tests.
  usage_interval_timers_for_testing()->clear();

  reset_reporting_delegate_for_testing(new TestUmaStatsReportingDelegate());

  // Stop the heartbeat timer to ensure that it doesn't interfere with the
  // tests.
  heartbeat_timer_for_testing()->Stop();
}

// Comparator for base::Bucket values.
bool CompareHistogramBucket(const base::Bucket& l, const base::Bucket& r) {
  return l.min < r.min;
}

}  // namespace

TEST_F(TabStatsTrackerTest, OnResume) {
  // Makes sure that there's no sample initially.
  histogram_tester_.ExpectTotalCount(
      UmaStatsReportingDelegate::kNumberOfTabsOnResumeHistogramName, 0);

  // Creates some tabs.
  size_t expected_tab_count = tab_stats_tracker_->AddTabs(12, this);

  std::vector<base::Bucket> count_buckets;
  count_buckets.emplace_back(base::Bucket(expected_tab_count, 1));

  // Generates a resume event that should end up calling the
  // |ReportTabCountOnResume| method of the reporting delegate.
  power_monitor_source_->GenerateSuspendEvent();
  power_monitor_source_->GenerateResumeEvent();

  // There should be only one sample for the |kNumberOfTabsOnResume| histogram.
  histogram_tester_.ExpectTotalCount(
      UmaStatsReportingDelegate::kNumberOfTabsOnResumeHistogramName,
      count_buckets.size());
  EXPECT_EQ(histogram_tester_.GetAllSamples(
                UmaStatsReportingDelegate::kNumberOfTabsOnResumeHistogramName),
            count_buckets);

  // Removes some tabs and update the expectations.
  expected_tab_count = tab_stats_tracker_->RemoveTabs(5);
  count_buckets.emplace_back(base::Bucket(expected_tab_count, 1));
  std::sort(count_buckets.begin(), count_buckets.end(), CompareHistogramBucket);

  // Generates another resume event.
  power_monitor_source_->GenerateSuspendEvent();
  power_monitor_source_->GenerateResumeEvent();

  // There should be 2 samples for this metric now.
  histogram_tester_.ExpectTotalCount(
      UmaStatsReportingDelegate::kNumberOfTabsOnResumeHistogramName,
      count_buckets.size());
  EXPECT_EQ(histogram_tester_.GetAllSamples(
                UmaStatsReportingDelegate::kNumberOfTabsOnResumeHistogramName),
            count_buckets);
}

TEST_F(TabStatsTrackerTest, StatsGetReportedDaily) {
  // This test ensures that the stats get reported accurately when the daily
  // event triggers.

  // Adds some tabs and windows, then remove some so the maximums are not equal
  // to the current state.
  size_t expected_tab_count = tab_stats_tracker_->AddTabs(12, this);
  size_t expected_window_count = tab_stats_tracker_->AddWindows(5);
  size_t expected_max_tab_per_window = expected_tab_count - 1;
  tab_stats_tracker_->data_store()->UpdateMaxTabsPerWindowIfNeeded(
      expected_max_tab_per_window);
  expected_tab_count = tab_stats_tracker_->RemoveTabs(5);
  expected_window_count = tab_stats_tracker_->RemoveWindows(2);
  expected_max_tab_per_window = expected_tab_count - 1;

  TabsStats stats = tab_stats_tracker_->data_store()->tab_stats();

  // Trigger the daily event.
  tab_stats_tracker_->TriggerDailyEvent();

  // Ensures that the histograms have been properly updated.
  histogram_tester_.ExpectUniqueSample(
      UmaStatsReportingDelegate::kMaxTabsInADayHistogramName,
      stats.total_tab_count_max, 1);
  histogram_tester_.ExpectUniqueSample(
      UmaStatsReportingDelegate::kMaxTabsPerWindowInADayHistogramName,
      stats.max_tab_per_window, 1);
  histogram_tester_.ExpectUniqueSample(
      UmaStatsReportingDelegate::kMaxWindowsInADayHistogramName,
      stats.window_count_max, 1);

  // Manually call the function to update the maximum number of tabs in a single
  // window. This is normally done automatically in the reporting function by
  // scanning the list of existing windows, but doesn't work here as this isn't
  // a window test.
  tab_stats_tracker_->data_store()->UpdateMaxTabsPerWindowIfNeeded(
      expected_max_tab_per_window);

  // Make sure that the maximum values have been updated to the current state.
  stats = tab_stats_tracker_->data_store()->tab_stats();
  EXPECT_EQ(expected_tab_count, stats.total_tab_count_max);
  EXPECT_EQ(expected_max_tab_per_window, stats.max_tab_per_window);
  EXPECT_EQ(expected_window_count, stats.window_count_max);
  EXPECT_EQ(expected_tab_count, static_cast<size_t>(pref_service_.GetInteger(
                                    prefs::kTabStatsTotalTabCountMax)));
  EXPECT_EQ(expected_max_tab_per_window,
            static_cast<size_t>(
                pref_service_.GetInteger(prefs::kTabStatsMaxTabsPerWindow)));
  EXPECT_EQ(expected_window_count, static_cast<size_t>(pref_service_.GetInteger(
                                       prefs::kTabStatsWindowCountMax)));

  // Trigger the daily event.
  tab_stats_tracker_->TriggerDailyEvent();

  // The values in the histograms should now be equal to the current state.
  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kMaxTabsInADayHistogramName,
      stats.total_tab_count_max, 1);
  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kMaxTabsPerWindowInADayHistogramName,
      stats.max_tab_per_window, 1);
  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kMaxWindowsInADayHistogramName,
      stats.window_count_max, 1);
}

TEST_F(TabStatsTrackerTest, TabUsageGetsReported) {
  constexpr base::TimeDelta kValidLongInterval = base::TimeDelta::FromHours(12);
  TabStatsDataStore::TabsStateDuringIntervalMap* interval_map =
      tab_stats_tracker_->data_store()->AddInterval();

  std::vector<std::unique_ptr<content::WebContents>> web_contentses;
  for (size_t i = 0; i < 4; ++i) {
    web_contentses.emplace_back(CreateTestWebContents());
    // Make sure that these WebContents are initially not visible.
    web_contentses[i]->WasHidden();
    tab_stats_tracker_->OnInitialOrInsertedTab(web_contentses[i].get());
  }

  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);

  histogram_tester_.ExpectUniqueSample(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::
              kUnusedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      0, 1);
  histogram_tester_.ExpectUniqueSample(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUnusedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      web_contentses.size(), 1);
  histogram_tester_.ExpectUniqueSample(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      0, 1);
  histogram_tester_.ExpectUniqueSample(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      0, 1);

  // Mark one tab as visible and make sure that it get reported properly.
  web_contentses[0]->WasShown();
  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::
              kUnusedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      0, 2);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUnusedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      web_contentses.size() - 1, 1);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      0, 2);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      1, 1);

  // Mark a tab as audible and make sure that we now have 2 tabs marked as used.
  content::WebContentsTester::For(web_contentses[1].get())
      ->SetIsCurrentlyAudible(true);
  tab_stats_tracker_->TabChangedAt(web_contentses[1].get(), 1,
                                   TabChangeType::kAll);
  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUnusedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      web_contentses.size() - 2, 1);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      2, 1);

  // Simulate an interaction on a tab, we should now see 3 tabs being marked as
  // used.
  content::WebContentsTester::For(web_contentses[2].get())
      ->TestDidReceiveInputEvent(blink::WebInputEvent::kMouseDown);
  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUnusedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      web_contentses.size() - 3, 1);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedTabsInIntervalHistogramNameBase,
          kValidLongInterval),
      3, 1);

  // Remove the last WebContents, which should be reported as an unused tab.
  web_contentses.pop_back();
  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::
              kUnusedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      1, 1);

  // Remove an active WebContents and make sure that this get reported properly.
  //
  // We need to re-interact with the WebContents as each call to |OnInterval|
  // reset the interval and clear the interaction bit.
  content::WebContentsTester::For(web_contentses.back().get())
      ->TestDidReceiveInputEvent(blink::WebInputEvent::kMouseDown);
  web_contentses.pop_back();
  tab_stats_tracker_->OnInterval(kValidLongInterval, interval_map);
  histogram_tester_.ExpectBucketCount(
      TestUmaStatsReportingDelegate::GetIntervalHistogramName(
          UmaStatsReportingDelegate::kUsedAndClosedInIntervalHistogramNameBase,
          kValidLongInterval),
      1, 1);
}

TEST_F(TabStatsTrackerTest, HeartbeatMetrics) {
  size_t expected_tab_count = tab_stats_tracker_->AddTabs(12, this);
  size_t expected_window_count = tab_stats_tracker_->AddWindows(5);

  tab_stats_tracker_->OnHeartbeatEvent();

  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kTabCountHistogramName, expected_tab_count, 1);
  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kWindowCountHistogramName,
      expected_window_count, 1);

  expected_tab_count = tab_stats_tracker_->RemoveTabs(4);
  expected_window_count = tab_stats_tracker_->RemoveWindows(3);

  tab_stats_tracker_->OnHeartbeatEvent();

  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kTabCountHistogramName, expected_tab_count, 1);
  histogram_tester_.ExpectBucketCount(
      UmaStatsReportingDelegate::kWindowCountHistogramName,
      expected_window_count, 1);
}

}  // namespace metrics