boot_times_loader.h revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_
6#define CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_
7
8#include <set>
9#include <string>
10
11#include "base/atomic_sequence_num.h"
12#include "base/callback_forward.h"
13#include "base/compiler_specific.h"
14#include "base/task/cancelable_task_tracker.h"
15#include "base/time/time.h"
16#include "content/public/browser/notification_observer.h"
17#include "content/public/browser/notification_registrar.h"
18#include "content/public/browser/render_widget_host.h"
19
20namespace chromeos {
21
22// BootTimesLoader loads the bootimes of Chrome OS from the file system.
23// Loading is done asynchronously on the file thread. Once loaded,
24// BootTimesLoader calls back to a method of your choice with the boot times.
25// To use BootTimesLoader, do the following:
26//
27// . In your class define a member field of type chromeos::BootTimesLoader and
28//   base::CancelableTaskTracker.
29// . Define the callback method, something like:
30//   void OnBootTimesLoaded(const BootTimesLoader::BootTimes& boot_times);
31// . When you want the version invoke: loader.GetBootTimes(callback, &tracker_);
32class BootTimesLoader : public content::NotificationObserver {
33 public:
34  BootTimesLoader();
35  virtual ~BootTimesLoader();
36
37  static BootTimesLoader* Get();
38
39  // Add a time marker for login. A timeline will be dumped to
40  // /tmp/login-times-sent after login is done. If |send_to_uma| is true
41  // the time between this marker and the last will be sent to UMA with
42  // the identifier BootTime.|marker_name|.
43  void AddLoginTimeMarker(const std::string& marker_name, bool send_to_uma);
44
45  // Add a time marker for logout. A timeline will be dumped to
46  // /tmp/logout-times-sent after logout is done. If |send_to_uma| is true
47  // the time between this marker and the last will be sent to UMA with
48  // the identifier ShutdownTime.|marker_name|.
49  void AddLogoutTimeMarker(const std::string& marker_name, bool send_to_uma);
50
51  // Records current uptime and disk usage for metrics use.
52  // Posts task to file thread.
53  // name will be used as part of file names in /tmp.
54  // Existing stats files will not be overwritten.
55  void RecordCurrentStats(const std::string& name);
56
57  // Saves away the stats at main, so the can be recorded later. At main() time
58  // the necessary threads don't exist yet for recording the data.
59  void SaveChromeMainStats();
60
61  // Records the data previously saved by SaveChromeMainStats(), using the
62  // file thread. Existing stats files will not be overwritten.
63  void RecordChromeMainStats();
64
65  // Records the time that a login was attempted. This will overwrite any
66  // previous login attempt times.
67  void RecordLoginAttempted();
68
69  // content::NotificationObserver implementation.
70  virtual void Observe(int type,
71                       const content::NotificationSource& source,
72                       const content::NotificationDetails& details) OVERRIDE;
73
74  // Writes the logout times to a /tmp/logout-times-sent. Unlike login
75  // times, we manually call this function for logout times, as we cannot
76  // rely on notification service to tell when the logout is done.
77  void WriteLogoutTimes();
78
79 private:
80  // BootTimesLoader calls into the Backend on the file thread to load
81  // the boot times.
82  class Backend : public base::RefCountedThreadSafe<Backend> {
83   public:
84    Backend() {}
85
86   private:
87    friend class base::RefCountedThreadSafe<Backend>;
88
89    ~Backend() {}
90
91    DISALLOW_COPY_AND_ASSIGN(Backend);
92  };
93
94  class TimeMarker {
95   public:
96    TimeMarker(const std::string& name, bool send_to_uma)
97        : name_(name),
98          time_(base::Time::NowFromSystemTime()),
99          send_to_uma_(send_to_uma) {}
100    std::string name() const { return name_; }
101    base::Time time() const { return time_; }
102    bool send_to_uma() const { return send_to_uma_; }
103
104    // comparitor for sorting
105    bool operator<(const TimeMarker& other) const {
106      return time_ < other.time_;
107    }
108
109   private:
110    friend class std::vector<TimeMarker>;
111    std::string name_;
112    base::Time time_;
113    bool send_to_uma_;
114  };
115
116  struct Stats {
117   public:
118    std::string uptime;
119    std::string disk;
120  };
121
122  static void RecordStats(
123      const std::string& name, const Stats& stats);
124  static Stats GetCurrentStats();
125  static void WriteTimes(const std::string base_name,
126                         const std::string uma_name,
127                         const std::string uma_prefix,
128                         std::vector<TimeMarker> login_times);
129  static void AddMarker(std::vector<TimeMarker>* vector, TimeMarker marker);
130
131  void LoginDone();
132
133  // Used to hold the stats at main().
134  Stats chrome_main_stats_;
135  scoped_refptr<Backend> backend_;
136
137  // Used to track notifications for login.
138  content::NotificationRegistrar registrar_;
139  base::AtomicSequenceNumber num_tabs_;
140  bool have_registered_;
141
142  std::vector<TimeMarker> login_time_markers_;
143  std::vector<TimeMarker> logout_time_markers_;
144  std::set<content::RenderWidgetHost*> render_widget_hosts_loading_;
145
146  DISALLOW_COPY_AND_ASSIGN(BootTimesLoader);
147};
148
149}  // namespace chromeos
150
151#endif  // CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_
152