[Sessions] Add detailed logging of SessionRestore events.

chrome/browser/sessions/session_restore.cc

 // Copyright 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 30 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "components/sessions/session_types.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/session_restore_uma.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_state.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension_set.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_recorder.h"
 #endif
@@ skipping 113 matching lines @@
           std::max(0, std::min((*i)->selected_tab_index,
                                static_cast<int>((*i)->tabs.size()) - 1));
       RestoreTabsToBrowser(*(*i), browser, initial_tab_count,
                            selected_tab_index, &created_contents);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // Always create in a new window.
     FinishedTabCreation(true, true, created_contents);
 
+    // Record the number of tabs associated with this session restore.
+    UMA_HISTOGRAM_COUNTS_100(content::kSessionRestoreTabCount,

[sky, 2015/05/07 20:23:45]

Please try to keep all stats collection in SessionRestoreStatsCollector.

+                             created_contents.size());
+
     on_session_restored_callbacks_->Notify(
         static_cast<int>(created_contents.size()));
 
     return browsers;
   }
 
   // Restore a single tab from a foreign session.
   // Opens in the tab in the last active browser, unless disposition is
   // NEW_WINDOW, in which case the tab will be opened in a new browser. Returns
   // the WebContents of the restored tab.
@@ skipping 23 matching lines @@
     } else {
       int tab_index =
           use_new_window ? 0 : browser->tab_strip_model()->active_index() + 1;
       web_contents = chrome::AddRestoredTab(
           browser, tab.navigations, tab_index, selected_index,
           tab.extension_app_id,
           disposition == NEW_FOREGROUND_TAB,  // selected
           tab.pinned, true, nullptr, tab.user_agent_override);
       // Start loading the tab immediately.
       web_contents->GetController().LoadIfNecessary();
+      UMA_HISTOGRAM_ENUMERATION(
+          content::kSessionRestoreTabActions,
+          content::kSessionRestoreTabActionsUma_ForegroundTabLoaded,
+          content::kSessionRestoreTabActionsUma_Max);
     }
 
     if (use_new_window) {
       browser->tab_strip_model()->ActivateTabAt(0, true);
       browser->window()->Show();
     }
     NotifySessionServiceOfRestoredTabs(browser,
                                        browser->tab_strip_model()->count());
 
     // Since FinishedTabCreation() is not called here, |this| will leak if we
@@ skipping 278 matching lines @@
         WebContents* contents = RestoreTab(tab, i, browser, is_selected_tab);
 
         // RestoreTab can return nullptr if |tab| doesn't have valid data.
         if (!contents)
           continue;
 
         RestoredTab restored_tab;
         restored_tab.contents = contents;
         restored_tab.is_active = is_selected_tab;
         created_contents->push_back(restored_tab);
+        UMA_HISTOGRAM_ENUMERATION(
+            content::kSessionRestoreTabActions,
+            content::kSessionRestoreTabActionsUma_TabCreated,
+            content::kSessionRestoreTabActionsUma_Max);
 
         // If this isn't the selected tab, there's nothing else to do.
         if (!is_selected_tab)
           continue;
 
         ShowBrowser(browser, browser->tab_strip_model()->GetIndexOfWebContents(
                                  contents));
         // TODO(sky): remove. For debugging 368236.
         CHECK_EQ(browser->tab_strip_model()->GetActiveWebContents(), contents);
       }
     } else {
       // If the browser already has tabs, we want to restore the new ones after
       // the existing ones. E.g. this happens in Win8 Metro where we merge
       // windows or when launching a hosted app from the app launcher.
       int tab_index_offset = initial_tab_count;
       for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
         const sessions::SessionTab& tab = *(window.tabs[i]);
         // Always schedule loads as we will not be calling ShowBrowser().
         WebContents* contents =
             RestoreTab(tab, tab_index_offset + i, browser, false);
         if (contents) {
           RestoredTab restored_tab;
           restored_tab.contents = contents;
           restored_tab.is_active = false;
           created_contents->push_back(restored_tab);
+          UMA_HISTOGRAM_ENUMERATION(
+              content::kSessionRestoreTabActions,
+              content::kSessionRestoreTabActionsUma_TabCreated,
+              content::kSessionRestoreTabActionsUma_Max);
         }
       }
     }
   }
 
   // |tab_index| is ignored for pinned tabs which will always be pushed behind
   // the last existing pinned tab.
   // |tab_loader_| will schedule this tab for loading if |is_selected_tab| is
   // false.
   WebContents* RestoreTab(const sessions::SessionTab& tab,
@@ skipping 154 matching lines @@
 Browser* SessionRestore::RestoreSession(
     Profile* profile,
     Browser* browser,
     chrome::HostDesktopType host_desktop_type,
     uint32 behavior,
     const std::vector<GURL>& urls_to_open) {
 #if defined(OS_CHROMEOS)
   chromeos::BootTimesRecorder::Get()->AddLoginTimeMarker(
       "SessionRestore-Start", false);
 #endif
+  UMA_HISTOGRAM_ENUMERATION(
+          content::kSessionRestoreActions,
+          content::kSessionRestoreActionsUma_Initiated,
+          content::kSessionRestoreActionsUma_Max);
   DCHECK(profile);
   // Always restore from the original profile (incognito profiles have no
   // session service).
   profile = profile->GetOriginalProfile();
   if (!SessionServiceFactory::GetForProfile(profile)) {
     NOTREACHED();
     return nullptr;
   }
   profile->set_restored_last_session(true);
   // SessionRestoreImpl takes care of deleting itself when done.
@@ skipping 80 matching lines @@
 // static
 SessionRestore::CallbackSubscription
     SessionRestore::RegisterOnSessionRestoredCallback(
         const base::Callback<void(int)>& callback) {
   return on_session_restored_callbacks()->Add(callback);
 }
 
 // static
 base::CallbackList<void(int)>*
     SessionRestore::on_session_restored_callbacks_ = nullptr;