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_CONFIGURATION_POLICY_PROVIDER_H_
      6 #define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/memory/ref_counted.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/observer_list.h"
     12 #include "chrome/browser/policy/policy_bundle.h"
     13 #include "chrome/browser/policy/policy_service.h"
     14 
     15 namespace policy {
     16 
     17 class PolicyDomainDescriptor;
     18 
     19 // A mostly-abstract super class for platform-specific policy providers.
     20 // Platform-specific policy providers (Windows Group Policy, gconf,
     21 // etc.) should implement a subclass of this class.
     22 class ConfigurationPolicyProvider {
     23  public:
     24   class Observer {
     25    public:
     26     virtual ~Observer();
     27     virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) = 0;
     28   };
     29 
     30   ConfigurationPolicyProvider();
     31 
     32   // Policy providers can be deleted quite late during shutdown of the browser,
     33   // and it's not guaranteed that the message loops will still be running when
     34   // this is invoked. Override Shutdown() instead for cleanup code that needs
     35   // to post to the FILE thread, for example.
     36   virtual ~ConfigurationPolicyProvider();
     37 
     38   // Invoked as soon as the main message loops are spinning. Policy providers
     39   // are created early during startup to provide the initial policies; the
     40   // Init() call allows them to perform initialization tasks that require
     41   // running message loops.
     42   virtual void Init();
     43 
     44   // Must be invoked before deleting the provider. Implementations can override
     45   // this method to do appropriate cleanup while threads are still running, and
     46   // must also invoke ConfigurationPolicyProvider::Shutdown().
     47   // The provider should keep providing the current policies after Shutdown()
     48   // is invoked, it only has to stop updating.
     49   virtual void Shutdown();
     50 
     51   // Returns the current PolicyBundle.
     52   const PolicyBundle& policies() const { return policy_bundle_; }
     53 
     54   // Check whether this provider has completed initialization for the given
     55   // policy |domain|. This is used to detect whether initialization is done in
     56   // case implementations need to do asynchronous operations for initialization.
     57   virtual bool IsInitializationComplete(PolicyDomain domain) const;
     58 
     59   // Asks the provider to refresh its policies. All the updates caused by this
     60   // call will be visible on the next call of OnUpdatePolicy on the observers,
     61   // which are guaranteed to happen even if the refresh fails.
     62   // It is possible that Shutdown() is called first though, and
     63   // OnUpdatePolicy won't be called if that happens.
     64   virtual void RefreshPolicies() = 0;
     65 
     66   // Observers must detach themselves before the provider is deleted.
     67   virtual void AddObserver(Observer* observer);
     68   virtual void RemoveObserver(Observer* observer);
     69 
     70   // Notifies the provider that there is interest in loading policy for the
     71   // listed components in the given |descriptor|. The list is complete; all the
     72   // components that matter for the domain are included, and components not
     73   // included can be discarded. The provider can ignore this information or use
     74   // it to selectively load the corresponding policy from its sources.
     75   virtual void RegisterPolicyDomain(
     76       scoped_refptr<const PolicyDomainDescriptor> descriptor);
     77 
     78  protected:
     79   // Subclasses must invoke this to update the policies currently served by
     80   // this provider. UpdatePolicy() takes ownership of |policies|.
     81   // The observers are notified after the policies are updated.
     82   void UpdatePolicy(scoped_ptr<PolicyBundle> bundle);
     83 
     84  private:
     85   // The policies currently configured at this provider.
     86   PolicyBundle policy_bundle_;
     87 
     88   // Whether Shutdown() has been invoked.
     89   bool did_shutdown_;
     90 
     91   ObserverList<Observer, true> observer_list_;
     92 
     93   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProvider);
     94 };
     95 
     96 }  // namespace policy
     97 
     98 #endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_PROVIDER_H_
     99