| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/policy/async_policy_loader.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/location.h" | |
| 9 #include "base/sequenced_task_runner.h" | |
| 10 #include "components/policy/core/common/policy_bundle.h" | |
| 11 | |
| 12 using base::Time; | |
| 13 using base::TimeDelta; | |
| 14 | |
| 15 namespace policy { | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // Amount of time to wait for the files on disk to settle before trying to load | |
| 20 // them. This alleviates the problem of reading partially written files and | |
| 21 // makes it possible to batch quasi-simultaneous changes. | |
| 22 const int kSettleIntervalSeconds = 5; | |
| 23 | |
| 24 // The time interval for rechecking policy. This is the fallback in case the | |
| 25 // implementation never detects changes. | |
| 26 const int kReloadIntervalSeconds = 15 * 60; | |
| 27 | |
| 28 } // namespace | |
| 29 | |
| 30 AsyncPolicyLoader::AsyncPolicyLoader( | |
| 31 scoped_refptr<base::SequencedTaskRunner> task_runner) | |
| 32 : task_runner_(task_runner), | |
| 33 weak_factory_(this) {} | |
| 34 | |
| 35 AsyncPolicyLoader::~AsyncPolicyLoader() {} | |
| 36 | |
| 37 Time AsyncPolicyLoader::LastModificationTime() { | |
| 38 return Time(); | |
| 39 } | |
| 40 | |
| 41 void AsyncPolicyLoader::Reload(bool force) { | |
| 42 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | |
| 43 | |
| 44 TimeDelta delay; | |
| 45 Time now = Time::Now(); | |
| 46 // Check if there was a recent modification to the underlying files. | |
| 47 if (!force && !IsSafeToReload(now, &delay)) { | |
| 48 ScheduleNextReload(delay); | |
| 49 return; | |
| 50 } | |
| 51 | |
| 52 scoped_ptr<PolicyBundle> bundle(Load()); | |
| 53 | |
| 54 // Check if there was a modification while reading. | |
| 55 if (!force && !IsSafeToReload(now, &delay)) { | |
| 56 ScheduleNextReload(delay); | |
| 57 return; | |
| 58 } | |
| 59 | |
| 60 // Filter out mismatching policies. | |
| 61 schema_map_->FilterBundle(bundle.get()); | |
| 62 | |
| 63 update_callback_.Run(bundle.Pass()); | |
| 64 ScheduleNextReload(TimeDelta::FromSeconds(kReloadIntervalSeconds)); | |
| 65 } | |
| 66 | |
| 67 scoped_ptr<PolicyBundle> AsyncPolicyLoader::InitialLoad( | |
| 68 const scoped_refptr<SchemaMap>& schema_map) { | |
| 69 // This is the first load, early during startup. Use this to record the | |
| 70 // initial |last_modification_time_|, so that potential changes made before | |
| 71 // installing the watches can be detected. | |
| 72 last_modification_time_ = LastModificationTime(); | |
| 73 schema_map_ = schema_map; | |
| 74 scoped_ptr<PolicyBundle> bundle(Load()); | |
| 75 // Filter out mismatching policies. | |
| 76 schema_map_->FilterBundle(bundle.get()); | |
| 77 return bundle.Pass(); | |
| 78 } | |
| 79 | |
| 80 void AsyncPolicyLoader::Init(const UpdateCallback& update_callback) { | |
| 81 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | |
| 82 DCHECK(update_callback_.is_null()); | |
| 83 DCHECK(!update_callback.is_null()); | |
| 84 update_callback_ = update_callback; | |
| 85 | |
| 86 InitOnBackgroundThread(); | |
| 87 | |
| 88 // There might have been changes to the underlying files since the initial | |
| 89 // load and before the watchers have been created. | |
| 90 if (LastModificationTime() != last_modification_time_) | |
| 91 Reload(false); | |
| 92 | |
| 93 // Start periodic refreshes. | |
| 94 ScheduleNextReload(TimeDelta::FromSeconds(kReloadIntervalSeconds)); | |
| 95 } | |
| 96 | |
| 97 void AsyncPolicyLoader::RefreshPolicies(scoped_refptr<SchemaMap> schema_map) { | |
| 98 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | |
| 99 schema_map_ = schema_map; | |
| 100 Reload(true); | |
| 101 } | |
| 102 | |
| 103 void AsyncPolicyLoader::ScheduleNextReload(TimeDelta delay) { | |
| 104 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | |
| 105 weak_factory_.InvalidateWeakPtrs(); | |
| 106 task_runner_->PostDelayedTask(FROM_HERE, | |
| 107 base::Bind(&AsyncPolicyLoader::Reload, | |
| 108 weak_factory_.GetWeakPtr(), | |
| 109 false /* force */), | |
| 110 delay); | |
| 111 } | |
| 112 | |
| 113 bool AsyncPolicyLoader::IsSafeToReload(const Time& now, TimeDelta* delay) { | |
| 114 Time last_modification = LastModificationTime(); | |
| 115 if (last_modification.is_null()) | |
| 116 return true; | |
| 117 | |
| 118 // If there was a change since the last recorded modification, wait some more. | |
| 119 const TimeDelta kSettleInterval( | |
| 120 TimeDelta::FromSeconds(kSettleIntervalSeconds)); | |
| 121 if (last_modification != last_modification_time_) { | |
| 122 last_modification_time_ = last_modification; | |
| 123 last_modification_clock_ = now; | |
| 124 *delay = kSettleInterval; | |
| 125 return false; | |
| 126 } | |
| 127 | |
| 128 // Check whether the settle interval has elapsed. | |
| 129 const TimeDelta age = now - last_modification_clock_; | |
| 130 if (age < kSettleInterval) { | |
| 131 *delay = kSettleInterval - age; | |
| 132 return false; | |
| 133 } | |
| 134 | |
| 135 return true; | |
| 136 } | |
| 137 | |
| 138 } // namespace policy | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 92263002:
Move AsyncPolicyProvider, etc. to components/policy/. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src