Refactor FileBasedPolicyProvider, introduce AsynchronousPolicyProvider.

chrome/browser/policy/asynchronous_policy_provider.cc

Index: chrome/browser/policy/asynchronous_policy_provider.cc
diff --git a/chrome/browser/policy/asynchronous_policy_provider.cc b/chrome/browser/policy/asynchronous_policy_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1e80ee5f857d9a59feb35445597486e32259ca76
--- /dev/null
+++ b/chrome/browser/policy/asynchronous_policy_provider.cc
@@ -0,0 +1,72 @@
+// 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.
+
+#include "chrome/browser/policy/asynchronous_policy_provider.h"
+
+#include "base/task.h"
+#include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/asynchronous_policy_loader.h"
+
+namespace {
+
+// The time interval for rechecking policy. This is our fallback in case the
+// delegate never reports a change to the ReloadObserver.
+const int kReloadIntervalMinutes = 15;

[Mattias Nissler (ping if slow), 2010/12/02 18:16:00]

Is the hardcoded interval appropriate for this very generic interface?

[danno, 2010/12/03 17:05:38]

Done.

+
+}
+
+namespace policy {
+
+class TriggerReloadPolicyChangeObserver
+    : public AsynchronousPolicyProvider::PolicyChangeObserver {
+ public:
+  TriggerReloadPolicyChangeObserver(
+      scoped_refptr<AsynchronousPolicyLoader> loader)
+      : AsynchronousPolicyProvider::PolicyChangeObserver(),
+        loader_(loader) {}
+  virtual ~TriggerReloadPolicyChangeObserver() {}
+
+  virtual void OnPolicyChange() {
+    if (BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
+      loader_->Reload();
+    } else {
+      BrowserThread::PostTask(
+          BrowserThread::FILE, FROM_HERE,
+          NewRunnableMethod(loader_.get(),
+                            &AsynchronousPolicyLoader::Reload));
+    }
+  }
+
+ private:
+  scoped_refptr<AsynchronousPolicyLoader> loader_;
+  DISALLOW_COPY_AND_ASSIGN(TriggerReloadPolicyChangeObserver);
+};
+
+AsynchronousPolicyProvider::AsynchronousPolicyProvider(
+    const PolicyDefinitionList* policy_list,
+    AsynchronousPolicyProvider::Delegate* delegate)
+    : ConfigurationPolicyProvider(policy_list),
+      delegate_(delegate) {
+  loader_ = new AsynchronousPolicyLoader(
+      this->AsWeakPtr(),
+      delegate,
+      kReloadIntervalMinutes);
+  loader_->Init();
+  delegate_->Init(new TriggerReloadPolicyChangeObserver(loader_));
+}
+
+AsynchronousPolicyProvider::~AsynchronousPolicyProvider() {
+  delegate_->Stop();
+  loader_->Stop();
+}
+
+bool AsynchronousPolicyProvider::Provide(
+    ConfigurationPolicyStoreInterface* store) {
+  scoped_ptr<DictionaryValue> policy(loader_->GetPolicy());
+  DCHECK(policy.get());
+  DecodePolicyValueTree(policy.get(), store);
+  return true;
+}
+
+}  // namespace policy