Record the number of tabs in a session restore in SampledProfile

chrome/browser/sessions/session_restore.h

 // 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.
 
 #ifndef CHROME_BROWSER_SESSIONS_SESSION_RESTORE_H_
 #define CHROME_BROWSER_SESSIONS_SESSION_RESTORE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 22 matching lines @@
     // Indicates that if there is a problem restoring the last session then a
     // new tabbed browser should be created.
     ALWAYS_CREATE_TABBED_BROWSER = 1 << 1,
 
     // Restore blocks until complete. This is intended for use during startup
     // when we want to block until restore is complete.
     SYNCHRONOUS                  = 1 << 2,
   };
 
   // Notification callback list.
-  using CallbackList = base::CallbackList<void(void)>;
+  using CallbackList = base::CallbackList<void(int)>;
 
   // Used by objects calling RegisterOnSessionRestoredCallback() to de-register
   // themselves when they are destroyed.
   using CallbackSubscription =
-      scoped_ptr<base::CallbackList<void(void)>::Subscription>;
+      scoped_ptr<base::CallbackList<void(int)>::Subscription>;
 
   // Restores the last session. |behavior| is a bitmask of Behaviors, see it
   // for details. If |browser| is non-null the tabs for the first window are
   // added to it. Returns the last active browser.
   // Every additional browser created will be created on the desktop specified
   // by |host_desktop_type|, if |browser| is non-null it should have the same
   // desktop type.
   //
   // If |urls_to_open| is non-empty, a tab is added for each of the URLs.
   static Browser* RestoreSession(Profile* profile,
@@ skipping 26 matching lines @@
       const sessions::SessionTab& tab,
       WindowOpenDisposition disposition);
 
   // Returns true if we're in the process of restoring |profile|.
   static bool IsRestoring(const Profile* profile);
 
   // Returns true if synchronously restoring a session.
   static bool IsRestoringSynchronously();
 
   // Register callbacks for session restore events. These callbacks are stored
-  // in on_session_restored_callbacks_.
+  // in |on_session_restored_callbacks_|. The "(int)" arg is the number of tabs
+  // being restored.

[sky, 2015/02/05 17:05:19]

This isn't quite right. You should clearly document the two possible values so
that two years from now when someone comes to this code and tries to add
something they understand what it really is.

[Simon Que, 2015/02/05 19:00:24]

I thought I'm passing in the number of tabs in both places where the callback
notification is invoked.

Are you referring to the two different types of notifications here?

[sky, 2015/02/06 00:55:00]

That is some what true, but there is a big difference between
synchronous/non-synchronous that should be documented.
Here's a shot at what I think we want:
The callback is supplied a tab count. The exact meaning, and timing, depends
upon the restore type:
. SessionRestore::SYNCHRONOUS: the parameter is the number of tabs that were
created. Additionally the callback is invoked immediately after the tabs have
been created. That is, the tabs are not necessarily loading.
. For all other restore types the parameter is the number of tabs that were
restored and is sent after all tabs have started loading. Additionally if a
request to restore tabs comes in while a previous request to restore tabs has
not yet completed (loading tabs is throttled), then the callback is only
notified once both sets of tabs have started loading and with the total number
of tabs for both restores.

[Simon Que, 2015/02/11 00:05:28]

Can we talk about this over video hangout tomorrow? I'll set up a half hour slot
after lunch.

   static CallbackSubscription RegisterOnSessionRestoredCallback(
-      const base::Closure& callback);
+      const base::Callback<void(int)>& callback);
 
   // The max number of non-selected tabs SessionRestore loads when restoring
   // a session. A value of 0 indicates all tabs are loaded at once.
   static size_t num_tabs_to_load_;
 
  private:
   SessionRestore();
 
   // Accessor for |*on_session_restored_callbacks_|. Creates a new object the
   // first time so that it always returns a valid object.
   static CallbackList* on_session_restored_callbacks() {
     if (!on_session_restored_callbacks_)
       on_session_restored_callbacks_ = new CallbackList();
     return on_session_restored_callbacks_;
   }
 
   // Contains all registered callbacks for session restore notifications.
   static CallbackList* on_session_restored_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionRestore);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_SESSION_RESTORE_H_