| // Copyright 2015 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/sessions/session_restore_stats_collector.h" |
| |
| #include <string> |
| |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/time/default_tick_clock.h" |
| #include "chrome/browser/engagement/site_engagement_service.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "content/public/browser/navigation_controller.h" |
| #include "content/public/browser/navigation_entry.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/browser/notification_types.h" |
| #include "content/public/browser/render_widget_host_view.h" |
| #include "content/public/browser/web_contents.h" |
| |
| namespace { |
| |
| using content::NavigationController; |
| using content::RenderWidgetHost; |
| using content::RenderWidgetHostView; |
| using content::Source; |
| using content::WebContents; |
| |
| // The enumeration values stored in the "SessionRestore.Actions" histogram. |
| enum SessionRestoreActionsUma { |
| // Counts the total number of session restores that have occurred. |
| SESSION_RESTORE_ACTIONS_UMA_INITIATED = 0, |
| // Counts the number of session restores that have seen deferred tab loadings |
| // for whatever reason (almost certainly due to memory pressure). |
| SESSION_RESTORE_ACTIONS_UMA_DEFERRED_TABS = 1, |
| // The size of this enum. Must be the last entry. |
| SESSION_RESTORE_ACTIONS_UMA_MAX, |
| }; |
| |
| // Emits a SessionRestore.Actions UMA event. |
| void EmitUmaSessionRestoreActionEvent(SessionRestoreActionsUma action) { |
| UMA_HISTOGRAM_ENUMERATION("SessionRestore.Actions", action, |
| SESSION_RESTORE_ACTIONS_UMA_MAX); |
| } |
| |
| // The enumeration of values stored in the "SessionRestore.TabActions" |
| // histogram. |
| enum SessionRestoreTabActionsUma { |
| // Incremented for each tab created in a session restore. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_CREATED = 0, |
| // Incremented for each tab that session restore decides not to load. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOADING_DEFERRED = 1, |
| // Incremented for each tab that is successfully loaded. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOADED = 2, |
| // Incremented for each session-restore-deferred tab that is subsequently |
| // loaded. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_DEFERRED_TAB_LOADED = 3, |
| // Incremented for each tab that starts loading due to the session restore. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOAD_STARTED = 4, |
| // The size of this enum. Must be the last entry. |
| SESSION_RESTORE_TAB_ACTIONS_UMA_MAX, |
| }; |
| |
| // Emits a SessionRestore.TabActions UMA event. |
| void EmitUmaSessionRestoreTabActionEvent(SessionRestoreTabActionsUma action) { |
| UMA_HISTOGRAM_ENUMERATION("SessionRestore.TabActions", action, |
| SESSION_RESTORE_TAB_ACTIONS_UMA_MAX); |
| } |
| |
| // Returns the RenderWidgetHostView associated with a NavigationController. |
| RenderWidgetHostView* GetRenderWidgetHostView( |
| NavigationController* tab) { |
| WebContents* web_contents = tab->GetWebContents(); |
| if (web_contents) |
| return web_contents->GetRenderWidgetHostView(); |
| return nullptr; |
| } |
| |
| // Returns the RenderWidgetHost associated with a NavigationController. |
| RenderWidgetHost* GetRenderWidgetHost( |
| NavigationController* tab) { |
| content::RenderWidgetHostView* render_widget_host_view = |
| GetRenderWidgetHostView(tab); |
| if (render_widget_host_view) |
| return render_widget_host_view->GetRenderWidgetHost(); |
| return nullptr; |
| } |
| |
| // Determines if the RenderWidgetHostView associated with a given |
| // NavigationController is visible. |
| bool IsShowing(NavigationController* tab) { |
| content::RenderWidgetHostView* render_widget_host_view = |
| GetRenderWidgetHostView(tab); |
| return render_widget_host_view && render_widget_host_view->IsShowing(); |
| } |
| |
| } // namespace |
| |
| SessionRestoreStatsCollector::TabLoaderStats::TabLoaderStats() |
| : tab_count(0u), |
| tabs_deferred(0u), |
| tabs_load_started(0u), |
| tabs_loaded(0u), |
| tab_first_paint_reason(PAINT_FINISHED_UMA_MAX) {} |
| |
| SessionRestoreStatsCollector::TabState::TabState( |
| NavigationController* controller) |
| : controller(controller), |
| is_deferred(false), |
| was_hidden_or_occluded(false), |
| loading_state(TAB_IS_NOT_LOADING), |
| observed_host(nullptr) {} |
| |
| SessionRestoreStatsCollector::SessionRestoreStatsCollector( |
| const base::TimeTicks& restore_started, |
| std::unique_ptr<StatsReportingDelegate> reporting_delegate) |
| : done_tracking_non_deferred_tabs_(false), |
| got_first_foreground_load_(false), |
| waiting_for_first_paint_(true), |
| non_restored_tab_painted_first_(false), |
| hidden_or_occluded_tab_ignored_(false), |
| restore_started_(restore_started), |
| waiting_for_load_tab_count_(0u), |
| loading_tab_count_(0u), |
| deferred_tab_count_(0u), |
| tick_clock_(new base::DefaultTickClock()), |
| reporting_delegate_(std::move(reporting_delegate)) { |
| this_retainer_ = this; |
| } |
| |
| SessionRestoreStatsCollector::~SessionRestoreStatsCollector() { |
| } |
| |
| void SessionRestoreStatsCollector::TrackTabs( |
| const std::vector<SessionRestoreDelegate::RestoredTab>& tabs) { |
| // Anytime new tabs are added, they are immediately "non deferred". |
| done_tracking_non_deferred_tabs_ = false; |
| |
| // If this is the first call to TrackTabs then start observing events. |
| if (tab_loader_stats_.tab_count == 0) { |
| registrar_.Add( |
| this, |
| content::NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_VISUAL_PROPERTIES, |
| content::NotificationService::AllSources()); |
| } |
| |
| const base::TimeTicks now = base::TimeTicks::Now(); |
| tab_loader_stats_.tab_count += tabs.size(); |
| waiting_for_load_tab_count_ += tabs.size(); |
| for (const auto& tab : tabs) { |
| // Report the time since the tab was active. If the tab is visible the |
| // last active time is right now, so report zero. |
| base::TimeDelta time_since_active; |
| if (tab.contents()->GetVisibility() != content::Visibility::VISIBLE) |
| time_since_active = now - tab.contents()->GetLastActiveTime(); |
| reporting_delegate_->ReportTabTimeSinceActive(time_since_active); |
| |
| // Get the active navigation entry. Restored tabs should always have one. |
| auto* controller = &tab.contents()->GetController(); |
| auto* nav_entry = |
| controller->GetEntryAtIndex(controller->GetCurrentEntryIndex()); |
| DCHECK(nav_entry); |
| |
| // Report the site engagement score for the restored tab. |
| auto* engagement_svc = SiteEngagementService::Get( |
| Profile::FromBrowserContext(tab.contents()->GetBrowserContext())); |
| double engagement = |
| engagement_svc->GetDetails(nav_entry->GetURL()).total_score; |
| reporting_delegate_->ReportTabSiteEngagementScore(engagement); |
| |
| TabState* tab_state = RegisterForNotifications(controller); |
| // The tab might already be loading if it is active in a visible window. |
| if (!controller->NeedsReload()) |
| MarkTabAsLoading(tab_state); |
| } |
| } |
| |
| void SessionRestoreStatsCollector::DeferTab(NavigationController* tab) { |
| TabState* tab_state = GetTabState(tab); |
| |
| // If the tab is no longer being tracked it has already finished loading. |
| // This can occur if the user forces the tab to load before the entire session |
| // restore is over, and the TabLoader then decides it would defer loading of |
| // that tab. |
| if (!tab_state) |
| return; |
| |
| // Mark this tab as deferred, if its still being tracked. A tab should not be |
| // marked as deferred twice. |
| DCHECK(!tab_state->is_deferred); |
| tab_state->is_deferred = true; |
| ++deferred_tab_count_; |
| ++tab_loader_stats_.tabs_deferred; |
| |
| // A tab that didn't start loading before it was deferred is not to be |
| // actively monitored for loading. |
| if (tab_state->loading_state == TAB_IS_NOT_LOADING) { |
| DCHECK_LT(0u, waiting_for_load_tab_count_); |
| if (--waiting_for_load_tab_count_ == 0) |
| ReleaseIfDoneTracking(); |
| } |
| |
| reporting_delegate_->ReportTabDeferred(); |
| } |
| |
| void SessionRestoreStatsCollector::OnWillLoadNextTab(bool timeout) { |
| UMA_HISTOGRAM_BOOLEAN("SessionRestore.TabLoadTimeout", timeout); |
| } |
| |
| void SessionRestoreStatsCollector::Observe( |
| int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) { |
| switch (type) { |
| case content::NOTIFICATION_LOAD_START: { |
| // This occurs when a tab has started to load. This can be because of |
| // the tab loader (only for non-deferred tabs) or because the user clicked |
| // on the tab. |
| NavigationController* tab = Source<NavigationController>(source).ptr(); |
| TabState* tab_state = GetTabState(tab); |
| MarkTabAsLoading(tab_state); |
| break; |
| } |
| case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: { |
| // This happens when a tab has been closed. A tab can be in any state |
| // when this occurs. Simply stop tracking the tab. |
| WebContents* web_contents = Source<WebContents>(source).ptr(); |
| NavigationController* tab = &web_contents->GetController(); |
| RemoveTab(tab); |
| break; |
| } |
| case content::NOTIFICATION_LOAD_STOP: { |
| // This occurs to loading tabs when they have finished loading. The tab |
| // may or may not already have painted at this point. |
| |
| // Update the tab state and any global state as necessary. |
| NavigationController* tab = Source<NavigationController>(source).ptr(); |
| TabState* tab_state = GetTabState(tab); |
| DCHECK(tab_state); |
| tab_state->loading_state = TAB_IS_LOADED; |
| DCHECK_LT(0u, loading_tab_count_); |
| --loading_tab_count_; |
| if (!tab_state->is_deferred) { |
| DCHECK_LT(0u, waiting_for_load_tab_count_); |
| --waiting_for_load_tab_count_; |
| } |
| |
| if (tab_state->is_deferred) { |
| reporting_delegate_->ReportDeferredTabLoaded(); |
| } else { |
| DCHECK(!done_tracking_non_deferred_tabs_); |
| ++tab_loader_stats_.tabs_loaded; |
| } |
| |
| // Update statistics for foreground tabs. |
| base::TimeDelta time_to_load = tick_clock_->NowTicks() - restore_started_; |
| if (!got_first_foreground_load_ && IsShowing(tab_state->controller)) { |
| got_first_foreground_load_ = true; |
| DCHECK(!done_tracking_non_deferred_tabs_); |
| tab_loader_stats_.foreground_tab_first_loaded = time_to_load; |
| } |
| |
| // Update statistics for all tabs, if this wasn't a deferred tab. This is |
| // done here and not in ReleaseIfDoneTracking because it is possible to |
| // wait for a paint long after all loads have completed. |
| if (!done_tracking_non_deferred_tabs_ && !tab_state->is_deferred) |
| tab_loader_stats_.non_deferred_tabs_loaded = time_to_load; |
| |
| // By default tabs transition to being tracked for paint events after the |
| // load event has been seen. However, if the first paint event has already |
| // been seen then this is not necessary and the tab can be removed. |
| if (!waiting_for_first_paint_) |
| RemoveTab(tab); |
| |
| break; |
| } |
| case content:: |
| NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_VISUAL_PROPERTIES: { |
| // This notification is across all tabs in the browser so notifications |
| // will arrive for tabs that the collector is not explicitly tracking. |
| |
| // Only process this event if first paint hasn't been seen and this is a |
| // paint of a tab that has not been hidden or occluded. |
| RenderWidgetHost* render_widget_host = |
| Source<RenderWidgetHost>(source).ptr(); |
| if (waiting_for_first_paint_ && render_widget_host->GetView() && |
| render_widget_host->GetView()->IsShowing()) { |
| TabState* tab_state = GetTabState(render_widget_host); |
| if (tab_state) { |
| // Ignore first paint of a restored tab that was hidden or occluded |
| // before first paint. If an other restored tab is painted, its |
| // paint time will be recorded. |
| if (tab_state->was_hidden_or_occluded) { |
| hidden_or_occluded_tab_ignored_ = true; |
| break; |
| } |
| // This is a paint for a tab that is explicitly being tracked so |
| // update the statistics. Otherwise the host is for a tab that's not |
| // being tracked. Thus some other tab has visibility and has rendered |
| // and there's no point in tracking the time to first paint. This can |
| // happen because the user opened a different tab or restored tabs |
| // to an already existing browser and an existing tab was in the |
| // foreground. |
| base::TimeDelta time_to_paint = |
| tick_clock_->NowTicks() - restore_started_; |
| DCHECK(!done_tracking_non_deferred_tabs_); |
| tab_loader_stats_.foreground_tab_first_paint = time_to_paint; |
| } else { |
| non_restored_tab_painted_first_ = true; |
| } |
| waiting_for_first_paint_ = false; |
| |
| // Once first paint has been observed the entire to-paint tracking |
| // mechanism is no longer needed. |
| registrar_.Remove( |
| this, |
| content:: |
| NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_VISUAL_PROPERTIES, |
| content::NotificationService::AllSources()); |
| |
| // Remove any tabs that have loaded. These were only being kept around |
| // while waiting for a paint event. |
| std::vector<NavigationController*> loaded_tabs; |
| for (auto& map_entry : tabs_tracked_) { |
| TabState& tab_state = map_entry.second; |
| if (tab_state.loading_state == TAB_IS_LOADED) |
| loaded_tabs.push_back(tab_state.controller); |
| } |
| for (auto* tab : loaded_tabs) |
| RemoveTab(tab); |
| } |
| break; |
| } |
| default: |
| NOTREACHED() << "Unknown notification received:" << type; |
| break; |
| } |
| |
| ReleaseIfDoneTracking(); |
| } |
| |
| void SessionRestoreStatsCollector::RenderWidgetHostVisibilityChanged( |
| content::RenderWidgetHost* widget_host, |
| bool became_visible) { |
| auto* tab_state = GetTabState(widget_host); |
| if (tab_state && !became_visible) |
| tab_state->was_hidden_or_occluded = true; |
| } |
| |
| void SessionRestoreStatsCollector::RenderWidgetHostDestroyed( |
| content::RenderWidgetHost* widget_host) { |
| auto* tab_state = GetTabState(widget_host); |
| if (tab_state) { |
| observer_.Remove(tab_state->observed_host); |
| tab_state->observed_host = nullptr; |
| } |
| } |
| |
| void SessionRestoreStatsCollector::RemoveTab(NavigationController* tab) { |
| // Stop observing this tab. |
| registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED, |
| Source<WebContents>(tab->GetWebContents())); |
| registrar_.Remove(this, content::NOTIFICATION_LOAD_STOP, |
| Source<NavigationController>(tab)); |
| registrar_.Remove(this, content::NOTIFICATION_LOAD_START, |
| Source<NavigationController>(tab)); |
| auto tab_it = tabs_tracked_.find(tab); |
| DCHECK(tab_it != tabs_tracked_.end()); |
| TabState& tab_state = tab_it->second; |
| if (tab_state.observed_host) |
| observer_.Remove(tab_state.observed_host); |
| |
| // If this tab was waiting for a NOTIFICATION_LOAD_STOP event then update |
| // the loading counts. |
| if (tab_state.loading_state == TAB_IS_LOADING) { |
| DCHECK_LT(0u, loading_tab_count_); |
| --loading_tab_count_; |
| } |
| |
| // Only non-deferred not-loading/not-loaded tabs are waiting to be loaded. |
| if (tab_state.loading_state != TAB_IS_LOADED && !tab_state.is_deferred) { |
| DCHECK_LT(0u, waiting_for_load_tab_count_); |
| // It's possible for waiting_for_load_tab_count_ to reach zero here. This |
| // function is only called from 'Observe', so the transition will be |
| // noticed there. |
| --waiting_for_load_tab_count_; |
| } |
| |
| if (tab_state.is_deferred) |
| --deferred_tab_count_; |
| |
| // Remove the tab from the tabs_tracked_| map. |
| tabs_tracked_.erase(tab_it); |
| |
| // It is possible for all restored contents to be destroyed or forcibly |
| // renavigated before a first paint has arrived. This can be detected by |
| // tabs_tracked_ containing only deferred tabs. At this point the paint |
| // mechanism can be disabled and stats collection will stop. |
| if (tabs_tracked_.size() == deferred_tab_count_ && waiting_for_first_paint_) { |
| waiting_for_first_paint_ = false; |
| registrar_.Remove( |
| this, |
| content::NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_VISUAL_PROPERTIES, |
| content::NotificationService::AllSources()); |
| } |
| } |
| |
| SessionRestoreStatsCollector::TabState* |
| SessionRestoreStatsCollector::RegisterForNotifications( |
| NavigationController* tab) { |
| registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED, |
| Source<WebContents>(tab->GetWebContents())); |
| registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, |
| Source<NavigationController>(tab)); |
| registrar_.Add(this, content::NOTIFICATION_LOAD_START, |
| Source<NavigationController>(tab)); |
| auto result = tabs_tracked_.insert(std::make_pair(tab, TabState(tab))); |
| DCHECK(result.second); |
| TabState* tab_state = &result.first->second; |
| // Register for RenderWidgetHostVisibilityChanged notifications for this tab. |
| tab_state->observed_host = GetRenderWidgetHost(tab); |
| if (tab_state->observed_host) |
| observer_.Add(tab_state->observed_host); |
| return tab_state; |
| } |
| |
| SessionRestoreStatsCollector::TabState* |
| SessionRestoreStatsCollector::GetTabState(NavigationController* tab) { |
| // This lookup can fail because DeferTab calls can arrive for tabs that have |
| // already loaded (user forced) and are no longer tracked. |
| auto it = tabs_tracked_.find(tab); |
| if (it == tabs_tracked_.end()) |
| return nullptr; |
| return &it->second; |
| } |
| |
| SessionRestoreStatsCollector::TabState* |
| SessionRestoreStatsCollector::GetTabState(RenderWidgetHost* tab) { |
| for (auto& pair : tabs_tracked_) { |
| if (pair.second.observed_host == tab) |
| return &pair.second; |
| } |
| // It's possible for this lookup to fail as paint events can be received for |
| // tabs that aren't being tracked. |
| return nullptr; |
| } |
| |
| void SessionRestoreStatsCollector::MarkTabAsLoading(TabState* tab_state) { |
| // If the tab has already started or finished loading then a user navigation |
| // has caused the tab to be forcibly reloaded. This tab can be removed from |
| // observation. |
| if (tab_state->loading_state == TAB_IS_LOADED) { |
| RemoveTab(tab_state->controller); |
| return; |
| } |
| |
| DCHECK_EQ(TAB_IS_NOT_LOADING, tab_state->loading_state); |
| if (tab_state->loading_state != TAB_IS_NOT_LOADING) |
| return; |
| tab_state->loading_state = TAB_IS_LOADING; |
| ++loading_tab_count_; |
| |
| if (!done_tracking_non_deferred_tabs_) |
| ++tab_loader_stats_.tabs_load_started; |
| } |
| |
| void SessionRestoreStatsCollector::ReleaseIfDoneTracking() { |
| // If non-deferred tabs are no longer being tracked then report tab loader |
| // statistics. |
| if (!done_tracking_non_deferred_tabs_ && !waiting_for_first_paint_ && |
| waiting_for_load_tab_count_ == 0) { |
| done_tracking_non_deferred_tabs_ = true; |
| if (!tab_loader_stats_.foreground_tab_first_paint.is_zero()) { |
| tab_loader_stats_.tab_first_paint_reason = PAINT_FINISHED_UMA_DONE; |
| } else if (non_restored_tab_painted_first_) { |
| tab_loader_stats_.tab_first_paint_reason = |
| PAINT_FINISHED_NON_RESTORED_TAB_PAINTED_FIRST; |
| } else if (hidden_or_occluded_tab_ignored_) { |
| tab_loader_stats_.tab_first_paint_reason = |
| PAINT_FINISHED_UMA_NO_COMPLETELY_VISIBLE_TABS; |
| } else { |
| tab_loader_stats_.tab_first_paint_reason = PAINT_FINISHED_UMA_NO_PAINT; |
| } |
| reporting_delegate_->ReportTabLoaderStats(tab_loader_stats_); |
| } |
| |
| // If tracking is completely finished then emit collected metrics and destroy |
| // this stats collector. |
| if (done_tracking_non_deferred_tabs_ && tabs_tracked_.empty()) |
| this_retainer_ = nullptr; |
| } |
| |
| SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| UmaStatsReportingDelegate() |
| : got_report_tab_deferred_(false) { |
| } |
| |
| void SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| ReportTabLoaderStats(const TabLoaderStats& tab_loader_stats) { |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount", |
| tab_loader_stats.tab_count); |
| |
| // Emit suffix specializations of the SessionRestore.TabCount metric. |
| if (tab_loader_stats.tabs_deferred) { |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount_MemoryPressure", |
| tab_loader_stats.tab_count); |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount_MemoryPressure_Loaded", |
| tab_loader_stats.tabs_loaded); |
| UMA_HISTOGRAM_COUNTS_100( |
| "SessionRestore.TabCount_MemoryPressure_LoadStarted", |
| tab_loader_stats.tabs_load_started); |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount_MemoryPressure_Deferred", |
| tab_loader_stats.tabs_deferred); |
| } else { |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount_NoMemoryPressure", |
| tab_loader_stats.tab_count); |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.TabCount_NoMemoryPressure_Loaded", |
| tab_loader_stats.tabs_loaded); |
| UMA_HISTOGRAM_COUNTS_100( |
| "SessionRestore.TabCount_NoMemoryPressure_LoadStarted", |
| tab_loader_stats.tabs_load_started); |
| } |
| |
| EmitUmaSessionRestoreActionEvent(SESSION_RESTORE_ACTIONS_UMA_INITIATED); |
| |
| for (size_t i = 0; i < tab_loader_stats.tab_count; ++i) { |
| EmitUmaSessionRestoreTabActionEvent( |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_CREATED); |
| } |
| |
| for (size_t i = 0; i < tab_loader_stats.tabs_loaded; ++i) { |
| EmitUmaSessionRestoreTabActionEvent( |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOADED); |
| } |
| |
| for (size_t i = 0; i < tab_loader_stats.tabs_load_started; ++i) { |
| EmitUmaSessionRestoreTabActionEvent( |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOAD_STARTED); |
| } |
| |
| if (!tab_loader_stats.foreground_tab_first_loaded.is_zero()) { |
| UMA_HISTOGRAM_CUSTOM_TIMES("SessionRestore.ForegroundTabFirstLoaded", |
| tab_loader_stats.foreground_tab_first_loaded, |
| base::TimeDelta::FromMilliseconds(10), |
| base::TimeDelta::FromSeconds(100), 100); |
| |
| // Record a time for the number of tabs, to help track down contention. |
| std::string time_for_count = base::StringPrintf( |
| "SessionRestore.ForegroundTabFirstLoaded_%u", |
| static_cast<unsigned int>(tab_loader_stats.tab_count)); |
| base::HistogramBase* counter_for_count = base::Histogram::FactoryTimeGet( |
| time_for_count, base::TimeDelta::FromMilliseconds(10), |
| base::TimeDelta::FromSeconds(100), 100, |
| base::Histogram::kUmaTargetedHistogramFlag); |
| counter_for_count->AddTime(tab_loader_stats.foreground_tab_first_loaded); |
| } |
| |
| if (!tab_loader_stats.foreground_tab_first_paint.is_zero()) { |
| UMA_HISTOGRAM_CUSTOM_TIMES("SessionRestore.ForegroundTabFirstPaint4", |
| tab_loader_stats.foreground_tab_first_paint, |
| base::TimeDelta::FromMilliseconds(100), |
| base::TimeDelta::FromMinutes(16), 50); |
| |
| std::string time_for_count = base::StringPrintf( |
| "SessionRestore.ForegroundTabFirstPaint4_%u", |
| static_cast<unsigned int>(tab_loader_stats.tab_count)); |
| base::HistogramBase* counter_for_count = base::Histogram::FactoryTimeGet( |
| time_for_count, base::TimeDelta::FromMilliseconds(100), |
| base::TimeDelta::FromMinutes(16), 50, |
| base::Histogram::kUmaTargetedHistogramFlag); |
| counter_for_count->AddTime(tab_loader_stats.foreground_tab_first_paint); |
| } |
| UMA_HISTOGRAM_ENUMERATION( |
| "SessionRestore.ForegroundTabFirstPaint4.FinishReason", |
| tab_loader_stats.tab_first_paint_reason, PAINT_FINISHED_UMA_MAX); |
| |
| if (!tab_loader_stats.non_deferred_tabs_loaded.is_zero()) { |
| UMA_HISTOGRAM_CUSTOM_TIMES("SessionRestore.AllTabsLoaded", |
| tab_loader_stats.non_deferred_tabs_loaded, |
| base::TimeDelta::FromMilliseconds(10), |
| base::TimeDelta::FromSeconds(100), 100); |
| |
| // Record a time for the number of tabs, to help track down contention. |
| std::string time_for_count = base::StringPrintf( |
| "SessionRestore.AllTabsLoaded_%u", |
| static_cast<unsigned int>(tab_loader_stats.tab_count)); |
| base::HistogramBase* counter_for_count = base::Histogram::FactoryTimeGet( |
| time_for_count, base::TimeDelta::FromMilliseconds(10), |
| base::TimeDelta::FromSeconds(100), 100, |
| base::Histogram::kUmaTargetedHistogramFlag); |
| counter_for_count->AddTime(tab_loader_stats.non_deferred_tabs_loaded); |
| } |
| } |
| |
| void SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| ReportTabDeferred() { |
| if (!got_report_tab_deferred_) { |
| got_report_tab_deferred_ = true; |
| EmitUmaSessionRestoreActionEvent(SESSION_RESTORE_ACTIONS_UMA_DEFERRED_TABS); |
| } |
| |
| EmitUmaSessionRestoreTabActionEvent( |
| SESSION_RESTORE_TAB_ACTIONS_UMA_TAB_LOADING_DEFERRED); |
| } |
| |
| void SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| ReportDeferredTabLoaded() { |
| EmitUmaSessionRestoreTabActionEvent( |
| SESSION_RESTORE_TAB_ACTIONS_UMA_DEFERRED_TAB_LOADED); |
| } |
| |
| void SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| ReportTabTimeSinceActive(base::TimeDelta elapsed) { |
| UMA_HISTOGRAM_CUSTOM_TIMES("SessionRestore.RestoredTab.TimeSinceActive", |
| elapsed, base::TimeDelta::FromSeconds(10), |
| base::TimeDelta::FromDays(7), 100); |
| } |
| |
| void SessionRestoreStatsCollector::UmaStatsReportingDelegate:: |
| ReportTabSiteEngagementScore(double engagement) { |
| // This metric uses the same reporting format (no rounding, histogram shape) |
| // as the equivalent SiteEngagementService.EngagementScore. See |
| // site_engagement_metrics.cc for details. |
| UMA_HISTOGRAM_COUNTS_100("SessionRestore.RestoredTab.SiteEngagementScore", |
| engagement); |
| } |
