Refactor FileBasedPolicyProvider, introduce AsynchronousPolicyProvider.

chrome/browser/policy/file_based_policy_loader.h

Index: chrome/browser/policy/file_based_policy_loader.h
diff --git a/chrome/browser/policy/file_based_policy_loader.h b/chrome/browser/policy/file_based_policy_loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..8acf9b2d151dff10fa8662d7923884119bbae387
--- /dev/null
+++ b/chrome/browser/policy/file_based_policy_loader.h
@@ -0,0 +1,104 @@
+// 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_FILE_BASED_POLICY_LOADER_H_
+#define CHROME_BROWSER_POLICY_FILE_BASED_POLICY_LOADER_H_
+#pragma once
+
+#include "chrome/browser/file_path_watcher/file_path_watcher.h"
+#include "chrome/browser/policy/asynchronous_policy_loader.h"
+#include "chrome/browser/policy/file_based_policy_provider.h"
+
+namespace policy {
+
+// A customized asynchronous policy loader that handles loading policy from a
+// file using a FilePathWatcher. The loader creates a fallback task to load
+// policy periodically in case the watcher fails and retries policy loads when
+// the watched file is in flux.
+class FileBasedPolicyLoader : public AsynchronousPolicyLoader {
+ public:
+  FileBasedPolicyLoader(
+      FileBasedPolicyProvider::ProviderDelegate* provider_delegate);
+
+  // AsynchronousPolicyLoader implementation:
+  virtual void Init();
+  virtual void Stop();
+  virtual void Reload();
+
+  void OnFilePathChanged(const FilePath& path);
+  void OnError();
+
+ protected:
+  // FileBasedPolicyLoader objects should only be deleted by
+  // RefCountedThreadSafe.
+  friend class base::RefCountedThreadSafe<AsynchronousPolicyLoader>;
+  virtual ~FileBasedPolicyLoader() {}
+
+  const FilePath& config_file_path() { return config_file_path_; }
+
+ private:
+  // Finishes initialization after the threading system has been fully
+  // intiialized.
+  void InitAfterFileThreadAvailable();
+
+  // Creates the file path watcher and configures it watch |config_file_path_|.
+  // Must be called on the file thread.
+  void InitWatcher();
+
+  // Cancels file path watch notification and destroys the watcher.
+  // Must be called on file thread.
+  void StopOnFileThread();
+
+  // Schedules a reload task to run when |delay| expires. Must be called on the
+  // file thread.
+  void ScheduleReloadTask(const base::TimeDelta& delay);
+
+  // Schedules a reload task to run after the number of minutes specified
+  // in |reload_interval_minutes_|. Must be called on the file thread.
+  void ScheduleFallbackReloadTask();
+
+  // Invoked from the reload task on the file thread.
+  void ReloadFromTask();
+
+  // Checks whether policy information is safe to read. If not, returns false
+  // and then delays until it is considered safe to reload in |delay|.
+  // Must be called on the file thread.
+  bool IsSafeToReloadPolicy(const base::Time& now, base::TimeDelta* delay);
+
+  // The path at which we look for configuration files.
+  const FilePath config_file_path_;
+
+  // Managed with a scoped_ptr rather than being declared as an inline member to
+  // decouple the watcher's life cycle from the loader's. This decoupling makes
+  // it possible to destroy the watcher before the loader's destructor is called
+  // (e.g. during Stop), since |watcher_| internally holds a reference to the
+  // loader and keeps it alive.
+  scoped_ptr<FilePathWatcher> watcher_;
+
+  // 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_;
+
+  // The interval that a policy reload will be triggered as a fallback even if
+  // the delegate doesn't indicate that one is needed.
+  const base::TimeDelta  reload_interval_;
+
+  // Settle interval.
+  const base::TimeDelta settle_interval_;
+
+  // Records last known modification timestamp of |config_file_path_|.
+  base::Time last_modification_file_;
+
+  // The wall clock time at which the last modification timestamp was
+  // recorded.  It's better to not assume the file notification time and the
+  // wall clock times come from the same source, just in case there is some
+  // non-local filesystem involved.
+  base::Time last_modification_clock_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileBasedPolicyLoader);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_FILE_BASED_POLICY_LOADER_H_