Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

remoting/host/policy_hack/policy_watcher.cc

 // Copyright (c) 2012 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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_hack/policy_watcher.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
-#include "base/time/time.h"
 #include "base/values.h"
 #include "policy/policy_constants.h"
 #include "remoting/host/dns_blackhole_checker.h"
 
 #if !defined(NDEBUG)
 #include "base/json/json_reader.h"
 #endif
 
 namespace remoting {
 namespace policy_hack {
 
 namespace {
 
-// The time interval for rechecking policy. This is our fallback in case the
-// delegate never reports a change to the ReloadObserver.
-const int kFallbackReloadDelayMinutes = 15;
-
 // Copies all policy values from one dictionary to another, using values from
 // |default| if they are not set in |from|, or values from |bad_type_values| if
 // the value in |from| has the wrong type.
 scoped_ptr<base::DictionaryValue> CopyGoodValuesAndAddDefaults(
     const base::DictionaryValue* from,
     const base::DictionaryValue* default_values,
     const base::DictionaryValue* bad_type_values) {
   scoped_ptr<base::DictionaryValue> to(default_values->DeepCopy());
   for (base::DictionaryValue::Iterator i(*default_values);
        !i.IsAtEnd(); i.Advance()) {
@@ skipping 25 matching lines @@
     }
   }
 #endif  // defined(NDEBUG)
 
   return to.Pass();
 }
 
 }  // namespace
 
 PolicyWatcher::PolicyWatcher(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       transient_policy_error_retry_counter_(0),
       old_policies_(new base::DictionaryValue()),
       default_values_(new base::DictionaryValue()),
       weak_factory_(this) {
   // Initialize the default values for each policy.
   default_values_->SetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
                               true);
   default_values_->SetBoolean(policy::key::kRemoteAccessHostRequireTwoFactor,
                               false);
@@ skipping 60 matching lines @@
       stopped_callback);
 }
 
 void PolicyWatcher::StopWatchingOnPolicyWatcherThread() {
   StopWatchingInternal();
   weak_factory_.InvalidateWeakPtrs();
   policy_updated_callback_.Reset();
   policy_error_callback_.Reset();
 }
 
-void PolicyWatcher::ScheduleFallbackReloadTask() {
-  DCHECK(OnPolicyWatcherThread());
-  ScheduleReloadTask(
-      base::TimeDelta::FromMinutes(kFallbackReloadDelayMinutes));
-}
-
-void PolicyWatcher::ScheduleReloadTask(const base::TimeDelta& delay) {
-  DCHECK(OnPolicyWatcherThread());
-  task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&PolicyWatcher::Reload, weak_factory_.GetWeakPtr()),
-      delay);
-}
-
 const base::DictionaryValue& PolicyWatcher::Defaults() const {
   return *default_values_;
 }
 
 bool PolicyWatcher::OnPolicyWatcherThread() const {
   return task_runner_->BelongsToCurrentThread();
 }
 
 void PolicyWatcher::UpdatePolicies(
     const base::DictionaryValue* new_policies_raw) {
@@ skipping 36 matching lines @@
 void PolicyWatcher::SignalTransientPolicyError() {
   const int kMaxRetryCount = 5;
   transient_policy_error_retry_counter_ += 1;
   if (transient_policy_error_retry_counter_ >= kMaxRetryCount) {
     SignalPolicyError();
   }
 }
 
 }  // namespace policy_hack
 }  // namespace remoting