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 "components/sync/engine_impl/debug_info_event_listener.h"
6
7 #include <stddef.h>
8
9 #include "components/sync/nigori/cryptographer.h"
10
11 namespace syncer {
12
DebugInfoEventListener()13 DebugInfoEventListener::DebugInfoEventListener()
14 : events_dropped_(false),
15 cryptographer_has_pending_keys_(false),
16 cryptographer_can_encrypt_(false) {}
17
~DebugInfoEventListener()18 DebugInfoEventListener::~DebugInfoEventListener() {}
19
OnSyncCycleCompleted(const SyncCycleSnapshot & snapshot)20 void DebugInfoEventListener::OnSyncCycleCompleted(
21 const SyncCycleSnapshot& snapshot) {
22 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
23 sync_pb::DebugEventInfo event_info;
24 sync_pb::SyncCycleCompletedEventInfo* sync_completed_event_info =
25 event_info.mutable_sync_cycle_completed_event_info();
26
27 sync_completed_event_info->set_num_encryption_conflicts(
28 snapshot.num_encryption_conflicts());
29 sync_completed_event_info->set_num_hierarchy_conflicts(
30 snapshot.num_hierarchy_conflicts());
31 sync_completed_event_info->set_num_server_conflicts(
32 snapshot.num_server_conflicts());
33
34 sync_completed_event_info->set_num_updates_downloaded(
35 snapshot.model_neutral_state().num_updates_downloaded_total);
36 sync_completed_event_info->set_num_reflected_updates_downloaded(
37 snapshot.model_neutral_state().num_reflected_updates_downloaded_total);
38 sync_completed_event_info->set_get_updates_origin(
39 snapshot.get_updates_origin());
40 sync_completed_event_info->mutable_caller_info()->set_notifications_enabled(
41 snapshot.notifications_enabled());
42
43 // Fill the legacy GetUpdatesSource field. This is not used anymore, but it's
44 // a required field so we still have to fill it with something.
45 sync_completed_event_info->mutable_caller_info()->set_source(
46 sync_pb::GetUpdatesCallerInfo::UNKNOWN);
47
48 AddEventToQueue(event_info);
49 }
50
OnInitializationComplete(const WeakHandle<JsBackend> & js_backend,const WeakHandle<DataTypeDebugInfoListener> & debug_listener,bool success)51 void DebugInfoEventListener::OnInitializationComplete(
52 const WeakHandle<JsBackend>& js_backend,
53 const WeakHandle<DataTypeDebugInfoListener>& debug_listener,
54 bool success) {
55 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
56 CreateAndAddEvent(sync_pb::SyncEnums::INITIALIZATION_COMPLETE);
57 }
58
OnConnectionStatusChange(ConnectionStatus status)59 void DebugInfoEventListener::OnConnectionStatusChange(ConnectionStatus status) {
60 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
61 CreateAndAddEvent(sync_pb::SyncEnums::CONNECTION_STATUS_CHANGE);
62 }
63
OnPassphraseRequired(const KeyDerivationParams & key_derivation_params,const sync_pb::EncryptedData & pending_keys)64 void DebugInfoEventListener::OnPassphraseRequired(
65 const KeyDerivationParams& key_derivation_params,
66 const sync_pb::EncryptedData& pending_keys) {
67 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
68 CreateAndAddEvent(sync_pb::SyncEnums::PASSPHRASE_REQUIRED);
69 }
70
OnPassphraseAccepted()71 void DebugInfoEventListener::OnPassphraseAccepted() {
72 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
73 CreateAndAddEvent(sync_pb::SyncEnums::PASSPHRASE_ACCEPTED);
74 }
75
OnTrustedVaultKeyRequired()76 void DebugInfoEventListener::OnTrustedVaultKeyRequired() {
77 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
78 CreateAndAddEvent(sync_pb::SyncEnums::TRUSTED_VAULT_KEY_REQUIRED);
79 }
80
OnTrustedVaultKeyAccepted()81 void DebugInfoEventListener::OnTrustedVaultKeyAccepted() {
82 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
83 CreateAndAddEvent(sync_pb::SyncEnums::TRUSTED_VAULT_KEY_ACCEPTED);
84 }
85
OnBootstrapTokenUpdated(const std::string & bootstrap_token,BootstrapTokenType type)86 void DebugInfoEventListener::OnBootstrapTokenUpdated(
87 const std::string& bootstrap_token,
88 BootstrapTokenType type) {
89 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
90 if (type == PASSPHRASE_BOOTSTRAP_TOKEN) {
91 CreateAndAddEvent(sync_pb::SyncEnums::BOOTSTRAP_TOKEN_UPDATED);
92 return;
93 }
94 DCHECK_EQ(type, KEYSTORE_BOOTSTRAP_TOKEN);
95 CreateAndAddEvent(sync_pb::SyncEnums::KEYSTORE_TOKEN_UPDATED);
96 }
97
OnEncryptedTypesChanged(ModelTypeSet encrypted_types,bool encrypt_everything)98 void DebugInfoEventListener::OnEncryptedTypesChanged(
99 ModelTypeSet encrypted_types,
100 bool encrypt_everything) {
101 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
102 CreateAndAddEvent(sync_pb::SyncEnums::ENCRYPTED_TYPES_CHANGED);
103 }
104
OnCryptographerStateChanged(Cryptographer * cryptographer,bool has_pending_keys)105 void DebugInfoEventListener::OnCryptographerStateChanged(
106 Cryptographer* cryptographer,
107 bool has_pending_keys) {
108 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
109 cryptographer_has_pending_keys_ = has_pending_keys;
110 cryptographer_can_encrypt_ = cryptographer->CanEncrypt();
111 }
112
OnPassphraseTypeChanged(PassphraseType type,base::Time explicit_passphrase_time)113 void DebugInfoEventListener::OnPassphraseTypeChanged(
114 PassphraseType type,
115 base::Time explicit_passphrase_time) {
116 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
117 CreateAndAddEvent(sync_pb::SyncEnums::PASSPHRASE_TYPE_CHANGED);
118 }
119
OnActionableError(const SyncProtocolError & sync_error)120 void DebugInfoEventListener::OnActionableError(
121 const SyncProtocolError& sync_error) {
122 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
123 CreateAndAddEvent(sync_pb::SyncEnums::ACTIONABLE_ERROR);
124 }
125
OnMigrationRequested(ModelTypeSet types)126 void DebugInfoEventListener::OnMigrationRequested(ModelTypeSet types) {}
127
OnProtocolEvent(const ProtocolEvent & event)128 void DebugInfoEventListener::OnProtocolEvent(const ProtocolEvent& event) {}
129
OnNudgeFromDatatype(ModelType datatype)130 void DebugInfoEventListener::OnNudgeFromDatatype(ModelType datatype) {
131 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
132 sync_pb::DebugEventInfo event_info;
133 event_info.set_nudging_datatype(
134 GetSpecificsFieldNumberFromModelType(datatype));
135 AddEventToQueue(event_info);
136 }
137
GetDebugInfo() const138 sync_pb::DebugInfo DebugInfoEventListener::GetDebugInfo() const {
139 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
140 DCHECK_LE(events_.size(), kMaxEntries);
141
142 sync_pb::DebugInfo debug_info;
143 for (const sync_pb::DebugEventInfo& event : events_) {
144 *debug_info.add_events() = event;
145 }
146
147 debug_info.set_events_dropped(events_dropped_);
148 debug_info.set_cryptographer_ready(cryptographer_can_encrypt_);
149 debug_info.set_cryptographer_has_pending_keys(
150 cryptographer_has_pending_keys_);
151 return debug_info;
152 }
153
ClearDebugInfo()154 void DebugInfoEventListener::ClearDebugInfo() {
155 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
156 DCHECK_LE(events_.size(), kMaxEntries);
157
158 events_.clear();
159 events_dropped_ = false;
160 }
161
GetWeakPtr()162 base::WeakPtr<DataTypeDebugInfoListener> DebugInfoEventListener::GetWeakPtr() {
163 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
164 return weak_ptr_factory_.GetWeakPtr();
165 }
166
OnDataTypeConfigureComplete(const std::vector<DataTypeConfigurationStats> & configuration_stats)167 void DebugInfoEventListener::OnDataTypeConfigureComplete(
168 const std::vector<DataTypeConfigurationStats>& configuration_stats) {
169 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
170
171 for (size_t i = 0; i < configuration_stats.size(); ++i) {
172 DCHECK(ProtocolTypes().Has(configuration_stats[i].model_type));
173 sync_pb::DebugEventInfo association_event;
174 sync_pb::DatatypeAssociationStats* datatype_stats =
175 association_event.mutable_datatype_association_stats();
176 datatype_stats->set_data_type_id(GetSpecificsFieldNumberFromModelType(
177 configuration_stats[i].model_type));
178 datatype_stats->set_download_wait_time_us(
179 configuration_stats[i].download_wait_time.InMicroseconds());
180 datatype_stats->set_download_time_us(
181 configuration_stats[i].download_time.InMicroseconds());
182 datatype_stats->set_association_wait_time_for_high_priority_us(
183 configuration_stats[i]
184 .association_wait_time_for_high_priority.InMicroseconds());
185
186 for (ModelType type :
187 configuration_stats[i].high_priority_types_configured_before) {
188 datatype_stats->add_high_priority_type_configured_before(
189 GetSpecificsFieldNumberFromModelType(type));
190 }
191
192 for (ModelType type :
193 configuration_stats[i].same_priority_types_configured_before) {
194 datatype_stats->add_same_priority_type_configured_before(
195 GetSpecificsFieldNumberFromModelType(type));
196 }
197
198 AddEventToQueue(association_event);
199 }
200 }
201
CreateAndAddEvent(sync_pb::SyncEnums::SingletonDebugEventType type)202 void DebugInfoEventListener::CreateAndAddEvent(
203 sync_pb::SyncEnums::SingletonDebugEventType type) {
204 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
205 sync_pb::DebugEventInfo event_info;
206 event_info.set_singleton_event(type);
207 AddEventToQueue(event_info);
208 }
209
AddEventToQueue(const sync_pb::DebugEventInfo & event_info)210 void DebugInfoEventListener::AddEventToQueue(
211 const sync_pb::DebugEventInfo& event_info) {
212 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
213 if (events_.size() >= kMaxEntries) {
214 DVLOG(1) << "DebugInfoEventListener::AddEventToQueue Dropping an old event "
215 << "because of full queue";
216
217 events_.pop_front();
218 events_dropped_ = true;
219 }
220 events_.push_back(event_info);
221 }
222
223 } // namespace syncer
224