[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 20 matching lines @@
     }
     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) {
+  // TODO(chrisha): Make the SessionRestoreStatsCollector aware that tab loading
+  // was explicitly stopped or restarted. This can make be used to invalidate
+  // various metrics.
   if (enable_tab_loading == loading_enabled_)
     return;
   loading_enabled_ = enable_tab_loading;
-  if (loading_enabled_)
+  if (loading_enabled_) {
     LoadNextTab();
-  else
+  } else {
     force_load_timer_.Stop();
+  }
 }
 
 // static
 void TabLoader::RestoreTabs(const std::vector<RestoredTab>& tabs,
                             const base::TimeTicks& restore_started) {
   if (!shared_tab_loader_)
     shared_tab_loader_ = new TabLoader(restore_started);
 
+  shared_tab_loader_->stats_collector_->TrackTabs(tabs);
   shared_tab_loader_->StartLoading(tabs);
 }
 
 TabLoader::TabLoader(base::TimeTicks restore_started)
     : memory_pressure_listener_(
           base::Bind(&TabLoader::OnMemoryPressure, base::Unretained(this))),
       force_load_delay_multiplier_(1),
       loading_enabled_(true),
       restore_started_(restore_started) {
+  scoped_refptr<SessionRestoreStatsCollector::StatsReportingDelegate>
+        reporting_delegate =
+            new SessionRestoreStatsCollector::UmaStatsReportingDelegate();
+  stats_collector_ = new SessionRestoreStatsCollector(
+      restore_started, reporting_delegate);
   shared_tab_loader_ = this;
   this_retainer_ = this;
 }
 
 TabLoader::~TabLoader() {
   DCHECK(tabs_loading_.empty() && tabs_to_load_.empty());
   DCHECK(shared_tab_loader_ == this);
   shared_tab_loader_ = nullptr;
 }
 
@@ skipping 128 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.
+    stats_collector_->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;