Support change detection and reloading in ConfigDirPolicyProvider.

chrome/browser/policy/config_dir_policy_provider.h

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_BROWSER_POLICY_CONFIG_DIR_POLICY_PROVIDER_H_
 #define CHROME_BROWSER_POLICY_CONFIG_DIR_POLICY_PROVIDER_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
+#include "base/lock.h"
+#include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
+#include "base/weak_ptr.h"
+#include "chrome/browser/file_path_watcher.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
+class ConfigDirPolicyProvider;
 class DictionaryValue;
+class MessageLoop;
+
+// FilePathWatcher delegate implementation that handles change notifications for
+// the configuration directory. It keeps the authorative version of the
+// currently effective policy dictionary and updates it as appropriate.
+class PolicyDirLoader : public FilePathWatcher::Delegate {
+ public:
+  // Create a new loader that'll load its data from |config_dir|.
+  PolicyDirLoader(base::WeakPtr<ConfigDirPolicyProvider> provider,
+                  const FilePath& config_dir,
+                  int settle_interval_second,
+                  int reload_interval_minutes);
+
+  // Stops any pending reload tasks.
+  void Stop();
+
+  // Reloads the policies and sends out a notification, if appropriate. Must be
+  // called on the file thread.
+  void Reload();
+
+  // Get the current dictionary value object. Ownership of the returned value is
+  // transferred to the caller.
+  DictionaryValue* GetPolicy();
+
+  const FilePath& config_dir() { return config_dir_; }
+
+  // FilePathWatcher::Delegate implementation:
+  void OnFilePathChanged(const FilePath& path);
+  void OnError();
+
+ private:
+  // Load the policy information. Ownership of the return value is transferred
+  // to the caller.
+  DictionaryValue* Load();
+
+  // Check the directory modification time to see whether reading the
+  // configuration directory is safe. If not, returns false and the delay until
+  // it is considered safe to reload in |delay|.
+  bool IsSafeToReloadPolicy(const base::Time& now, base::TimeDelta* delay);
+
+  // Post a reload task. Must be called on the file thread.
+  void ScheduleReloadTask(const base::TimeDelta& delay);
+
+  // Notifies the policy provider to send out a policy changed notification.
+  // Must be called on |origin_loop_|.
+  void NotifyPolicyChanged();
+
+  // Invoked from the reload task on the file thread.
+  void ReloadFromTask();
+
+  // The provider this loader is associated with. Access only on the thread that
+  // called the constructor. See |origin_loop_| below.
+  base::WeakPtr<ConfigDirPolicyProvider> provider_;
+
+  // The message loop on which this object was constructed and |provider_|
+  // received on. Recorded so we can call back into the non thread safe provider
+  // to fire the notification.
+  MessageLoop* origin_loop_;
+
+  // The directory in which we look for configuration files.
+  const FilePath config_dir_;
+
+  // Protects |policy_|.
+  Lock lock_;
+
+  // The current policy definition.
+  scoped_ptr<DictionaryValue> policy_;
+
+  // The reload task. Access only on the file thread. Holds a reference to the
+  // currently posted task, so we can cancel and repost it if necessary.
+  CancelableTask* reload_task_;
+
+  // Settle and reload intervals.
+  const int settle_interval_seconds_;
+  const int reload_interval_minutes_;
+
+  DISALLOW_COPY_AND_ASSIGN(PolicyDirLoader);
+};
+
+// Wraps a FilePathWatcher for the configuration directory and takes care of
+// initializing the watcher object on the file thread.
+class PolicyDirWatcher : public FilePathWatcher,
+                         public base::RefCountedThreadSafe<PolicyDirWatcher> {
+ public:
+  PolicyDirWatcher() {}
+
+  // Run initialization. This is in a separate method since we need to post a
+  // task (which cannot be done from the constructor).
+  void Init(PolicyDirLoader* loader);
+
+ private:
+  // Actually sets up the watch with the FilePathWatcher code.
+  void InitWatcher(const scoped_refptr<PolicyDirLoader>& loader);
+
+  DISALLOW_COPY_AND_ASSIGN(PolicyDirWatcher);
+};
 
 // A policy provider implementation backed by a set of files in a given
 // directory. The files should contain JSON-formatted policy settings. They are
 // merged together and the result is returned via the
 // ConfigurationPolicyProvider interface. The files are consulted in
 // lexicographic file name order, so the last value read takes precedence in
 // case of preference key collisions.
-class ConfigDirPolicyProvider : public ConfigurationPolicyProvider {
+class ConfigDirPolicyProvider
+    : public ConfigurationPolicyProvider,
+      public base::SupportsWeakPtr<ConfigDirPolicyProvider> {
  public:
   explicit ConfigDirPolicyProvider(const FilePath& config_dir);
-  virtual ~ConfigDirPolicyProvider() { }
+  virtual ~ConfigDirPolicyProvider();
 
   // ConfigurationPolicyProvider implementation.
   virtual bool Provide(ConfigurationPolicyStore* store);
 
  private:
-  // Read and merge the files from the configuration directory.
-  DictionaryValue* ReadPolicies();
-
   // Decodes the value tree and writes the configuration to the given |store|.
   void DecodePolicyValueTree(DictionaryValue* policies,
                              ConfigurationPolicyStore* store);
 
-  // The directory in which we look for configuration files.
-  const FilePath config_dir_;
+  // Watches for changes to the configuration directory.
+  scoped_refptr<PolicyDirWatcher> watcher_;
+
+  // The loader object we use internally.
+  scoped_refptr<PolicyDirLoader> loader_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigDirPolicyProvider);
 };
 
 #endif  // CHROME_BROWSER_POLICY_CONFIG_DIR_POLICY_PROVIDER_H_