Home | History | Annotate | Download | only in policy 
      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_POLICY_ASYNC_POLICY_LOADER_H_
      6 #define CHROME_BROWSER_POLICY_ASYNC_POLICY_LOADER_H_
      7 
      8 #include <map>
      9 
     10 #include "base/callback.h"
     11 #include "base/memory/ref_counted.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/memory/weak_ptr.h"
     14 #include "base/time/time.h"
     15 #include "chrome/browser/policy/policy_service.h"
     16 
     17 namespace policy {
     18 
     19 class PolicyBundle;
     20 class PolicyDomainDescriptor;
     21 
     22 // Base implementation for platform-specific policy loaders. Together with the
     23 // AsyncPolicyProvider, this base implementation takes care of the initial load,
     24 // periodic reloads, watching file changes, refreshing policies and object
     25 // lifetime.
     26 //
     27 // All methods are invoked on the FILE thread, including the destructor.
     28 // The only exceptions are the constructor (which may be called on any thread),
     29 // and the initial Load() which is called on the thread that owns the provider.
     30 // LastModificationTime() is also invoked once on that thread at startup.
     31 class AsyncPolicyLoader {
     32  public:
     33   AsyncPolicyLoader();
     34   virtual ~AsyncPolicyLoader();
     35 
     36   // Returns the currently configured policies. Load() is always invoked on
     37   // the FILE thread, except for the initial Load() at startup which is invoked
     38   // from the thread that owns the provider.
     39   virtual scoped_ptr<PolicyBundle> Load() = 0;
     40 
     41   // Allows implementations to finalize their initialization on the FILE
     42   // thread (e.g. setup file watchers).
     43   virtual void InitOnFile() = 0;
     44 
     45   // Implementations should return the time of the last modification detected,
     46   // or base::Time() if it doesn't apply, which is the default.
     47   virtual base::Time LastModificationTime();
     48 
     49   // Implementations should invoke Reload() when a change is detected. This
     50   // must be invoked from the FILE thread and will trigger a Load(), and pass
     51   // the returned bundle to the provider.
     52   // The load is immediate when |force| is true. Otherwise, the loader
     53   // reschedules the reload until the LastModificationTime() is a couple of
     54   // seconds in the past. This mitigates the problem of reading files that are
     55   // currently being written to, and whose contents are incomplete.
     56   // A reload is posted periodically, if it hasn't been triggered recently. This
     57   // makes sure the policies are reloaded if the update events aren't triggered.
     58   void Reload(bool force);
     59 
     60   // Passes the current |descriptor| for a domain, which is used to determine
     61   // which policy names are supported for each component.
     62   void RegisterPolicyDomain(
     63       scoped_refptr<const PolicyDomainDescriptor> descriptor);
     64 
     65  protected:
     66   typedef std::map<PolicyDomain, scoped_refptr<const PolicyDomainDescriptor> >
     67       DescriptorMap;
     68 
     69   // Returns the current DescriptorMap. This can be used by implementations to
     70   // determine the components registered for each domain, and to filter out
     71   // unknonwn policies.
     72   const DescriptorMap& descriptor_map() const { return descriptor_map_; }
     73 
     74  private:
     75   // Allow AsyncPolicyProvider to call Init().
     76   friend class AsyncPolicyProvider;
     77 
     78   typedef base::Callback<void(scoped_ptr<PolicyBundle>)> UpdateCallback;
     79 
     80   // Used by the AsyncPolicyProvider to do the initial Load(). The first load
     81   // is also used to initialize |last_modification_time_|.
     82   scoped_ptr<PolicyBundle> InitialLoad();
     83 
     84   // Used by the AsyncPolicyProvider to install the |update_callback_|.
     85   // Invoked on the FILE thread.
     86   void Init(const UpdateCallback& update_callback);
     87 
     88   // Cancels any pending periodic reload and posts one |delay| time units from
     89   // now.
     90   void ScheduleNextReload(base::TimeDelta delay);
     91 
     92   // Checks if the underlying files haven't changed recently, by checking the
     93   // LastModificationTime(). |delay| is updated with a suggested time to wait
     94   // before retrying when this returns false.
     95   bool IsSafeToReload(const base::Time& now, base::TimeDelta* delay);
     96 
     97   // Callback for updates, passed in Init().
     98   UpdateCallback update_callback_;
     99 
    100   // Used to get WeakPtrs for the periodic reload task.
    101   base::WeakPtrFactory<AsyncPolicyLoader> weak_factory_;
    102 
    103   // Records last known modification timestamp.
    104   base::Time last_modification_time_;
    105 
    106   // The wall clock time at which the last modification timestamp was
    107   // recorded.  It's better to not assume the file notification time and the
    108   // wall clock times come from the same source, just in case there is some
    109   // non-local filesystem involved.
    110   base::Time last_modification_clock_;
    111 
    112   // A map of the currently registered domains and their descriptors.
    113   DescriptorMap descriptor_map_;
    114 
    115   DISALLOW_COPY_AND_ASSIGN(AsyncPolicyLoader);
    116 };
    117 
    118 }  // namespace policy
    119 
    120 #endif  // CHROME_BROWSER_POLICY_ASYNC_POLICY_LOADER_H_
    121