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/sync/about_sync_util.h"
6
7 #include <string>
8
9 #include "base/strings/string16.h"
10 #include "base/strings/stringprintf.h"
11 #include "base/values.h"
12 #include "chrome/browser/sync/profile_sync_service.h"
13 #include "chrome/common/chrome_version_info.h"
14 #include "components/signin/core/browser/signin_manager.h"
15 #include "sync/api/time.h"
16 #include "sync/internal_api/public/util/sync_string_conversions.h"
17 #include "sync/protocol/proto_enum_conversions.h"
18
19 using base::DictionaryValue;
20 using base::ListValue;
21
22 const char kIdentityTitle[] = "Identity";
23 const char kDetailsKey[] = "details";
24
25 namespace {
26
27 // Creates a 'section' for display on about:sync, consisting of a title and a
28 // list of fields. Returns a pointer to the new section. Note that
29 // |parent_list|, not the caller, owns the newly added section.
AddSection(base::ListValue * parent_list,const std::string & title)30 base::ListValue* AddSection(base::ListValue* parent_list,
31 const std::string& title) {
32 base::DictionaryValue* section = new base::DictionaryValue();
33 base::ListValue* section_contents = new base::ListValue();
34 section->SetString("title", title);
35 section->Set("data", section_contents);
36 section->SetBoolean("is_sensitive", false);
37 parent_list->Append(section);
38 return section_contents;
39 }
40
41 // Same as AddSection, but for data that should be elided when dumped into text
42 // form and posted in a public forum (e.g. unique identifiers).
AddSensitiveSection(base::ListValue * parent_list,const std::string & title)43 base::ListValue* AddSensitiveSection(base::ListValue* parent_list,
44 const std::string& title) {
45 base::DictionaryValue* section = new base::DictionaryValue();
46 base::ListValue* section_contents = new base::ListValue();
47 section->SetString("title", title);
48 section->Set("data", section_contents);
49 section->SetBoolean("is_sensitive", true);
50 parent_list->Append(section);
51 return section_contents;
52 }
53
54 // The following helper classes help manage the about:sync fields which will be
55 // populated in method in ConstructAboutInformation.
56 //
57 // Each instance of one of thse classes indicates a field in about:sync. Each
58 // field will be serialized to a DictionaryValue with entries for 'stat_name',
59 // 'stat_value' and 'is_valid'.
60
61 class StringSyncStat {
62 public:
63 StringSyncStat(base::ListValue* section, const std::string& key);
64 void SetValue(const std::string& value);
65 void SetValue(const base::string16& value);
66
67 private:
68 // Owned by the |section| passed in during construction.
69 base::DictionaryValue* stat_;
70 };
71
StringSyncStat(base::ListValue * section,const std::string & key)72 StringSyncStat::StringSyncStat(base::ListValue* section,
73 const std::string& key) {
74 stat_ = new base::DictionaryValue();
75 stat_->SetString("stat_name", key);
76 stat_->SetString("stat_value", "Uninitialized");
77 stat_->SetBoolean("is_valid", false);
78 section->Append(stat_);
79 }
80
SetValue(const std::string & value)81 void StringSyncStat::SetValue(const std::string& value) {
82 stat_->SetString("stat_value", value);
83 stat_->SetBoolean("is_valid", true);
84 }
85
SetValue(const base::string16 & value)86 void StringSyncStat::SetValue(const base::string16& value) {
87 stat_->SetString("stat_value", value);
88 stat_->SetBoolean("is_valid", true);
89 }
90
91 class BoolSyncStat {
92 public:
93 BoolSyncStat(base::ListValue* section, const std::string& key);
94 void SetValue(bool value);
95
96 private:
97 // Owned by the |section| passed in during construction.
98 base::DictionaryValue* stat_;
99 };
100
BoolSyncStat(base::ListValue * section,const std::string & key)101 BoolSyncStat::BoolSyncStat(base::ListValue* section, const std::string& key) {
102 stat_ = new base::DictionaryValue();
103 stat_->SetString("stat_name", key);
104 stat_->SetBoolean("stat_value", false);
105 stat_->SetBoolean("is_valid", false);
106 section->Append(stat_);
107 }
108
SetValue(bool value)109 void BoolSyncStat::SetValue(bool value) {
110 stat_->SetBoolean("stat_value", value);
111 stat_->SetBoolean("is_valid", true);
112 }
113
114 class IntSyncStat {
115 public:
116 IntSyncStat(base::ListValue* section, const std::string& key);
117 void SetValue(int value);
118
119 private:
120 // Owned by the |section| passed in during construction.
121 base::DictionaryValue* stat_;
122 };
123
IntSyncStat(base::ListValue * section,const std::string & key)124 IntSyncStat::IntSyncStat(base::ListValue* section, const std::string& key) {
125 stat_ = new base::DictionaryValue();
126 stat_->SetString("stat_name", key);
127 stat_->SetInteger("stat_value", 0);
128 stat_->SetBoolean("is_valid", false);
129 section->Append(stat_);
130 }
131
SetValue(int value)132 void IntSyncStat::SetValue(int value) {
133 stat_->SetInteger("stat_value", value);
134 stat_->SetBoolean("is_valid", true);
135 }
136
137 // Returns a string describing the chrome version environment. Version format:
138 // <Build Info> <OS> <Version number> (<Last change>)<channel or "-devel">
139 // If version information is unavailable, returns "invalid."
140 // TODO(zea): this approximately matches MakeUserAgentForSyncApi in
141 // sync_backend_host.cc. Unify the two if possible.
GetVersionString()142 std::string GetVersionString() {
143 // Build a version string that matches MakeUserAgentForSyncApi with the
144 // addition of channel info and proper OS names.
145 chrome::VersionInfo chrome_version;
146 if (!chrome_version.is_valid())
147 return "invalid";
148 // GetVersionStringModifier returns empty string for stable channel or
149 // unofficial builds, the channel string otherwise. We want to have "-devel"
150 // for unofficial builds only.
151 std::string version_modifier =
152 chrome::VersionInfo::GetVersionStringModifier();
153 if (version_modifier.empty()) {
154 if (chrome::VersionInfo::GetChannel() !=
155 chrome::VersionInfo::CHANNEL_STABLE) {
156 version_modifier = "-devel";
157 }
158 } else {
159 version_modifier = " " + version_modifier;
160 }
161 return chrome_version.Name() + " " + chrome_version.OSType() + " " +
162 chrome_version.Version() + " (" + chrome_version.LastChange() + ")" +
163 version_modifier;
164 }
165
GetTimeStr(base::Time time,const std::string & default_msg)166 std::string GetTimeStr(base::Time time, const std::string& default_msg) {
167 std::string time_str;
168 if (time.is_null())
169 time_str = default_msg;
170 else
171 time_str = syncer::GetTimeDebugString(time);
172 return time_str;
173 }
174
GetConnectionStatus(const ProfileSyncService::SyncTokenStatus & status)175 std::string GetConnectionStatus(
176 const ProfileSyncService::SyncTokenStatus& status) {
177 std::string message;
178 switch (status.connection_status) {
179 case syncer::CONNECTION_NOT_ATTEMPTED:
180 base::StringAppendF(&message, "not attempted");
181 break;
182 case syncer::CONNECTION_OK:
183 base::StringAppendF(
184 &message, "OK since %s",
185 GetTimeStr(status.connection_status_update_time, "n/a").c_str());
186 break;
187 case syncer::CONNECTION_AUTH_ERROR:
188 base::StringAppendF(
189 &message, "auth error since %s",
190 GetTimeStr(status.connection_status_update_time, "n/a").c_str());
191 break;
192 case syncer::CONNECTION_SERVER_ERROR:
193 base::StringAppendF(
194 &message, "server error since %s",
195 GetTimeStr(status.connection_status_update_time, "n/a").c_str());
196 break;
197 default:
198 NOTREACHED();
199 }
200 return message;
201 }
202
203 } // namespace
204
205 namespace sync_ui_util {
206
207 // This function both defines the structure of the message to be returned and
208 // its contents. Most of the message consists of simple fields in about:sync
209 // which are grouped into sections and populated with the help of the SyncStat
210 // classes defined above.
ConstructAboutInformation(ProfileSyncService * service)211 scoped_ptr<base::DictionaryValue> ConstructAboutInformation(
212 ProfileSyncService* service) {
213 scoped_ptr<base::DictionaryValue> about_info(new base::DictionaryValue());
214
215 // 'details': A list of sections.
216 base::ListValue* stats_list = new base::ListValue();
217
218 // The following lines define the sections and their fields. For each field,
219 // a class is instantiated, which allows us to reference the fields in
220 // 'setter' code later on in this function.
221 base::ListValue* section_summary = AddSection(stats_list, "Summary");
222 StringSyncStat summary_string(section_summary, "Summary");
223
224 base::ListValue* section_version = AddSection(stats_list, "Version Info");
225 StringSyncStat client_version(section_version, "Client Version");
226 StringSyncStat server_url(section_version, "Server URL");
227
228 base::ListValue* section_identity =
229 AddSensitiveSection(stats_list, kIdentityTitle);
230 StringSyncStat sync_id(section_identity, "Sync Client ID");
231 StringSyncStat invalidator_id(section_identity, "Invalidator Client ID");
232 StringSyncStat username(section_identity, "Username");
233
234 base::ListValue* section_credentials = AddSection(stats_list, "Credentials");
235 StringSyncStat request_token_time(section_credentials, "Requested Token");
236 StringSyncStat receive_token_time(section_credentials, "Received Token");
237 StringSyncStat token_request_status(section_credentials,
238 "Token Request Status");
239 StringSyncStat next_token_request(section_credentials,
240 "Next Token Request");
241
242 base::ListValue* section_local = AddSection(stats_list, "Local State");
243 StringSyncStat server_connection(section_local,
244 "Server Connection");
245 StringSyncStat last_synced(section_local, "Last Synced");
246 BoolSyncStat is_setup_complete(section_local,
247 "Sync First-Time Setup Complete");
248 StringSyncStat backend_initialization(section_local,
249 "Sync Backend Initialization");
250 BoolSyncStat is_syncing(section_local, "Syncing");
251
252 base::ListValue* section_network = AddSection(stats_list, "Network");
253 BoolSyncStat is_throttled(section_network, "Throttled");
254 StringSyncStat retry_time(section_network, "Retry time (maybe stale)");
255 BoolSyncStat are_notifications_enabled(section_network,
256 "Notifications Enabled");
257
258 base::ListValue* section_encryption = AddSection(stats_list, "Encryption");
259 BoolSyncStat is_using_explicit_passphrase(section_encryption,
260 "Explicit Passphrase");
261 BoolSyncStat is_passphrase_required(section_encryption,
262 "Passphrase Required");
263 BoolSyncStat is_cryptographer_ready(section_encryption,
264 "Cryptographer Ready");
265 BoolSyncStat has_pending_keys(section_encryption,
266 "Cryptographer Has Pending Keys");
267 StringSyncStat encrypted_types(section_encryption, "Encrypted Types");
268 BoolSyncStat has_keystore_key(section_encryption, "Has Keystore Key");
269 StringSyncStat keystore_migration_time(section_encryption,
270 "Keystore Migration Time");
271 StringSyncStat passphrase_type(section_encryption,
272 "Passphrase Type");
273 StringSyncStat passphrase_time(section_encryption,
274 "Passphrase Time");
275
276 base::ListValue* section_last_session = AddSection(
277 stats_list, "Status from Last Completed Session");
278 StringSyncStat session_source(section_last_session, "Sync Source");
279 StringSyncStat get_key_result(section_last_session, "GetKey Step Result");
280 StringSyncStat download_result(section_last_session, "Download Step Result");
281 StringSyncStat commit_result(section_last_session, "Commit Step Result");
282
283 base::ListValue* section_counters = AddSection(stats_list, "Running Totals");
284 IntSyncStat notifications_received(section_counters,
285 "Notifications Received");
286 IntSyncStat updates_received(section_counters, "Updates Downloaded");
287 IntSyncStat tombstone_updates(section_counters, "Tombstone Updates");
288 IntSyncStat reflected_updates(section_counters, "Reflected Updates");
289 IntSyncStat successful_commits(section_counters, "Successful Commits");
290 IntSyncStat conflicts_resolved_local_wins(section_counters,
291 "Conflicts Resolved: Client Wins");
292 IntSyncStat conflicts_resolved_server_wins(section_counters,
293 "Conflicts Resolved: Server Wins");
294
295 base::ListValue *section_this_cycle = AddSection(stats_list,
296 "Transient Counters (this cycle)");
297 IntSyncStat encryption_conflicts(section_this_cycle, "Encryption Conflicts");
298 IntSyncStat hierarchy_conflicts(section_this_cycle, "Hierarchy Conflicts");
299 IntSyncStat server_conflicts(section_this_cycle, "Server Conflicts");
300 IntSyncStat committed_items(section_this_cycle, "Committed Items");
301
302 base::ListValue* section_that_cycle = AddSection(
303 stats_list, "Transient Counters (last cycle of last completed session)");
304 IntSyncStat updates_downloaded(section_that_cycle, "Updates Downloaded");
305 IntSyncStat committed_count(section_that_cycle, "Committed Count");
306 IntSyncStat entries(section_that_cycle, "Entries");
307
308 base::ListValue* section_nudge_info = AddSection(
309 stats_list, "Nudge Source Counters");
310 IntSyncStat nudge_source_notification(
311 section_nudge_info, "Server Invalidations");
312 IntSyncStat nudge_source_local(section_nudge_info, "Local Changes");
313 IntSyncStat nudge_source_local_refresh(section_nudge_info, "Local Refreshes");
314
315 // This list of sections belongs in the 'details' field of the returned
316 // message.
317 about_info->Set(kDetailsKey, stats_list);
318
319 // Populate all the fields we declared above.
320 client_version.SetValue(GetVersionString());
321
322 if (!service) {
323 summary_string.SetValue("Sync service does not exist");
324 return about_info.Pass();
325 }
326
327 syncer::SyncStatus full_status;
328 bool is_status_valid = service->QueryDetailedSyncStatus(&full_status);
329 bool sync_initialized = service->sync_initialized();
330 const syncer::sessions::SyncSessionSnapshot& snapshot =
331 sync_initialized ?
332 service->GetLastSessionSnapshot() :
333 syncer::sessions::SyncSessionSnapshot();
334
335 if (is_status_valid)
336 summary_string.SetValue(service->QuerySyncStatusSummaryString());
337
338 server_url.SetValue(service->sync_service_url().spec());
339
340 if (is_status_valid && !full_status.sync_id.empty())
341 sync_id.SetValue(full_status.sync_id);
342 if (is_status_valid && !full_status.invalidator_client_id.empty())
343 invalidator_id.SetValue(full_status.invalidator_client_id);
344 if (service->signin())
345 username.SetValue(service->signin()->GetAuthenticatedUsername());
346
347 const ProfileSyncService::SyncTokenStatus& token_status =
348 service->GetSyncTokenStatus();
349 server_connection.SetValue(GetConnectionStatus(token_status));
350 request_token_time.SetValue(GetTimeStr(token_status.token_request_time,
351 "n/a"));
352 receive_token_time.SetValue(GetTimeStr(token_status.token_receive_time,
353 "n/a"));
354 std::string err = token_status.last_get_token_error.error_message();
355 token_request_status.SetValue(err.empty() ? "OK" : err);
356 next_token_request.SetValue(
357 GetTimeStr(token_status.next_token_request_time, "not scheduled"));
358
359 last_synced.SetValue(service->GetLastSyncedTimeString());
360 is_setup_complete.SetValue(service->HasSyncSetupCompleted());
361 backend_initialization.SetValue(
362 service->GetBackendInitializationStateString());
363 if (is_status_valid) {
364 is_syncing.SetValue(full_status.syncing);
365 retry_time.SetValue(GetTimeStr(full_status.retry_time,
366 "Scheduler is not in backoff or throttled"));
367 }
368
369 if (snapshot.is_initialized())
370 is_throttled.SetValue(snapshot.is_silenced());
371 if (is_status_valid) {
372 are_notifications_enabled.SetValue(
373 full_status.notifications_enabled);
374 }
375
376 if (sync_initialized) {
377 is_using_explicit_passphrase.SetValue(
378 service->IsUsingSecondaryPassphrase());
379 is_passphrase_required.SetValue(service->IsPassphraseRequired());
380 passphrase_time.SetValue(
381 GetTimeStr(service->GetExplicitPassphraseTime(), "No Passphrase Time"));
382 }
383 if (is_status_valid) {
384 is_cryptographer_ready.SetValue(full_status.cryptographer_ready);
385 has_pending_keys.SetValue(full_status.crypto_has_pending_keys);
386 encrypted_types.SetValue(
387 ModelTypeSetToString(full_status.encrypted_types));
388 has_keystore_key.SetValue(full_status.has_keystore_key);
389 keystore_migration_time.SetValue(
390 GetTimeStr(full_status.keystore_migration_time, "Not Migrated"));
391 passphrase_type.SetValue(
392 PassphraseTypeToString(full_status.passphrase_type));
393 }
394
395 if (snapshot.is_initialized()) {
396 if (snapshot.legacy_updates_source() !=
397 sync_pb::GetUpdatesCallerInfo::UNKNOWN) {
398 session_source.SetValue(
399 syncer::GetUpdatesSourceString(snapshot.legacy_updates_source()));
400 }
401 get_key_result.SetValue(
402 GetSyncerErrorString(
403 snapshot.model_neutral_state().last_get_key_result));
404 download_result.SetValue(
405 GetSyncerErrorString(
406 snapshot.model_neutral_state().last_download_updates_result));
407 commit_result.SetValue(
408 GetSyncerErrorString(
409 snapshot.model_neutral_state().commit_result));
410 }
411
412 if (is_status_valid) {
413 notifications_received.SetValue(full_status.notifications_received);
414 updates_received.SetValue(full_status.updates_received);
415 tombstone_updates.SetValue(full_status.tombstone_updates_received);
416 reflected_updates.SetValue(full_status.reflected_updates_received);
417 successful_commits.SetValue(full_status.num_commits_total);
418 conflicts_resolved_local_wins.SetValue(
419 full_status.num_local_overwrites_total);
420 conflicts_resolved_server_wins.SetValue(
421 full_status.num_server_overwrites_total);
422 }
423
424 if (is_status_valid) {
425 encryption_conflicts.SetValue(full_status.encryption_conflicts);
426 hierarchy_conflicts.SetValue(full_status.hierarchy_conflicts);
427 server_conflicts.SetValue(full_status.server_conflicts);
428 committed_items.SetValue(full_status.committed_count);
429 }
430
431 if (is_status_valid) {
432 nudge_source_notification.SetValue(full_status.nudge_source_notification);
433 nudge_source_local.SetValue(full_status.nudge_source_local);
434 nudge_source_local_refresh.SetValue(full_status.nudge_source_local_refresh);
435 }
436
437 if (snapshot.is_initialized()) {
438 updates_downloaded.SetValue(
439 snapshot.model_neutral_state().num_updates_downloaded_total);
440 committed_count.SetValue(
441 snapshot.model_neutral_state().num_successful_commits);
442 entries.SetValue(snapshot.num_entries());
443 }
444
445 // The values set from this point onwards do not belong in the
446 // details list.
447
448 // We don't need to check is_status_valid here.
449 // full_status.sync_protocol_error is exported directly from the
450 // ProfileSyncService, even if the backend doesn't exist.
451 const bool actionable_error_detected =
452 full_status.sync_protocol_error.error_type != syncer::UNKNOWN_ERROR &&
453 full_status.sync_protocol_error.error_type != syncer::SYNC_SUCCESS;
454
455 about_info->SetBoolean("actionable_error_detected",
456 actionable_error_detected);
457
458 // NOTE: We won't bother showing any of the following values unless
459 // actionable_error_detected is set.
460
461 base::ListValue* actionable_error = new base::ListValue();
462 about_info->Set("actionable_error", actionable_error);
463
464 StringSyncStat error_type(actionable_error, "Error Type");
465 StringSyncStat action(actionable_error, "Action");
466 StringSyncStat url(actionable_error, "URL");
467 StringSyncStat description(actionable_error, "Error Description");
468
469 if (actionable_error_detected) {
470 error_type.SetValue(syncer::GetSyncErrorTypeString(
471 full_status.sync_protocol_error.error_type));
472 action.SetValue(syncer::GetClientActionString(
473 full_status.sync_protocol_error.action));
474 url.SetValue(full_status.sync_protocol_error.url);
475 description.SetValue(full_status.sync_protocol_error.error_description);
476 }
477
478 about_info->SetBoolean("unrecoverable_error_detected",
479 service->HasUnrecoverableError());
480
481 if (service->HasUnrecoverableError()) {
482 tracked_objects::Location loc(service->unrecoverable_error_location());
483 std::string location_str;
484 loc.Write(true, true, &location_str);
485 std::string unrecoverable_error_message =
486 "Unrecoverable error detected at " + location_str +
487 ": " + service->unrecoverable_error_message();
488 about_info->SetString("unrecoverable_error_message",
489 unrecoverable_error_message);
490 }
491
492 about_info->Set("type_status", service->GetTypeStatusMap());
493
494 return about_info.Pass();
495 }
496
497 } // namespace sync_ui_util
498