Session restore: Add UMA metrics for recording how many tabs were loaded in parallel.

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2012 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.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
@@ skipping 141 matching lines @@
   RenderWidgetHostSet render_widget_hosts_to_paint_;
 
   // The number of tabs that have been restored.
   int tab_count_;
 
   base::OneShotTimer<TabLoader> force_load_timer_;
 
   // The time the restore process started.
   base::TimeTicks restore_started_;
 
+  // Max number of tabs that were loaded in parallel (for metrics).
+  size_t max_parallel_tab_loads_;
+
   DISALLOW_COPY_AND_ASSIGN(TabLoader);
 };
 
 TabLoader::TabLoader(base::TimeTicks restore_started)
     : force_load_delay_(kInitialDelayTimerMS),
       loading_(false),
       got_first_paint_(false),
       tab_count_(0),
-      restore_started_(restore_started) {
+      restore_started_(restore_started),
+      max_parallel_tab_loads_(0) {
 }
 
 TabLoader::~TabLoader() {
   DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
           tabs_loading_.empty() && tabs_to_load_.empty());
   net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
 }
 
 void TabLoader::ScheduleLoad(NavigationController* controller) {
   DCHECK(controller);
@@ skipping 28 matching lines @@
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
     DCHECK(tab);
     tabs_loading_.insert(tab);
+    if (tabs_loading_.size() > max_parallel_tab_loads_)
+      max_parallel_tab_loads_ = tabs_loading_.size();
     tabs_to_load_.pop_front();
     tab->LoadIfNecessary();
     if (tab->GetWebContents()) {
       int tab_index;
       Browser* browser = Browser::GetBrowserForController(tab, &tab_index);
       if (browser && browser->active_index() != tab_index) {
         // By default tabs are marked as visible. As only the active tab is
         // visible we need to explicitly tell non-active tabs they are hidden.
         // Without this call non-active tabs are not marked as backgrounded.
         //
@@ skipping 168 matching lines @@
     std::string time_for_count =
         base::StringPrintf("SessionRestore.AllTabsLoaded_%d", tab_count_);
     base::Histogram* 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(time_to_load);
+
+    UMA_HISTOGRAM_COUNTS_100("SessionRestore.ParallelTabLoads",

[sky, 2012/03/27 17:04:34]

Would it be better to do this in the destructor?

[marja, 2012/03/27 18:37:48]

Hmm, why? The other "finished tab loading" -related metrics are here, too.

[sky, 2012/03/27 20:10:10]

I was assuming you only cared about the max number. Is that not the case?

+                             max_parallel_tab_loads_);
   }
 }
 
 // SessionRestoreImpl ---------------------------------------------------------
 
 // SessionRestoreImpl is responsible for fetching the set of tabs to create
 // from SessionService. SessionRestoreImpl deletes itself when done.
 
 class SessionRestoreImpl : public content::NotificationObserver {
  public:
@@ skipping 594 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }