From f962a274ea399bb6db39cb8df734ac05c2a1053b Mon Sep 17 00:00:00 2001 From: Kuo-Hsin Yang Date: Mon, 7 Mar 2022 18:49:03 +0000 Subject: [PATCH] Add daily discard/reload histograms Add histograms Discarding.Daily{Discards|Reloads}.{Extension|Urgent}. These discard/reload histograms are reported per calendar day. (cherry picked from commit 26bdf5595f96d337a2f29157e07f9e8da177fa37) Bug: b:205905993 Change-Id: I3f8c526913c4e18a0f3d2349c026620017e58add Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3460191 Reviewed-by: Yusuke Sato Reviewed-by: Francois Pierre Doray Reviewed-by: Olivier Li Shing Tat-Dupuis Reviewed-by: Olivier Li Commit-Queue: Vovo Yang Cr-Original-Commit-Position: refs/heads/main@{#973054} Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3505724 Auto-Submit: Vovo Yang Commit-Queue: Olivier Li Cr-Commit-Position: refs/branch-heads/4896@{#341} Cr-Branched-From: 1f63ff4bc27570761b35ffbc7f938f6586f7bee8-refs/heads/main@{#972766} --- .../metrics/tab_stats/tab_stats_data_store.cc | 53 ++++++++++- .../metrics/tab_stats/tab_stats_data_store.h | 21 +++++ .../tab_stats_data_store_unittest.cc | 44 +++++++++ .../metrics/tab_stats/tab_stats_tracker.cc | 47 ++++++++++ .../metrics/tab_stats/tab_stats_tracker.h | 19 +++- .../tab_stats/tab_stats_tracker_unittest.cc | 93 +++++++++++++++++++ chrome/common/pref_names.cc | 6 ++ chrome/common/pref_names.h | 4 + .../histograms/metadata/tab/histograms.xml | 32 +++++++ 9 files changed, 317 insertions(+), 2 deletions(-) diff --git a/chrome/browser/metrics/tab_stats/tab_stats_data_store.cc b/chrome/browser/metrics/tab_stats/tab_stats_data_store.cc index da5d1a1d48ee0a..92a2a7742706ab 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_data_store.cc +++ b/chrome/browser/metrics/tab_stats/tab_stats_data_store.cc @@ -8,6 +8,7 @@ #include #include "base/containers/contains.h" +#include "base/notreached.h" #include "chrome/browser/ui/browser.h" #include "chrome/browser/ui/browser_list.h" #include "chrome/browser/ui/tabs/tab_strip_model.h" @@ -33,7 +34,10 @@ TabStatsDataStore::TabsStats::TabsStats() total_tab_count_max(0U), max_tab_per_window(0U), window_count(0U), - window_count_max(0U) {} + window_count_max(0U) { + tab_discard_counts.fill(0U); + tab_reload_counts.fill(0U); +} TabStatsDataStore::TabsStats::TabsStats(const TabsStats& other) = default; TabStatsDataStore::TabsStats& TabStatsDataStore::TabsStats::operator=( const TabsStats& other) = default; @@ -47,6 +51,20 @@ TabStatsDataStore::TabStatsDataStore(PrefService* pref_service) pref_service->GetInteger(::prefs::kTabStatsMaxTabsPerWindow); tab_stats_.window_count_max = pref_service->GetInteger(::prefs::kTabStatsWindowCountMax); + + // Loads discard/reload counters. + tab_stats_.tab_discard_counts[static_cast( + LifecycleUnitDiscardReason::EXTERNAL)] = + pref_service->GetInteger(::prefs::kTabStatsDiscardsExternal); + tab_stats_.tab_discard_counts[static_cast( + LifecycleUnitDiscardReason::URGENT)] = + pref_service->GetInteger(::prefs::kTabStatsDiscardsUrgent); + tab_stats_.tab_reload_counts[static_cast( + LifecycleUnitDiscardReason::EXTERNAL)] = + pref_service->GetInteger(::prefs::kTabStatsReloadsExternal); + tab_stats_.tab_reload_counts[static_cast( + LifecycleUnitDiscardReason::URGENT)] = + pref_service->GetInteger(::prefs::kTabStatsReloadsUrgent); } TabStatsDataStore::~TabStatsDataStore() {} @@ -179,6 +197,39 @@ void TabStatsDataStore::ResetIntervalData( AddTabToIntervalMap(iter.first, GetTabID(iter.first), true, interval_map); } +void TabStatsDataStore::OnTabDiscardStateChange( + LifecycleUnitDiscardReason discard_reason, + bool is_discarded) { + size_t discard_reason_index = static_cast(discard_reason); + size_t& count = is_discarded + ? tab_stats_.tab_discard_counts[discard_reason_index] + : tab_stats_.tab_reload_counts[discard_reason_index]; + count++; + switch (discard_reason) { + case LifecycleUnitDiscardReason::EXTERNAL: + if (is_discarded) + pref_service_->SetInteger(::prefs::kTabStatsDiscardsExternal, count); + else + pref_service_->SetInteger(::prefs::kTabStatsReloadsExternal, count); + break; + case LifecycleUnitDiscardReason::URGENT: + if (is_discarded) + pref_service_->SetInteger(::prefs::kTabStatsDiscardsUrgent, count); + else + pref_service_->SetInteger(::prefs::kTabStatsReloadsUrgent, count); + break; + } +} + +void TabStatsDataStore::ClearTabDiscardAndReloadCounts() { + tab_stats_.tab_discard_counts.fill(0U); + tab_stats_.tab_reload_counts.fill(0U); + pref_service_->SetInteger(::prefs::kTabStatsDiscardsExternal, 0); + pref_service_->SetInteger(::prefs::kTabStatsDiscardsUrgent, 0); + pref_service_->SetInteger(::prefs::kTabStatsReloadsExternal, 0); + pref_service_->SetInteger(::prefs::kTabStatsReloadsUrgent, 0); +} + absl::optional TabStatsDataStore::GetTabIDForTesting( content::WebContents* web_contents) { if (!base::Contains(existing_tabs_, web_contents)) diff --git a/chrome/browser/metrics/tab_stats/tab_stats_data_store.h b/chrome/browser/metrics/tab_stats/tab_stats_data_store.h index e4182d536a8f29..6a3628b160d99d 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_data_store.h +++ b/chrome/browser/metrics/tab_stats/tab_stats_data_store.h @@ -5,6 +5,7 @@ #ifndef CHROME_BROWSER_METRICS_TAB_STATS_TAB_STATS_DATA_STORE_H_ #define CHROME_BROWSER_METRICS_TAB_STATS_TAB_STATS_DATA_STORE_H_ +#include #include #include @@ -58,6 +59,16 @@ class TabStatsDataStore : public TabStatsObserver { // The maximum total number of windows opened at the same time. size_t window_count_max; + + // The number of tabs discarded, per discard reason. + std::array(LifecycleUnitDiscardReason::kMaxValue) + 1> + tab_discard_counts; + + // The number of tabs reloaded after a discard, per discard reason. + std::array(LifecycleUnitDiscardReason::kMaxValue) + 1> + tab_reload_counts; }; // Structure describing the state of a tab during an interval of time. @@ -118,6 +129,16 @@ class TabStatsDataStore : public TabStatsObserver { // Reset |interval_map| with the list of current tabs. void ResetIntervalData(TabsStateDuringIntervalMap* interval_map); + // Updates discard/reload counts when the discarded state of a tab changes. + // Updates the discard count when is_discarded is true. Updates the reload + // count when is_discarded is false. + void OnTabDiscardStateChange(LifecycleUnitDiscardReason discard_reason, + bool is_discarded); + + // Clears the discard and reload counters. Called after reporting the counter + // values. + void ClearTabDiscardAndReloadCounts(); + const TabsStats& tab_stats() const { return tab_stats_; } absl::optional GetTabIDForTesting(content::WebContents* web_contents); base::flat_map* existing_tabs_for_testing() { diff --git a/chrome/browser/metrics/tab_stats/tab_stats_data_store_unittest.cc b/chrome/browser/metrics/tab_stats/tab_stats_data_store_unittest.cc index c5189efa94a17a..972cc667447be1 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_data_store_unittest.cc +++ b/chrome/browser/metrics/tab_stats/tab_stats_data_store_unittest.cc @@ -69,6 +69,50 @@ TEST_F(TabStatsDataStoreTest, TabStatsGetsReloadedFromLocalState) { EXPECT_EQ(0U, stats2.total_tab_count); } +TEST_F(TabStatsDataStoreTest, DiscardsFromLocalState) { + // This test updates the discard/reload counts to a data store instance and + // then reinitialize it. The data store instance should restore the discard + // and reload counts from the pref service. + constexpr size_t kExpectedDiscardsExternal = 3; + constexpr size_t kExpectedDiscardsUrgent = 5; + constexpr size_t kExpectedReloadsExternal = 8; + constexpr size_t kExpectedReloadsUrgent = 13; + for (size_t i = 0; i < kExpectedDiscardsExternal; ++i) { + data_store_->OnTabDiscardStateChange(LifecycleUnitDiscardReason::EXTERNAL, + /*is_discarded=*/true); + } + for (size_t i = 0; i < kExpectedDiscardsUrgent; ++i) { + data_store_->OnTabDiscardStateChange(LifecycleUnitDiscardReason::URGENT, + /*is_discarded=*/true); + } + for (size_t i = 0; i < kExpectedReloadsExternal; ++i) { + data_store_->OnTabDiscardStateChange(LifecycleUnitDiscardReason::EXTERNAL, + /*is_discarded=*/false); + } + for (size_t i = 0; i < kExpectedReloadsUrgent; ++i) { + data_store_->OnTabDiscardStateChange(LifecycleUnitDiscardReason::URGENT, + /*is_discarded=*/false); + } + + const size_t external = + static_cast(LifecycleUnitDiscardReason::EXTERNAL); + const size_t urgent = static_cast(LifecycleUnitDiscardReason::URGENT); + TabsStats stats = data_store_->tab_stats(); + EXPECT_EQ(kExpectedDiscardsExternal, stats.tab_discard_counts[external]); + EXPECT_EQ(kExpectedDiscardsUrgent, stats.tab_discard_counts[urgent]); + EXPECT_EQ(kExpectedReloadsExternal, stats.tab_reload_counts[external]); + EXPECT_EQ(kExpectedReloadsUrgent, stats.tab_reload_counts[urgent]); + + // Resets the |data_store_| and checks discard/reload counters are restored. + data_store_ = std::make_unique(&pref_service_); + + TabsStats stats2 = data_store_->tab_stats(); + EXPECT_EQ(kExpectedDiscardsExternal, stats2.tab_discard_counts[external]); + EXPECT_EQ(kExpectedDiscardsUrgent, stats2.tab_discard_counts[urgent]); + EXPECT_EQ(kExpectedReloadsExternal, stats2.tab_reload_counts[external]); + EXPECT_EQ(kExpectedReloadsUrgent, stats2.tab_reload_counts[urgent]); +} + TEST_F(TabStatsDataStoreTest, TrackTabUsageDuringInterval) { std::vector> web_contents_vec; for (size_t i = 0; i < 3; ++i) { diff --git a/chrome/browser/metrics/tab_stats/tab_stats_tracker.cc b/chrome/browser/metrics/tab_stats/tab_stats_tracker.cc index 25b476f3d65701..99d02195d664c8 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_tracker.cc +++ b/chrome/browser/metrics/tab_stats/tab_stats_tracker.cc @@ -133,6 +133,16 @@ const char TabStatsTracker::UmaStatsReportingDelegate::kCollapsedTabHistogramName[] = "TabGroups.CollapsedTabCount"; +// Daily discard/reload histograms. +const char TabStatsTracker::UmaStatsReportingDelegate:: + kDailyDiscardsExternalHistogramName[] = "Discarding.DailyDiscards.External"; +const char TabStatsTracker::UmaStatsReportingDelegate:: + kDailyDiscardsUrgentHistogramName[] = "Discarding.DailyDiscards.Urgent"; +const char TabStatsTracker::UmaStatsReportingDelegate:: + kDailyReloadsExternalHistogramName[] = "Discarding.DailyReloads.External"; +const char TabStatsTracker::UmaStatsReportingDelegate:: + kDailyReloadsUrgentHistogramName[] = "Discarding.DailyReloads.Urgent"; + const TabStatsDataStore::TabsStats& TabStatsTracker::tab_stats() const { return tab_stats_data_store_->tab_stats(); } @@ -205,12 +215,15 @@ TabStatsTracker::TabStatsTracker(PrefService* pref_service) heartbeat_timer_.Start(FROM_HERE, kTabsHeartbeatReportingInterval, base::BindRepeating(&TabStatsTracker::OnHeartbeatEvent, base::Unretained(this))); + + g_browser_process->GetTabManager()->AddObserver(this); } TabStatsTracker::~TabStatsTracker() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); BrowserList::GetInstance()->RemoveObserver(this); base::PowerMonitor::RemovePowerSuspendObserver(this); + g_browser_process->GetTabManager()->RemoveObserver(this); } // static @@ -252,6 +265,12 @@ void TabStatsTracker::RegisterPrefs(PrefRegistrySimple* registry) { registry->RegisterIntegerPref(::prefs::kTabStatsMaxTabsPerWindow, 0); registry->RegisterIntegerPref(::prefs::kTabStatsWindowCountMax, 0); DailyEvent::RegisterPref(registry, ::prefs::kTabStatsDailySample); + + // Preferences for saving discard/reload counts. + registry->RegisterIntegerPref(::prefs::kTabStatsDiscardsExternal, 0); + registry->RegisterIntegerPref(::prefs::kTabStatsDiscardsUrgent, 0); + registry->RegisterIntegerPref(::prefs::kTabStatsReloadsExternal, 0); + registry->RegisterIntegerPref(::prefs::kTabStatsReloadsUrgent, 0); } void TabStatsTracker::SetDelegateForTesting( @@ -263,6 +282,7 @@ void TabStatsTracker::TabStatsDailyObserver::OnDailyEvent( DailyEvent::IntervalType type) { reporting_delegate_->ReportDailyMetrics(data_store_->tab_stats()); data_store_->ResetMaximumsToCurrentState(); + data_store_->ClearTabDiscardAndReloadCounts(); } class TabStatsTracker::WebContentsUsageObserver @@ -442,6 +462,19 @@ void TabStatsTracker::OnResume() { tab_stats_data_store_->tab_stats().total_tab_count); } +// resource_coordinator::TabLifecycleObserver: +void TabStatsTracker::OnDiscardedStateChange( + content::WebContents* contents, + ::mojom::LifecycleUnitDiscardReason reason, + bool is_discarded) { + // Increment the count in the data store for tabs metrics reporting. + tab_stats_data_store_->OnTabDiscardStateChange(reason, is_discarded); +} + +void TabStatsTracker::OnAutoDiscardableStateChange( + content::WebContents* contents, + bool is_auto_discardable) {} + void TabStatsTracker::OnInterval( base::TimeDelta interval, TabStatsDataStore::TabsStateDuringIntervalMap* interval_map) { @@ -509,6 +542,20 @@ void TabStatsTracker::UmaStatsReportingDelegate::ReportDailyMetrics( kMaxTabsPerWindowInADayHistogramName, tab_stats.max_tab_per_window); UmaHistogramCounts10000WithBatteryStateVariant(kMaxWindowsInADayHistogramName, tab_stats.window_count_max); + + // Reports the discard/reload counts. + const size_t external_index = + static_cast(LifecycleUnitDiscardReason::EXTERNAL); + const size_t urgent_index = + static_cast(LifecycleUnitDiscardReason::URGENT); + base::UmaHistogramCounts10000(kDailyDiscardsExternalHistogramName, + tab_stats.tab_discard_counts[external_index]); + base::UmaHistogramCounts10000(kDailyDiscardsUrgentHistogramName, + tab_stats.tab_discard_counts[urgent_index]); + base::UmaHistogramCounts10000(kDailyReloadsExternalHistogramName, + tab_stats.tab_reload_counts[external_index]); + base::UmaHistogramCounts10000(kDailyReloadsUrgentHistogramName, + tab_stats.tab_reload_counts[urgent_index]); } void TabStatsTracker::UmaStatsReportingDelegate::ReportHeartbeatMetrics( diff --git a/chrome/browser/metrics/tab_stats/tab_stats_tracker.h b/chrome/browser/metrics/tab_stats/tab_stats_tracker.h index ecf065e75a271d..8b9179ac4d2ad9 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_tracker.h +++ b/chrome/browser/metrics/tab_stats/tab_stats_tracker.h @@ -19,6 +19,7 @@ #include "build/build_config.h" #include "chrome/browser/metrics/tab_stats/tab_stats_data_store.h" #include "chrome/browser/metrics/tab_stats/tab_stats_tracker_delegate.h" +#include "chrome/browser/resource_coordinator/tab_lifecycle_observer.h" #include "chrome/browser/ui/browser_list_observer.h" #include "chrome/browser/ui/tabs/tab_strip_model_observer.h" #include "components/metrics/daily_event.h" @@ -39,7 +40,8 @@ FORWARD_DECLARE_TEST(TabStatsTrackerBrowserTest, // std::make_unique(g_browser_process->local_state())); class TabStatsTracker : public TabStripModelObserver, public BrowserListObserver, - public base::PowerSuspendObserver { + public base::PowerSuspendObserver, + public resource_coordinator::TabLifecycleObserver { public: // Constructor. |pref_service| must outlive this object. explicit TabStatsTracker(PrefService* pref_service); @@ -157,6 +159,14 @@ class TabStatsTracker : public TabStripModelObserver, // base::PowerSuspendObserver: void OnResume() override; + // resource_coordinator::TabLifecycleObserver: + void OnDiscardedStateChange(content::WebContents* contents, + ::mojom::LifecycleUnitDiscardReason reason, + bool is_discarded) override; + + void OnAutoDiscardableStateChange(content::WebContents* contents, + bool is_auto_discardable) override; + // Callback when an interval timer triggers. void OnInterval(base::TimeDelta interval, TabStatsDataStore::TabsStateDuringIntervalMap* interval_map); @@ -263,6 +273,13 @@ class TabStatsTracker::UmaStatsReportingDelegate { // The name of the histogram that records the number of collapsed tabs. static const char kCollapsedTabHistogramName[]; + // The names of the histograms that record daily discard/reload counts caused + // by external/urgent event. + static const char kDailyDiscardsExternalHistogramName[]; + static const char kDailyDiscardsUrgentHistogramName[]; + static const char kDailyReloadsExternalHistogramName[]; + static const char kDailyReloadsUrgentHistogramName[]; + UmaStatsReportingDelegate() = default; UmaStatsReportingDelegate(const UmaStatsReportingDelegate&) = delete; diff --git a/chrome/browser/metrics/tab_stats/tab_stats_tracker_unittest.cc b/chrome/browser/metrics/tab_stats/tab_stats_tracker_unittest.cc index ab2e5f1ff5cdc1..d72ee240c9312e 100644 --- a/chrome/browser/metrics/tab_stats/tab_stats_tracker_unittest.cc +++ b/chrome/browser/metrics/tab_stats/tab_stats_tracker_unittest.cc @@ -111,6 +111,14 @@ class TestTabStatsTracker : public TabStatsTracker { return tab_stats_data_store()->tab_stats().window_count; } + void DiscardedStateChange(ChromeRenderViewHostTestHarness* test_harness, + ::mojom::LifecycleUnitDiscardReason reason, + bool is_discarded) { + std::unique_ptr tab = + test_harness->CreateTestWebContents(); + OnDiscardedStateChange(tab.get(), reason, is_discarded); + } + void CheckDailyEventInterval() { daily_event_for_testing()->CheckInterval(); } void TriggerDailyEvent() { @@ -408,6 +416,91 @@ TEST_F(TabStatsTrackerTest, StatsGetReportedDaily) { stats.window_count_max, 1); } +TEST_F(TabStatsTrackerTest, DailyDiscards) { + // This test checks that the discard/reload counts are reported when the + // daily event triggers. + + // Daily report is skipped when there is no tab. Adds tabs to avoid that. + tab_stats_tracker_->AddTabs(1, this, tab_strip_model_); + + constexpr size_t kExpectedDiscardsExternal = 3; + constexpr size_t kExpectedDiscardsUrgent = 5; + constexpr size_t kExpectedReloadsExternal = 7; + constexpr size_t kExpectedReloadsUrgent = 9; + for (size_t i = 0; i < kExpectedDiscardsExternal; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::EXTERNAL, /*is_discarded*/ true); + } + for (size_t i = 0; i < kExpectedDiscardsUrgent; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::URGENT, /*is_discarded*/ true); + } + for (size_t i = 0; i < kExpectedReloadsExternal; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::EXTERNAL, /*is_discarded*/ false); + } + for (size_t i = 0; i < kExpectedReloadsUrgent; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::URGENT, /*is_discarded*/ false); + } + + // Triggers the daily event. + tab_stats_tracker_->TriggerDailyEvent(); + + // Checks that the histograms have been properly updated. + histogram_tester_.ExpectUniqueSample( + UmaStatsReportingDelegate::kDailyDiscardsExternalHistogramName, + kExpectedDiscardsExternal, 1); + histogram_tester_.ExpectUniqueSample( + UmaStatsReportingDelegate::kDailyDiscardsUrgentHistogramName, + kExpectedDiscardsUrgent, 1); + histogram_tester_.ExpectUniqueSample( + UmaStatsReportingDelegate::kDailyReloadsExternalHistogramName, + kExpectedReloadsExternal, 1); + histogram_tester_.ExpectUniqueSample( + UmaStatsReportingDelegate::kDailyReloadsUrgentHistogramName, + kExpectedReloadsUrgent, 1); + + // Checks that the second report also updates the histograms properly. + constexpr size_t kExpectedDiscardsExternal2 = 15; + constexpr size_t kExpectedDiscardsUrgent2 = 25; + constexpr size_t kExpectedReloadsExternal2 = 35; + constexpr size_t kExpectedReloadsUrgent2 = 45; + for (size_t i = 0; i < kExpectedDiscardsExternal2; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::EXTERNAL, /*is_discarded=*/true); + } + for (size_t i = 0; i < kExpectedDiscardsUrgent2; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::URGENT, /*is_discarded=*/true); + } + for (size_t i = 0; i < kExpectedReloadsExternal2; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::EXTERNAL, /*is_discarded=*/false); + } + for (size_t i = 0; i < kExpectedReloadsUrgent2; ++i) { + tab_stats_tracker_->DiscardedStateChange( + this, LifecycleUnitDiscardReason::URGENT, /*is_discarded=*/false); + } + + // Triggers the daily event again. + tab_stats_tracker_->TriggerDailyEvent(); + + // Checks that the histograms have been properly updated. + histogram_tester_.ExpectBucketCount( + UmaStatsReportingDelegate::kDailyDiscardsExternalHistogramName, + kExpectedDiscardsExternal2, 1); + histogram_tester_.ExpectBucketCount( + UmaStatsReportingDelegate::kDailyDiscardsUrgentHistogramName, + kExpectedDiscardsUrgent2, 1); + histogram_tester_.ExpectBucketCount( + UmaStatsReportingDelegate::kDailyReloadsExternalHistogramName, + kExpectedReloadsExternal2, 1); + histogram_tester_.ExpectBucketCount( + UmaStatsReportingDelegate::kDailyReloadsUrgentHistogramName, + kExpectedReloadsUrgent2, 1); +} + TEST_F(TabStatsTrackerTest, TabUsageGetsReported) { constexpr base::TimeDelta kValidLongInterval = base::Hours(12); TabStatsDataStore::TabsStateDuringIntervalMap* interval_map = diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc index e220b6141840cd..5b61aa306e6002 100644 --- a/chrome/common/pref_names.cc +++ b/chrome/common/pref_names.cc @@ -3079,6 +3079,12 @@ const char kTabStatsWindowCountMax[] = "tab_stats.window_count_max"; // Timestamp of the last time the tab stats daily metrics have been reported. const char kTabStatsDailySample[] = "tab_stats.last_daily_sample"; +// Discards/Reloads since last daily report. +const char kTabStatsDiscardsExternal[] = "tab_stats.discards_external"; +const char kTabStatsDiscardsUrgent[] = "tab_stats.discards_urgent"; +const char kTabStatsReloadsExternal[] = "tab_stats.reloads_external"; +const char kTabStatsReloadsUrgent[] = "tab_stats.reloads_urgent"; + // A list of origins (URLs) to treat as "secure origins" for debugging purposes. const char kUnsafelyTreatInsecureOriginAsSecure[] = "unsafely_treat_insecure_origin_as_secure"; diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h index c3c8139c6612dd..85ef4f9d07315b 100644 --- a/chrome/common/pref_names.h +++ b/chrome/common/pref_names.h @@ -1048,6 +1048,10 @@ extern const char kTabStatsTotalTabCountMax[]; extern const char kTabStatsMaxTabsPerWindow[]; extern const char kTabStatsWindowCountMax[]; extern const char kTabStatsDailySample[]; +extern const char kTabStatsDiscardsExternal[]; +extern const char kTabStatsDiscardsUrgent[]; +extern const char kTabStatsReloadsExternal[]; +extern const char kTabStatsReloadsUrgent[]; extern const char kUnsafelyTreatInsecureOriginAsSecure[]; diff --git a/tools/metrics/histograms/metadata/tab/histograms.xml b/tools/metrics/histograms/metadata/tab/histograms.xml index 968487601683d3..d8bbd2124a9554 100644 --- a/tools/metrics/histograms/metadata/tab/histograms.xml +++ b/tools/metrics/histograms/metadata/tab/histograms.xml @@ -45,6 +45,14 @@ chromium-metrics-reviews@google.com. blank link. e.g. tehchmeme.com will create tabs this way."/> + + + + + + + vovoy@chromium.org + fdoray@chromium.org + + The number of tabs discards since last emit. The emit interval is at least + 24 hours, see metrics::DailyEvent for more details. The discards are + requested {TabDiscardReason}. + + + + + + vovoy@chromium.org + fdoray@chromium.org + + The number of tabs reloads since last emit. The emit interval is at least 24 + hours, see metrics::DailyEvent for more details. The discards corresponding + to the reloads are requested {TabDiscardReason}. + + + + chrisha@chromium.org