Created method to save histogram data for future...

chrome/browser/sessions/session_service.h

 // Copyright (c) 2010 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_SERVICE_H_
 #define CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_
 
 #include <map>
+#include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/time.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/sessions/base_session_service.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/common/notification_observer.h"
@@ skipping 149 matching lines @@
   // callback invokes OnGotSessionCommands from which we map the
   // SessionCommands to browser state, then notify the callback.
   Handle GetCurrentSession(CancelableRequestConsumerBase* consumer,
                            SessionCallback* callback);
 
   // Overridden from BaseSessionService because we want some UMA reporting on
   // session update activities.
   virtual void Save();
 
  private:
-  typedef std::map<SessionID::id_type,std::pair<int,int> > IdToRange;
-  typedef std::map<SessionID::id_type,SessionTab*> IdToSessionTab;
-  typedef std::map<SessionID::id_type,SessionWindow*> IdToSessionWindow;
+  typedef std::map<SessionID::id_type, std::pair<int, int> > IdToRange;
+  typedef std::map<SessionID::id_type, SessionTab*> IdToSessionTab;
+  typedef std::map<SessionID::id_type, SessionWindow*> IdToSessionWindow;
+
 
   virtual ~SessionService();
 
   // These types mirror Browser::Type, but are re-defined here because these
   // specific enumeration _values_ are written into the session database and
   // are needed to maintain forward compatibility.
   enum WindowType {
     TYPE_NORMAL = 0,
     TYPE_POPUP = 1,
     TYPE_APP = 2,
@@ skipping 87 matching lines @@
       int index);
 
   // Does the following:
   // . Deletes and removes any windows with no tabs or windows with types other
   //   than tabbed_browser or browser. NOTE: constrained windows that have
   //   been dragged out are of type browser. As such, this preserves any dragged
   //   out constrained windows (aka popups that have been dragged out).
   // . Sorts the tabs in windows with valid tabs based on the tabs
   //   visual order, and adds the valid windows to windows.
   void SortTabsBasedOnVisualOrderAndPrune(
-      std::map<int,SessionWindow*>* windows,
+      std::map<int, SessionWindow*>* windows,
       std::vector<SessionWindow*>* valid_windows);
 
   // Adds tabs to their parent window based on the tab's window_id. This
   // ignores tabs with no navigations.
-  void AddTabsToWindows(std::map<int,SessionTab*>* tabs,
-                        std::map<int,SessionWindow*>* windows);
+  void AddTabsToWindows(std::map<int, SessionTab*>* tabs,
+                        std::map<int, SessionWindow*>* windows);
 
   // Creates tabs and windows from the specified commands. The created tabs
   // and windows are added to |tabs| and |windows| respectively. It is up to
   // the caller to delete the tabs and windows added to |tabs| and |windows|.
   //
   // This does NOT add any created SessionTabs to SessionWindow.tabs, that is
   // done by AddTabsToWindows.
   bool CreateTabsAndWindows(const std::vector<SessionCommand*>& data,
-                            std::map<int,SessionTab*>* tabs,
-                            std::map<int,SessionWindow*>* windows);
+                            std::map<int, SessionTab*>* tabs,
+                            std::map<int, SessionWindow*>* windows);
 
   // Adds commands to commands that will recreate the state of the specified
   // NavigationController. This adds at most kMaxNavigationCountToPersist
   // navigations (in each direction from the current navigation index).
   // A pair is added to tab_to_available_range indicating the range of
   // indices that were written.
   void BuildCommandsForTab(
       const SessionID& window_id,
       NavigationController* controller,
       int index_in_window,
@@ skipping 59 matching lines @@
   bool should_record_close_as_pending() const {
     // When this is called, the browser window being closed is still open, hence
     // still in the browser list. If there is a browser window other than the
     // one being closed but no trackable windows, then the others must be App
     // windows or similar. In this case, we record the close as pending.
     return !has_open_trackable_browsers_ &&
         (!browser_defaults::kBrowserAliveWithNoWindows ||
          BrowserList::size() > 1);
   }
 
-  // Call when a Save() occurs to record this in UMA stats.
-  void RecordSaveHistogramData();
+  // Call when certain session relevant notifications
+  // (tab_closed, nav_list_pruned) occur.  In addition, this is
+  // currently called when Save() is called to compare how often the
+  // session data is currently saved verses when we may want to save it.
+  // It records the data in UMA stats.
+  void RecordSessionUpdateHistogramData(NotificationType type,
+    base::TimeTicks* last_updated_time);
+
+  // Helper methods to record the histogram data
+  void RecordUpdatedTabClosed(base::TimeDelta delta, bool use_long_period);
+  void RecordUpdatedNavListPruned(base::TimeDelta delta, bool use_long_period);
+  void RecordUpdatedNavEntryCommit(base::TimeDelta delta, bool use_long_period);
+  void RecordUpdatedSaveTime(base::TimeDelta delta, bool use_long_period);
+  void RecordUpdatedSessionNavigationOrTab(base::TimeDelta delta,
+                                           bool use_long_period);
 
   // Convert back/forward between the Browser and SessionService DB window
   // types.
   static WindowType WindowTypeForBrowserType(Browser::Type type);
   static Browser::Type BrowserTypeForWindowType(WindowType type);
 
   NotificationRegistrar registrar_;
 
   // Maps from session tab id to the range of navigation entries that has
   // been written to disk.
@@ skipping 26 matching lines @@
 
   // Are there any open trackable browsers?
   bool has_open_trackable_browsers_;
 
   // If true and a new tabbed browser is created and there are no opened tabbed
   // browser (has_open_trackable_browsers_ is false), then the current session
   // is made the previous session. See description above class for details on
   // current/previous session.
   bool move_on_new_browser_;
 
-  // Used for reporting frequency of Save() operations.
-  base::TimeTicks last_save_time_;
+  // Used for reporting frequency of session alteriing operations.
+  base::TimeTicks last_updated_tab_closed_time_;
+  base::TimeTicks last_updated_nav_list_pruned_time_;
+  base::TimeTicks last_updated_nav_entry_commit_time_;
+  base::TimeTicks last_updated_save_time_;
+
+  // Constants used in calculating histogram data.
+  const base::TimeDelta save_delay_in_millis_;
+  const base::TimeDelta save_delay_in_mins_;
+  const base::TimeDelta save_delay_in_hrs_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionService);
 };
 
 #endif  // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_H_