blob: a3d121b246356816ed501125f7bcaad75999142c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// 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.
#ifndef CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_REFRESH_SCHEDULER_H_
#define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_REFRESH_SCHEDULER_H_
#include "base/basictypes.h"
#include "base/cancelable_callback.h"
#include "base/memory/ref_counted.h"
#include "base/time/time.h"
#include "chrome/browser/policy/cloud/cloud_policy_client.h"
#include "chrome/browser/policy/cloud/cloud_policy_store.h"
#include "chrome/browser/policy/cloud/rate_limiter.h"
#include "net/base/network_change_notifier.h"
namespace base {
class SequencedTaskRunner;
}
namespace policy {
// Observes CloudPolicyClient and CloudPolicyStore to trigger periodic policy
// fetches and issue retries on error conditions.
class CloudPolicyRefreshScheduler
: public CloudPolicyClient::Observer,
public CloudPolicyStore::Observer,
public net::NetworkChangeNotifier::IPAddressObserver {
public:
// Refresh constants.
static const int64 kDefaultRefreshDelayMs;
static const int64 kUnmanagedRefreshDelayMs;
static const int64 kWithInvalidationsRefreshDelayMs;
static const int64 kInitialErrorRetryDelayMs;
// Refresh delay bounds.
static const int64 kRefreshDelayMinMs;
static const int64 kRefreshDelayMaxMs;
// |client| and |store| pointers must stay valid throughout the
// lifetime of CloudPolicyRefreshScheduler.
CloudPolicyRefreshScheduler(
CloudPolicyClient* client,
CloudPolicyStore* store,
const scoped_refptr<base::SequencedTaskRunner>& task_runner);
virtual ~CloudPolicyRefreshScheduler();
base::Time last_refresh() const { return last_refresh_; }
int64 refresh_delay() const { return refresh_delay_ms_; }
// Sets the refresh delay to |refresh_delay| (subject to min/max clamping).
void SetRefreshDelay(int64 refresh_delay);
// Requests a policy refresh to be performed soon. This may apply throttling,
// and the request may not be immediately sent.
void RefreshSoon();
// The refresh scheduler starts by assuming that invalidations are not
// available. This call can be used to signal whether the invalidations
// service is available or not, and can be called multiple times.
// When the invalidations service is available then the refresh rate is much
// lower.
void SetInvalidationServiceAvailability(bool is_available);
// Whether the invalidations service is available and receiving notifications
// of policy updates.
bool invalidations_available() {
return invalidations_available_;
}
// CloudPolicyClient::Observer:
virtual void OnPolicyFetched(CloudPolicyClient* client) OVERRIDE;
virtual void OnRegistrationStateChanged(CloudPolicyClient* client) OVERRIDE;
virtual void OnClientError(CloudPolicyClient* client) OVERRIDE;
// CloudPolicyStore::Observer:
virtual void OnStoreLoaded(CloudPolicyStore* store) OVERRIDE;
virtual void OnStoreError(CloudPolicyStore* store) OVERRIDE;
// net::NetworkChangeNotifier::IPAddressObserver:
virtual void OnIPAddressChanged() OVERRIDE;
private:
// Initializes |last_refresh_| to the policy timestamp from |store_| in case
// there is policy present that indicates this client is not managed. This
// results in policy fetches only to occur after the entire unmanaged refresh
// delay expires, even over restarts. For managed clients, we want to trigger
// a refresh on every restart.
void UpdateLastRefreshFromPolicy();
// Schedules a refresh to be performed immediately.
void RefreshNow();
// Evaluates when the next refresh is pending and updates the callback to
// execute that refresh at the appropriate time.
void ScheduleRefresh();
// Triggers a policy refresh.
void PerformRefresh();
// Schedules a policy refresh to happen after |delta_ms| milliseconds,
// relative to |last_refresh_|.
void RefreshAfter(int delta_ms);
// Sets the |wait_for_invalidations_timeout_callback_| and schedules it.
void WaitForInvalidationService();
// Callback for |wait_for_invalidations_timeout_callback_|.
void OnWaitForInvalidationServiceTimeout();
// Returns true if the refresh scheduler is currently waiting for the
// availability of the invalidations service.
bool WaitingForInvalidationService() const;
CloudPolicyClient* client_;
CloudPolicyStore* store_;
// For scheduling delayed tasks.
const scoped_refptr<base::SequencedTaskRunner> task_runner_;
// The delayed refresh callback.
base::CancelableClosure refresh_callback_;
// The last time a refresh callback completed.
base::Time last_refresh_;
// Error retry delay in milliseconds.
int64 error_retry_delay_ms_;
// The refresh delay.
int64 refresh_delay_ms_;
// Used to limit the rate at which refreshes are scheduled.
RateLimiter rate_limiter_;
// Whether the invalidations service is available and receiving notifications
// of policy updates.
bool invalidations_available_;
// The refresh scheduler waits some seconds for the invalidations service
// before starting to issue refresh requests. If the invalidations service
// doesn't become available during this time then the refresh scheduler will
// use the polling refresh rate.
base::CancelableClosure wait_for_invalidations_timeout_callback_;
// Used to measure how long it took for the invalidations service to report
// its initial status.
base::Time creation_time_;
DISALLOW_COPY_AND_ASSIGN(CloudPolicyRefreshScheduler);
};
} // namespace policy
#endif // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_REFRESH_SCHEDULER_H_
|
