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/sync_ui_util.h" 6 7 #include "base/i18n/number_formatting.h" 8 #include "base/i18n/time_formatting.h" 9 #include "base/prefs/pref_service.h" 10 #include "base/strings/string_util.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "chrome/browser/profiles/profile.h" 13 #include "chrome/browser/profiles/profile_manager.h" 14 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" 15 #include "chrome/browser/signin/signin_ui_util.h" 16 #include "chrome/browser/sync/profile_sync_service.h" 17 #include "chrome/browser/sync/profile_sync_service_factory.h" 18 #include "chrome/browser/ui/browser.h" 19 #include "chrome/browser/ui/browser_window.h" 20 #include "chrome/browser/ui/webui/signin/login_ui_service.h" 21 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h" 22 #include "chrome/common/chrome_switches.h" 23 #include "chrome/common/pref_names.h" 24 #include "chrome/common/url_constants.h" 25 #include "components/signin/core/browser/profile_oauth2_token_service.h" 26 #include "components/signin/core/browser/signin_error_controller.h" 27 #include "components/signin/core/browser/signin_manager_base.h" 28 #include "google_apis/gaia/google_service_auth_error.h" 29 #include "grit/browser_resources.h" 30 #include "grit/chromium_strings.h" 31 #include "grit/generated_resources.h" 32 #include "grit/locale_settings.h" 33 #include "sync/internal_api/public/base/model_type.h" 34 #include "sync/internal_api/public/sessions/sync_session_snapshot.h" 35 #include "sync/protocol/proto_enum_conversions.h" 36 #include "sync/protocol/sync_protocol_error.h" 37 #include "ui/base/l10n/l10n_util.h" 38 #include "ui/base/resource/resource_bundle.h" 39 40 #if defined(OS_CHROMEOS) 41 #include "chrome/browser/chromeos/login/users/user_manager.h" 42 #endif // defined(OS_CHROMEOS) 43 44 typedef GoogleServiceAuthError AuthError; 45 46 namespace sync_ui_util { 47 48 namespace { 49 50 // Returns the message that should be displayed when the user is authenticated 51 // and can connect to the sync server. If the user hasn't yet authenticated, an 52 // empty string is returned. 53 base::string16 GetSyncedStateStatusLabel(ProfileSyncService* service, 54 const SigninManagerBase& signin, 55 StatusLabelStyle style) { 56 std::string user_display_name = signin.GetAuthenticatedUsername(); 57 58 #if defined(OS_CHROMEOS) 59 if (chromeos::UserManager::IsInitialized()) { 60 // On CrOS user email is sanitized and then passed to the signin manager. 61 // Original email (containing dots) is stored as "display email". 62 user_display_name = chromeos::UserManager::Get()-> 63 GetUserDisplayEmail(user_display_name); 64 } 65 #endif // defined(OS_CHROMEOS) 66 67 base::string16 user_name = base::UTF8ToUTF16(user_display_name); 68 69 if (!user_name.empty()) { 70 if (!service || service->IsManaged()) { 71 // User is signed in, but sync is disabled. 72 return l10n_util::GetStringFUTF16(IDS_SIGNED_IN_WITH_SYNC_DISABLED, 73 user_name); 74 } else if (service->IsStartSuppressed()) { 75 // User is signed in, but sync has been stopped. 76 return l10n_util::GetStringFUTF16(IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED, 77 user_name); 78 } 79 } 80 81 if (!service || !service->sync_initialized()) { 82 // User is not signed in, or sync is still initializing. 83 return base::string16(); 84 } 85 86 DCHECK(!user_name.empty()); 87 88 // Message may also carry additional advice with an HTML link, if acceptable. 89 switch (style) { 90 case PLAIN_TEXT: 91 return l10n_util::GetStringFUTF16( 92 IDS_SYNC_ACCOUNT_SYNCING_TO_USER, 93 user_name); 94 case WITH_HTML: 95 return l10n_util::GetStringFUTF16( 96 IDS_SYNC_ACCOUNT_SYNCING_TO_USER_WITH_MANAGE_LINK, 97 user_name, 98 base::ASCIIToUTF16(chrome::kSyncGoogleDashboardURL)); 99 default: 100 NOTREACHED(); 101 return NULL; 102 } 103 } 104 105 void GetStatusForActionableError( 106 const syncer::SyncProtocolError& error, 107 base::string16* status_label) { 108 DCHECK(status_label); 109 switch (error.action) { 110 case syncer::STOP_AND_RESTART_SYNC: 111 status_label->assign( 112 l10n_util::GetStringUTF16(IDS_SYNC_STOP_AND_RESTART_SYNC)); 113 break; 114 case syncer::UPGRADE_CLIENT: 115 status_label->assign( 116 l10n_util::GetStringFUTF16(IDS_SYNC_UPGRADE_CLIENT, 117 l10n_util::GetStringUTF16(IDS_PRODUCT_NAME))); 118 break; 119 case syncer::ENABLE_SYNC_ON_ACCOUNT: 120 status_label->assign( 121 l10n_util::GetStringUTF16(IDS_SYNC_ENABLE_SYNC_ON_ACCOUNT)); 122 break; 123 case syncer::CLEAR_USER_DATA_AND_RESYNC: 124 status_label->assign( 125 l10n_util::GetStringUTF16(IDS_SYNC_CLEAR_USER_DATA)); 126 break; 127 default: 128 NOTREACHED(); 129 } 130 } 131 132 // TODO(akalin): Write unit tests for these three functions below. 133 134 // status_label and link_label must either be both NULL or both non-NULL. 135 MessageType GetStatusInfo(ProfileSyncService* service, 136 const SigninManagerBase& signin, 137 StatusLabelStyle style, 138 base::string16* status_label, 139 base::string16* link_label) { 140 DCHECK_EQ(status_label == NULL, link_label == NULL); 141 142 MessageType result_type(SYNCED); 143 144 if (signin.GetAuthenticatedUsername().empty()) 145 return PRE_SYNCED; 146 147 if (!service || service->IsManaged() || service->HasSyncSetupCompleted() || 148 service->IsStartSuppressed()) { 149 // The order or priority is going to be: 1. Unrecoverable errors. 150 // 2. Auth errors. 3. Protocol errors. 4. Passphrase errors. 151 152 if (service && service->HasUnrecoverableError()) { 153 if (status_label) { 154 status_label->assign(l10n_util::GetStringFUTF16( 155 IDS_SYNC_STATUS_UNRECOVERABLE_ERROR, 156 l10n_util::GetStringUTF16(IDS_SYNC_UNRECOVERABLE_ERROR_HELP_URL))); 157 } 158 return SYNC_ERROR; 159 } 160 161 // For auth errors first check if an auth is in progress. 162 if (signin.AuthInProgress()) { 163 if (status_label) { 164 status_label->assign( 165 l10n_util::GetStringUTF16(IDS_SYNC_AUTHENTICATING_LABEL)); 166 } 167 return PRE_SYNCED; 168 } 169 170 // Check for sync errors if the sync service is enabled. 171 if (service) { 172 // Since there is no auth in progress, check for an auth error first. 173 AuthError auth_error = 174 ProfileOAuth2TokenServiceFactory::GetForProfile(service->profile())-> 175 signin_error_controller()->auth_error(); 176 if (auth_error.state() != AuthError::NONE) { 177 if (status_label && link_label) 178 signin_ui_util::GetStatusLabelsForAuthError( 179 service->profile(), signin, status_label, link_label); 180 return SYNC_ERROR; 181 } 182 183 // We don't have an auth error. Check for an actionable error. 184 ProfileSyncService::Status status; 185 service->QueryDetailedSyncStatus(&status); 186 if (ShouldShowActionOnUI(status.sync_protocol_error)) { 187 if (status_label) { 188 GetStatusForActionableError(status.sync_protocol_error, 189 status_label); 190 } 191 return SYNC_ERROR; 192 } 193 194 // Check for a passphrase error. 195 if (service->IsPassphraseRequired()) { 196 if (service->IsPassphraseRequiredForDecryption()) { 197 // TODO(lipalani) : Ask tim if this is still needed. 198 // NOT first machine. 199 // Show a link ("needs attention"), but still indicate the 200 // current synced status. Return SYNC_PROMO so that 201 // the configure link will still be shown. 202 if (status_label && link_label) { 203 status_label->assign(GetSyncedStateStatusLabel( 204 service, signin, style)); 205 link_label->assign( 206 l10n_util::GetStringUTF16(IDS_SYNC_PASSWORD_SYNC_ATTENTION)); 207 } 208 return SYNC_PROMO; 209 } 210 } 211 212 // Check to see if sync has been disabled via the dasboard and needs to be 213 // set up once again. 214 if (service->IsStartSuppressed() && 215 status.sync_protocol_error.error_type == syncer::NOT_MY_BIRTHDAY) { 216 if (status_label) { 217 status_label->assign(GetSyncedStateStatusLabel(service, 218 signin, 219 style)); 220 } 221 return PRE_SYNCED; 222 } 223 } 224 225 // There is no error. Display "Last synced..." message. 226 if (status_label) 227 status_label->assign(GetSyncedStateStatusLabel(service, signin, style)); 228 return SYNCED; 229 } else { 230 // Either show auth error information with a link to re-login, auth in prog, 231 // or provide a link to continue with setup. 232 if (service->FirstSetupInProgress()) { 233 result_type = PRE_SYNCED; 234 ProfileSyncService::Status status; 235 service->QueryDetailedSyncStatus(&status); 236 AuthError auth_error = 237 ProfileOAuth2TokenServiceFactory::GetForProfile(service->profile())-> 238 signin_error_controller()->auth_error(); 239 if (status_label) { 240 status_label->assign( 241 l10n_util::GetStringUTF16(IDS_SYNC_NTP_SETUP_IN_PROGRESS)); 242 } 243 if (signin.AuthInProgress()) { 244 if (status_label) { 245 status_label->assign( 246 l10n_util::GetStringUTF16(IDS_SYNC_AUTHENTICATING_LABEL)); 247 } 248 } else if (auth_error.state() != AuthError::NONE && 249 auth_error.state() != AuthError::TWO_FACTOR) { 250 if (status_label && link_label) { 251 status_label->clear(); 252 signin_ui_util::GetStatusLabelsForAuthError( 253 service->profile(), signin, status_label, link_label); 254 } 255 result_type = SYNC_ERROR; 256 } 257 } else if (service->HasUnrecoverableError()) { 258 result_type = SYNC_ERROR; 259 ProfileSyncService::Status status; 260 service->QueryDetailedSyncStatus(&status); 261 if (ShouldShowActionOnUI(status.sync_protocol_error)) { 262 if (status_label) { 263 GetStatusForActionableError(status.sync_protocol_error, 264 status_label); 265 } 266 } else if (status_label) { 267 status_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_SETUP_ERROR)); 268 } 269 } else if (!signin.GetAuthenticatedUsername().empty()) { 270 // The user is signed in, but sync has been stopped. 271 if (status_label) { 272 base::string16 label = l10n_util::GetStringFUTF16( 273 IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED, 274 base::UTF8ToUTF16(signin.GetAuthenticatedUsername())); 275 status_label->assign(label); 276 result_type = PRE_SYNCED; 277 } 278 } 279 } 280 return result_type; 281 } 282 283 // Returns the status info for use on the new tab page, where we want slightly 284 // different information than in the settings panel. 285 MessageType GetStatusInfoForNewTabPage(ProfileSyncService* service, 286 const SigninManagerBase& signin, 287 base::string16* status_label, 288 base::string16* link_label) { 289 DCHECK(status_label); 290 DCHECK(link_label); 291 292 if (service->HasSyncSetupCompleted() && 293 service->IsPassphraseRequired()) { 294 if (service->passphrase_required_reason() == syncer::REASON_ENCRYPTION) { 295 // First machine migrating to passwords. Show as a promotion. 296 if (status_label && link_label) { 297 status_label->assign( 298 l10n_util::GetStringFUTF16( 299 IDS_SYNC_NTP_PASSWORD_PROMO, 300 l10n_util::GetStringUTF16(IDS_PRODUCT_NAME))); 301 link_label->assign( 302 l10n_util::GetStringUTF16(IDS_SYNC_NTP_PASSWORD_ENABLE)); 303 } 304 return SYNC_PROMO; 305 } else { 306 // NOT first machine. 307 // Show a link and present as an error ("needs attention"). 308 if (status_label && link_label) { 309 status_label->assign(base::string16()); 310 link_label->assign( 311 l10n_util::GetStringUTF16(IDS_SYNC_CONFIGURE_ENCRYPTION)); 312 } 313 return SYNC_ERROR; 314 } 315 } 316 317 // Fallback to default. 318 return GetStatusInfo(service, signin, WITH_HTML, status_label, link_label); 319 } 320 321 } // namespace 322 323 MessageType GetStatusLabels(ProfileSyncService* service, 324 const SigninManagerBase& signin, 325 StatusLabelStyle style, 326 base::string16* status_label, 327 base::string16* link_label) { 328 DCHECK(status_label); 329 DCHECK(link_label); 330 return sync_ui_util::GetStatusInfo( 331 service, signin, style, status_label, link_label); 332 } 333 334 MessageType GetStatusLabelsForNewTabPage(ProfileSyncService* service, 335 const SigninManagerBase& signin, 336 base::string16* status_label, 337 base::string16* link_label) { 338 DCHECK(status_label); 339 DCHECK(link_label); 340 return sync_ui_util::GetStatusInfoForNewTabPage( 341 service, signin, status_label, link_label); 342 } 343 344 #if !defined(OS_CHROMEOS) 345 void GetStatusLabelsForSyncGlobalError(const ProfileSyncService* service, 346 base::string16* menu_label, 347 base::string16* bubble_message, 348 base::string16* bubble_accept_label) { 349 DCHECK(menu_label); 350 DCHECK(bubble_message); 351 DCHECK(bubble_accept_label); 352 *menu_label = base::string16(); 353 *bubble_message = base::string16(); 354 *bubble_accept_label = base::string16(); 355 356 // Only display an error if we've completed sync setup. 357 if (!service->HasSyncSetupCompleted()) 358 return; 359 360 // Display a passphrase error if we have one. 361 if (service->IsPassphraseRequired() && 362 service->IsPassphraseRequiredForDecryption()) { 363 // This is not the first machine so ask user to enter passphrase. 364 *menu_label = l10n_util::GetStringUTF16( 365 IDS_SYNC_PASSPHRASE_ERROR_WRENCH_MENU_ITEM); 366 *bubble_message = l10n_util::GetStringUTF16( 367 IDS_SYNC_PASSPHRASE_ERROR_BUBBLE_VIEW_MESSAGE); 368 *bubble_accept_label = l10n_util::GetStringUTF16( 369 IDS_SYNC_PASSPHRASE_ERROR_BUBBLE_VIEW_ACCEPT); 370 return; 371 } 372 } 373 #endif 374 375 MessageType GetStatus( 376 ProfileSyncService* service, const SigninManagerBase& signin) { 377 return sync_ui_util::GetStatusInfo(service, signin, WITH_HTML, NULL, NULL); 378 } 379 380 base::string16 ConstructTime(int64 time_in_int) { 381 base::Time time = base::Time::FromInternalValue(time_in_int); 382 383 // If time is null the format function returns a time in 1969. 384 if (time.is_null()) 385 return base::string16(); 386 return base::TimeFormatFriendlyDateAndTime(time); 387 } 388 389 } // namespace sync_ui_util 390
