Home | History | Annotate | Download | only in idle 
      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_
    147