QUIC - cleanup changes to sync chromium tree with internal source.
[chromium-blink-merge.git] / base / threading / watchdog.h
blobea3be36d1a8c450b9d122f792de0d71e2f21619c
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.
5 // The Watchdog class creates a second thread that can Alarm if a specific
6 // duration of time passes without proper attention. The duration of time is
7 // specified at construction time. The Watchdog may be used many times by
8 // simply calling Arm() (to start timing) and Disarm() (to reset the timer).
9 // The Watchdog is typically used under a debugger, where the stack traces on
10 // other threads can be examined if/when the Watchdog alarms.
12 // Some watchdogs will be enabled or disabled via command line switches. To
13 // facilitate such code, an "enabled" argument for the constuctor can be used
14 // to permanently disable the watchdog. Disabled watchdogs don't even spawn
15 // a second thread, and their methods call (Arm() and Disarm()) return very
16 // quickly.
18 #ifndef BASE_THREADING_WATCHDOG_H_
19 #define BASE_THREADING_WATCHDOG_H_
21 #include <string>
23 #include "base/base_export.h"
24 #include "base/compiler_specific.h"
25 #include "base/synchronization/condition_variable.h"
26 #include "base/synchronization/lock.h"
27 #include "base/threading/platform_thread.h"
28 #include "base/time/time.h"
30 namespace base {
32 class BASE_EXPORT Watchdog {
33 public:
34 // Constructor specifies how long the Watchdog will wait before alarming.
35 Watchdog(const TimeDelta& duration,
36 const std::string& thread_watched_name,
37 bool enabled);
38 virtual ~Watchdog();
40 // Notify watchdog thread to finish up. Sets the state_ to SHUTDOWN.
41 void Cleanup();
43 // Returns true if we state_ is JOINABLE (which indicates that Watchdog has
44 // exited).
45 bool IsJoinable();
47 // Start timing, and alarm when time expires (unless we're disarm()ed.)
48 void Arm(); // Arm starting now.
49 void ArmSomeTimeDeltaAgo(const TimeDelta& time_delta);
50 void ArmAtStartTime(const TimeTicks start_time);
52 // Reset time, and do not set off the alarm.
53 void Disarm();
55 // Alarm is called if the time expires after an Arm() without someone calling
56 // Disarm(). This method can be overridden to create testable classes.
57 virtual void Alarm();
59 // Reset static data to initial state. Useful for tests, to ensure
60 // they are independent.
61 static void ResetStaticData();
63 private:
64 class ThreadDelegate : public PlatformThread::Delegate {
65 public:
66 explicit ThreadDelegate(Watchdog* watchdog) : watchdog_(watchdog) {
68 void ThreadMain() override;
70 private:
71 void SetThreadName() const;
73 Watchdog* watchdog_;
76 enum State {ARMED, DISARMED, SHUTDOWN, JOINABLE };
78 bool enabled_;
80 Lock lock_; // Mutex for state_.
81 ConditionVariable condition_variable_;
82 State state_;
83 const TimeDelta duration_; // How long after start_time_ do we alarm?
84 const std::string thread_watched_name_;
85 PlatformThreadHandle handle_;
86 ThreadDelegate delegate_; // Store it, because it must outlive the thread.
88 TimeTicks start_time_; // Start of epoch, and alarm after duration_.
90 DISALLOW_COPY_AND_ASSIGN(Watchdog);
93 } // namespace base
95 #endif // BASE_THREADING_WATCHDOG_H_