Add experiment to disable loading of background tabs during session restore.

chrome/browser/sessions/session_restore_stats_collector.cc

 // 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.h"
 #include "base/strings/stringprintf.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"
 
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 // static
 void SessionRestoreStatsCollector::TrackTabs(
     const std::vector<SessionRestoreDelegate::RestoredTab>& tabs,
-    const base::TimeTicks& restore_started) {
+    const base::TimeTicks& restore_started,
+    bool active_only) {
   if (!shared_collector_)
-    shared_collector_ = new SessionRestoreStatsCollector(restore_started);
+    shared_collector_ =
+        new SessionRestoreStatsCollector(restore_started, active_only);
 
   shared_collector_->AddTabs(tabs);
 }
 
 SessionRestoreStatsCollector::SessionRestoreStatsCollector(
-    const base::TimeTicks& restore_started)
+    const base::TimeTicks& restore_started,
+    bool active_only)
     : got_first_foreground_load_(false),
       got_first_paint_(false),
       restore_started_(restore_started),
       tab_count_(0),
-      max_parallel_tab_loads_(0) {
+      max_parallel_tab_loads_(0),
+      active_only_(active_only) {
   this_retainer_ = this;
   registrar_.Add(
       this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
       content::NotificationService::AllSources());
 }
 
 SessionRestoreStatsCollector::~SessionRestoreStatsCollector() {
   DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
          tabs_tracked_.empty() && render_widget_hosts_loading_.empty());
   DCHECK(shared_collector_ == this);
@@ skipping 109 matching lines @@
 
   // Check if we are done and if so, reset |this_retainer_| as the collector no
   // longer needs to stay alive.
   if ((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
       tabs_tracked_.empty() && render_widget_hosts_loading_.empty())
     this_retainer_ = nullptr;
 }
 
 void SessionRestoreStatsCollector::AddTabs(
     const std::vector<SessionRestoreDelegate::RestoredTab>& tabs) {
+  tab_count_ += tabs.size();
   for (auto& tab : tabs) {
+    // If we are only restoring active tabs and the tab is not active, nothing
+    // to do.
+    if (active_only_ && !tab.is_active)

[sky, 2015/04/03 22:04:46]

Actually, one nit. Pass active_only to this function and nuke the field.

+      continue;
     RegisterForNotifications(&tab.contents->GetController());
     if (tab.is_active) {
       RenderWidgetHost* render_widget_host =
           GetRenderWidgetHost(&tab.contents->GetController());
       render_widget_hosts_loading_.insert(render_widget_host);
     }
   }
 }
 
 void SessionRestoreStatsCollector::RemoveTab(NavigationController* tab) {
@@ skipping 34 matching lines @@
 }
 
 void SessionRestoreStatsCollector::RegisterForNotifications(
     NavigationController* tab) {
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::Source<WebContents>(tab->GetWebContents()));
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::Source<NavigationController>(tab));
   registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                  content::Source<NavigationController>(tab));
-  ++tab_count_;
   tabs_tracked_.insert(tab);
 }
 
 RenderWidgetHost* SessionRestoreStatsCollector::GetRenderWidgetHost(
     NavigationController* tab) {
   WebContents* web_contents = tab->GetWebContents();
   if (web_contents) {
     content::RenderWidgetHostView* render_widget_host_view =
         web_contents->GetRenderWidgetHostView();
     if (render_widget_host_view)
       return render_widget_host_view->GetRenderWidgetHost();
   }
   return nullptr;
 }
 
 // static
 SessionRestoreStatsCollector* SessionRestoreStatsCollector::shared_collector_ =
     nullptr;