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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// Copyright 2016 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 COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_SCHEDULER_IMPL_H_
#define COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_SCHEDULER_IMPL_H_
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/macros.h"
#include "base/time/clock.h"
#include "base/time/time.h"
#include "components/ntp_snippets/content_suggestions_provider.h"
#include "components/ntp_snippets/logger.h"
#include "components/ntp_snippets/remote/persistent_scheduler.h"
#include "components/ntp_snippets/remote/remote_suggestions_scheduler.h"
#include "components/ntp_snippets/remote/request_throttler.h"
#include "components/web_resource/eula_accepted_notifier.h"
class PrefRegistrySimple;
class PrefService;
namespace base {
class Clock;
}
namespace ntp_snippets {
struct Status;
class EulaState;
class UserClassifier;
// A client of RemoteSuggestionsProvider that introduces periodic fetching.
class RemoteSuggestionsSchedulerImpl : public RemoteSuggestionsScheduler {
public:
RemoteSuggestionsSchedulerImpl(PersistentScheduler* persistent_scheduler,
const UserClassifier* user_classifier,
PrefService* profile_prefs,
PrefService* local_state_prefs,
base::Clock* clock,
Logger* debug_logger);
~RemoteSuggestionsSchedulerImpl() override;
static void RegisterProfilePrefs(PrefRegistrySimple* registry);
// RemoteSuggestionsScheduler implementation.
void SetProvider(RemoteSuggestionsProvider* provider) override;
void OnProviderActivated() override;
void OnProviderDeactivated() override;
void OnSuggestionsCleared() override;
void OnHistoryCleared() override;
void OnBrowserUpgraded() override;
bool AcquireQuotaForInteractiveFetch() override;
void OnInteractiveFetchFinished(Status fetch_status) override;
void OnPersistentSchedulerWakeUp() override;
void OnBrowserForegrounded() override;
void OnBrowserColdStart() override;
void OnSuggestionsSurfaceOpened() override;
private:
// Abstract description of the fetching schedule. See the enum
// FetchingInterval for more documentation.
struct FetchingSchedule {
static FetchingSchedule Empty();
bool operator==(const FetchingSchedule& other) const;
bool operator!=(const FetchingSchedule& other) const;
bool is_empty() const;
// Interval since the last successful fetch after which to consider the
// current content stale.
base::TimeDelta GetStalenessInterval() const;
// Intervals since the last fetch attempt after which to fetch again
// (depending on the trigger and connectivity).
base::TimeDelta interval_persistent_wifi;
base::TimeDelta interval_persistent_fallback;
base::TimeDelta interval_startup_wifi;
base::TimeDelta interval_startup_fallback;
base::TimeDelta interval_shown_wifi;
base::TimeDelta interval_shown_fallback;
};
enum class TriggerType;
// After the call, updates will be scheduled in the future. Idempotent, can be
// run any time later without impacting the current schedule.
// If you want to enforce rescheduling, call Unschedule() and then Schedule().
void StartScheduling();
// After the call, no updates will happen before another call to Schedule().
// Idempotent, can be run any time later without impacting the current
// schedule.
void StopScheduling();
bool IsLastSuccessfulFetchStale() const;
// Trigger a background refetch for the given |trigger| if enabled and if the
// timing is appropriate for another fetch.
void RefetchIfAppropriate(TriggerType trigger);
// Checks whether it is time to perform a soft background fetch for |trigger|,
// according to |schedule|.
bool ShouldRefetchNow(base::Time last_fetch_attempt_time,
TriggerType trigger);
// Returns whether all components are ready for background fetches.
bool IsReadyForBackgroundFetches() const;
// Runs any queued triggers if the system is ready for background fetches.
void RunQueuedTriggersIfReady();
// Returns true if quota is available for another request.
bool AcquireQuota(bool interactive_request);
// Callback after Refetch is completed.
void RefetchFinished(Status fetch_status);
// Common function to call after a fetch of any type is finished.
void OnFetchCompleted(Status fetch_status);
// Clears the time of the last fetch so that the provider is ready to make a
// soft fetch at any later time (upon a trigger), treating the last fetch as
// stale.
void ClearLastFetchAttemptTime();
FetchingSchedule GetDesiredFetchingSchedule() const;
// Load and store |schedule_|.
void LoadLastFetchingSchedule();
void StoreFetchingSchedule();
// Applies the persistent schedule given by |schedule_|.
void ApplyPersistentFetchingSchedule();
// Gets enabled trigger types from the variation parameter.
std::set<TriggerType> GetEnabledTriggerTypes();
// Gets trigger types enabled by default.
std::set<TriggerType> GetDefaultEnabledTriggerTypes();
// Interface for scheduling hard fetches, OS dependent. Not owned, may be
// null.
PersistentScheduler* persistent_scheduler_;
// Interface for doing all the actual work (apart from scheduling). Not owned.
RemoteSuggestionsProvider* provider_;
FetchingSchedule schedule_;
bool background_fetch_in_progress_;
// Used to adapt the schedule based on usage activity of the user. Not owned.
const UserClassifier* user_classifier_;
// Request throttlers for limiting requests for different classes of users.
RequestThrottler request_throttler_rare_ntp_user_;
RequestThrottler request_throttler_active_ntp_user_;
RequestThrottler request_throttler_active_suggestions_consumer_;
// Variables to make sure we only report the first trigger of each kind to
// UMA.
bool time_until_first_shown_trigger_reported_;
bool time_until_first_startup_trigger_reported_;
// We should not fetch in background before EULA gets accepted.
std::unique_ptr<EulaState> eula_state_;
PrefService* profile_prefs_;
base::Clock* clock_;
std::set<TriggerType> enabled_triggers_;
std::set<TriggerType> queued_triggers_;
base::Time background_fetches_allowed_after_;
// Additional logging, accesible through snippets-internals.
Logger* debug_logger_;
DISALLOW_COPY_AND_ASSIGN(RemoteSuggestionsSchedulerImpl);
};
} // namespace ntp_snippets
#endif // COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_SCHEDULER_IMPL_H_
|
