[Sessions] Add detailed logging of SessionRestore events.

chrome/browser/sessions/tab_loader.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/tab_loader.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/sessions/session_restore_stats_collector.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "components/favicon/content/content_favicon_driver.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ skipping 19 matching lines @@
       break;
     }
     default:
       NOTREACHED() << "Unknown notification received:" << type;
   }
   // Delete ourselves when we are done.
   if (tabs_loading_.empty() && tabs_to_load_.empty())
     this_retainer_ = nullptr;
 }
 
 void TabLoader::SetTabLoadingEnabled(bool enable_tab_loading) {

[sky, 2015/05/12 15:27:56]

This likely needs to invalidate a bunch of histograms too.

[chrisha, 2015/05/13 21:18:02]

No more information is provided at the site of this call then is provided via
the 'DeferTab' calls below. Any histograms that need to be invalidated can be
done so entirely inside of the stats collector.

What histograms did you have in mind, exactly?

[sky, 2015/05/14 00:12:40]

My concern is that any time based histograms are now going to be delayed until
tab loading turns back on. For example, the time to paint would be totally
misleading.

[chrisha, 2015/05/14 21:27:02]

We only track time to first paint, and this concerns itself with the foreground
tab only. Since at least one tab is always loaded (the visible tab), then a
first paint *will* always happen. If a restore has n tabs, and d get deferred,
the stats collector will effectively behave as an "old" stats collector over (n
- d) tabs.

The tab loader will never be "turned back on", as memory pressure is currently
only a one way switch: automatic tab loading stops permanently once memory
pressure is seen.

(Making this a long term observer of memory pressure, and resuming tab loading
is a whole other story, and one that I think we should eventually address. The
session restore becomes less of a concept at that point, and eventually we'll
simply have some kind of session tab manager, which decides when to load tabs,
when to evict them, monitors resources, etc. Probably need an entirely new
approach to metrics at that point.)

   if (enable_tab_loading == loading_enabled_)
     return;
   loading_enabled_ = enable_tab_loading;
   if (loading_enabled_)
     LoadNextTab();
   else
     force_load_timer_.Stop();
 }
 
 // static
@@ skipping 145 matching lines @@
 #endif
 
   // When receiving a resource pressure level warning, we stop pre-loading more
   // tabs since we are running in danger of loading more tabs by throwing out
   // old ones.
   if (tabs_to_load_.empty())
     return;
   // Stop the timer and suppress any tab loads while we clean the list.
   SetTabLoadingEnabled(false);
   while (!tabs_to_load_.empty()) {
-    NavigationController* controller = tabs_to_load_.front();
+    NavigationController* tab = tabs_to_load_.front();
     tabs_to_load_.pop_front();
-    RemoveTab(controller);
+    RemoveTab(tab);
+
+    // Notify the stats collector that a tab's loading has been deferred due to
+    // memory pressure. It's possible for the stats collector to infer this on
+    // its own, but not in the presence of the above experiment, hence this is
+    // explicitly called.
+    // TODO(chrisha): Re-evaluate this was the memory-pressure experiment is
+    // finished.
+    SessionRestoreStatsCollector::DeferTab(tab);
   }
   // By calling |LoadNextTab| explicitly, we make sure that the
   // |NOTIFICATION_SESSION_RESTORE_DONE| event gets sent.
   LoadNextTab();
 }
 
 // static
 TabLoader* TabLoader::shared_tab_loader_ = nullptr;