chrome/browser/sync/sync_ui_util.cc

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