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   ~IdleManager() override;
  73
  74   void Init();
  75
  76   // KeyedService implementation.
  77   void Shutdown() override;
  78
  79   // ExtensionRegistryObserver implementation.
  80   void OnExtensionUnloaded(content::BrowserContext* browser_context,
  81                            const Extension* extension,
  82                            UnloadedExtensionInfo::Reason reason) override;
  83
  84   // EventRouter::Observer implementation.
  85   void OnListenerAdded(const EventListenerInfo& details) override;
  86   void OnListenerRemoved(const EventListenerInfo& details) override;
  87
  88   void QueryState(int threshold, QueryStateCallback notify);
  89   void SetThreshold(const std::string& extension_id, int threshold);
  90   static base::StringValue* CreateIdleValue(IdleState idle_state);
  91
  92   // Override default event class. Callee assumes ownership. Used for testing.
  93   void SetEventDelegateForTest(scoped_ptr<EventDelegate> event_delegate);
  94
  95   // Override default idle time calculations. Callee assumes ownership. Used
  96   // for testing.
  97   void SetIdleTimeProviderForTest(scoped_ptr<IdleTimeProvider> idle_provider);
  98
  99  private:
 100   FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToIdle);
 101   FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToLocked);
 102   FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToActive);
 103   FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToLocked);
 104   FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToActive);
 105   FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToIdle);
 106   FRIEND_TEST_ALL_PREFIXES(IdleTest, MultipleExtensions);
 107   FRIEND_TEST_ALL_PREFIXES(IdleTest, ReAddListener);
 108   FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionInterval);
 109   FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalBeforeListener);
 110   FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMaximum);
 111   FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMinimum);
 112   FRIEND_TEST_ALL_PREFIXES(IdleTest, UnloadCleanup);
 113
 114   typedef std::map<const std::string, IdleMonitor> MonitorMap;
 115
 116   IdleMonitor* GetMonitor(const std::string& extension_id);
 117   void StartPolling();
 118   void StopPolling();
 119   void UpdateIdleState();
 120   void UpdateIdleStateCallback(int idle_time);
 121
 122   Profile* profile_;
 123
 124   IdleState last_state_;
 125   MonitorMap monitors_;
 126
 127   base::RepeatingTimer<IdleManager> poll_timer_;
 128
 129   scoped_ptr<IdleTimeProvider> idle_time_provider_;
 130   scoped_ptr<EventDelegate> event_delegate_;
 131
 132   base::ThreadChecker thread_checker_;
 133
 134   // Listen to extension unloaded notification.
 135   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
 136       extension_registry_observer_;
 137
 138   base::WeakPtrFactory<IdleManager> weak_factory_;
 139
 140   DISALLOW_COPY_AND_ASSIGN(IdleManager);
 141 };
 142
 143 }  // namespace extensions
 144
 145 #endif  // CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_