Refactor the windows policy provider to use AsynchronousPolicyProvider.

chrome/browser/policy/asynchronous_policy_loader.cc

 // 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_loader.h"
 
 #include "base/message_loop.h"
 #include "base/task.h"
+#include "chrome/browser/browser_thread.h"
 
 namespace policy {
 
 AsynchronousPolicyLoader::AsynchronousPolicyLoader(
-    AsynchronousPolicyProvider::Delegate* delegate)
+    AsynchronousPolicyProvider::Delegate* delegate,
+    int reload_interval_minutes)
     : delegate_(delegate),
       provider_(NULL),
-      origin_loop_(MessageLoop::current()) {}
+      reload_task_(NULL),
+      reload_interval_(base::TimeDelta::FromMinutes(reload_interval_minutes)),
+      origin_loop_(MessageLoop::current()),
+      stopped_(false) {}
 
 void AsynchronousPolicyLoader::Init() {
   policy_.reset(delegate_->Load());
+  // Initialization can happen early when the file thread is not yet available,
+  // but the subclass of the loader must do some of their initialization on the
+  // file thread. Posting to the file thread directly before it is initialized
+  // will cause the task to be forgotten. Instead, post a task to the ui thread
+  // to delay the remainder of initialization until threading is fully
+  // initialized.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &AsynchronousPolicyLoader::InitAfterFileThreadAvailable));
 }
 
 void AsynchronousPolicyLoader::Stop() {
-  delegate_.reset();
+  if (!stopped_) {
+    stopped_ = true;
+    delegate_.reset();
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        NewRunnableMethod(this, &AsynchronousPolicyLoader::StopOnFileThread));
+  }
 }
 
 void AsynchronousPolicyLoader::SetProvider(
     AsynchronousPolicyProvider* provider) {
   provider_ = provider;
 }
 
 AsynchronousPolicyLoader::~AsynchronousPolicyLoader() {
 }
 
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(UpdatePolicyTask);
 };
 
 void AsynchronousPolicyLoader::Reload() {
   if (delegate_.get()) {
     DictionaryValue* new_policy = delegate_->Load();
     PostUpdatePolicyTask(new_policy);
   }
 }
 
+void AsynchronousPolicyLoader::CancelReloadTask() {
+  if (reload_task_) {
+    // Only check the thread if there's still a reload task. During
+    // destruction of unit tests, the message loop destruction can
+    // call this method when the file thread is no longer around,
+    // but in that case reload_task_ is NULL.
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    reload_task_->Cancel();
+    reload_task_ = NULL;
+  }
+}
+
+void AsynchronousPolicyLoader::ScheduleReloadTask(
+    const base::TimeDelta& delay) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  CancelReloadTask();
+
+  reload_task_ =
+      NewRunnableMethod(this, &AsynchronousPolicyLoader::ReloadFromTask);
+  BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE, reload_task_,
+                                 delay.InMilliseconds());
+}
+
+void AsynchronousPolicyLoader::ScheduleFallbackReloadTask() {
+  // As a safeguard in case that the load delegate failed to timely notice a
+  // change in policy, schedule a reload task that'll make us recheck after a
+  // reasonable interval.
+  ScheduleReloadTask(reload_interval_);
+}
+
+void AsynchronousPolicyLoader::ReloadFromTask() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  // Drop the reference to the reload task, since the task might be the only
+  // referrer that keeps us alive, so we should not Cancel() it.
+  reload_task_ = NULL;
+
+  Reload();
+}
+
+void AsynchronousPolicyLoader::InitOnFileThread() {
+}
+
+void AsynchronousPolicyLoader::StopOnFileThread() {
+  CancelReloadTask();
+}
+
 void AsynchronousPolicyLoader::PostUpdatePolicyTask(
     DictionaryValue* new_policy) {
   origin_loop_->PostTask(FROM_HERE, new UpdatePolicyTask(this, new_policy));
 }
 
 void AsynchronousPolicyLoader::UpdatePolicy(DictionaryValue* new_policy_raw) {
   scoped_ptr<DictionaryValue> new_policy(new_policy_raw);
   DCHECK(policy_.get());
   if (!policy_->Equals(new_policy.get())) {
     policy_.reset(new_policy.release());
     // TODO(danno): Change the notification between the provider and the
     // PrefStore into a notification mechanism, removing the need for the
     // WeakPtr for the provider.
     if (provider_)
       provider_->NotifyStoreOfPolicyChange();
   }
 }
 
+void AsynchronousPolicyLoader::InitAfterFileThreadAvailable() {
+  if (!stopped_) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        NewRunnableMethod(this, &AsynchronousPolicyLoader::InitOnFileThread));
+  }
+}
+
 }  // namespace policy