src/chrome/browser/extensions/api/idle/idle_manager.h

   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
  22 namespace base {
  23 class StringValue;
  24 }  // namespace base
  25
  26 class Profile;
  27
  28 namespace extensions {
  29 class ExtensionRegistry;
  30
  31 typedef base::Callback<void(IdleState)> QueryStateCallback;
  32
  33 struct IdleMonitor {
  34   explicit IdleMonitor(IdleState initial_state);
  35
  36   IdleState last_state;
  37   int listeners;
  38   int threshold;
  39 };
  40
  41 class 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_