idle_manager.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
6#define CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
7
8#include <map>
9#include <string>
10
11#include "base/callback_forward.h"
12#include "base/gtest_prod_util.h"
13#include "base/memory/weak_ptr.h"
14#include "base/scoped_observer.h"
15#include "base/threading/thread_checker.h"
16#include "base/timer/timer.h"
17#include "chrome/browser/idle.h"
18#include "components/keyed_service/core/keyed_service.h"
19#include "extensions/browser/event_router.h"
20#include "extensions/browser/extension_registry_observer.h"
21
22namespace base {
23class StringValue;
24}  // namespace base
25
26class Profile;
27
28namespace extensions {
29class ExtensionRegistry;
30
31typedef base::Callback<void(IdleState)> QueryStateCallback;
32
33struct IdleMonitor {
34  explicit IdleMonitor(IdleState initial_state);
35
36  IdleState last_state;
37  int listeners;
38  int threshold;
39};
40
41class IdleManager : public ExtensionRegistryObserver,
42                    public EventRouter::Observer,
43                    public KeyedService {
44 public:
45  class IdleTimeProvider {
46   public:
47    IdleTimeProvider() {}
48    virtual ~IdleTimeProvider() {}
49    virtual void CalculateIdleState(int idle_threshold,
50                                    IdleCallback notify) = 0;
51    virtual void CalculateIdleTime(IdleTimeCallback notify) = 0;
52    virtual bool CheckIdleStateIsLocked() = 0;
53
54   private:
55    DISALLOW_COPY_AND_ASSIGN(IdleTimeProvider);
56  };
57
58  class EventDelegate {
59   public:
60    EventDelegate() {}
61    virtual ~EventDelegate() {}
62    virtual void OnStateChanged(const std::string& extension_id,
63                                IdleState new_state) = 0;
64    virtual void RegisterObserver(EventRouter::Observer* observer) = 0;
65    virtual void UnregisterObserver(EventRouter::Observer* observer) = 0;
66
67   private:
68    DISALLOW_COPY_AND_ASSIGN(EventDelegate);
69  };
70
71  explicit IdleManager(Profile* profile);
72  virtual ~IdleManager();
73
74  void Init();
75
76  // KeyedService implementation.
77  virtual void Shutdown() OVERRIDE;
78
79  // ExtensionRegistryObserver implementation.
80  virtual void OnExtensionUnloaded(
81      content::BrowserContext* browser_context,
82      const Extension* extension,
83      UnloadedExtensionInfo::Reason reason) OVERRIDE;
84
85  // EventRouter::Observer implementation.
86  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
87  virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
88
89  void QueryState(int threshold, QueryStateCallback notify);
90  void SetThreshold(const std::string& extension_id, int threshold);
91  static base::StringValue* CreateIdleValue(IdleState idle_state);
92
93  // Override default event class. Callee assumes ownership. Used for testing.
94  void SetEventDelegateForTest(scoped_ptr<EventDelegate> event_delegate);
95
96  // Override default idle time calculations. Callee assumes ownership. Used
97  // for testing.
98  void SetIdleTimeProviderForTest(scoped_ptr<IdleTimeProvider> idle_provider);
99
100 private:
101  FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToIdle);
102  FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToLocked);
103  FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToActive);
104  FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToLocked);
105  FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToActive);
106  FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToIdle);
107  FRIEND_TEST_ALL_PREFIXES(IdleTest, MultipleExtensions);
108  FRIEND_TEST_ALL_PREFIXES(IdleTest, ReAddListener);
109  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionInterval);
110  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalBeforeListener);
111  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMaximum);
112  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMinimum);
113  FRIEND_TEST_ALL_PREFIXES(IdleTest, UnloadCleanup);
114
115  typedef std::map<const std::string, IdleMonitor> MonitorMap;
116
117  IdleMonitor* GetMonitor(const std::string& extension_id);
118  void StartPolling();
119  void StopPolling();
120  void UpdateIdleState();
121  void UpdateIdleStateCallback(int idle_time);
122
123  Profile* profile_;
124
125  IdleState last_state_;
126  MonitorMap monitors_;
127
128  base::RepeatingTimer<IdleManager> poll_timer_;
129
130  scoped_ptr<IdleTimeProvider> idle_time_provider_;
131  scoped_ptr<EventDelegate> event_delegate_;
132
133  base::ThreadChecker thread_checker_;
134
135  // Listen to extension unloaded notification.
136  ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
137      extension_registry_observer_;
138
139  base::WeakPtrFactory<IdleManager> weak_factory_;
140
141  DISALLOW_COPY_AND_ASSIGN(IdleManager);
142};
143
144}  // namespace extensions
145
146#endif  // CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
147