[MD Settings][Sync Settings] Updates sync status messages

chrome/browser/sync/sync_ui_util.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/sync/sync_ui_util.h"
 
 #include <stdint.h>
 
 #include <string>
 
@@ skipping 79 matching lines @@
       }
       return l10n_util::GetStringFUTF16(
           IDS_SYNC_ACCOUNT_SYNCING_WITH_MANAGE_LINK,
           base::ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
-void GetStatusForActionableError(
-    const syncer::SyncProtocolError& error,
-    base::string16* status_label) {
+void GetStatusForActionableError(const syncer::SyncProtocolError& error,
+                                 base::string16* status_label,
+                                 ActionType* action_type) {
   DCHECK(status_label);
   switch (error.action) {
-    case syncer::STOP_AND_RESTART_SYNC:
-       status_label->assign(
-           l10n_util::GetStringUTF16(IDS_SYNC_STOP_AND_RESTART_SYNC));
-      break;
     case syncer::UPGRADE_CLIENT:
-       status_label->assign(
-           l10n_util::GetStringFUTF16(IDS_SYNC_UPGRADE_CLIENT,
-               l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
+      status_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_UPGRADE_CLIENT));
+      *action_type = UPGRADE_CLIENT;
       break;
     case syncer::ENABLE_SYNC_ON_ACCOUNT:
-       status_label->assign(
-           l10n_util::GetStringUTF16(IDS_SYNC_ENABLE_SYNC_ON_ACCOUNT));
-    break;
-    case syncer::CLEAR_USER_DATA_AND_RESYNC:
-       status_label->assign(
-           l10n_util::GetStringUTF16(IDS_SYNC_CLEAR_USER_DATA));
+      status_label->assign(
+          l10n_util::GetStringUTF16(IDS_SYNC_STATUS_ENABLE_SYNC_ON_ACCOUNT));
       break;
     default:
-      NOTREACHED();
+      break;

[Roger Tawa OOO till Jul 10th, 2016/11/02 17:33:41]

Wouldn't it be better to keep the NOTREACHED() or maybe set the output args to
some default values?

[Moe, 2016/11/02 18:46:32]

after removing browser_sync::ShouldShowActionOnUI() the default case is
reachable. But I agree with you. It's best to clear() the status_label in the
default case b/c we expect the output arg to be an empty string.

   }
 }
 
+void GetStatusForUnrecoverableError(Profile* profile,
+                                    ProfileSyncService* service,
+                                    base::string16* status_label,
+                                    ActionType* action_type) {
+  // Unrecoverable error is sometimes accompanied by actionable error.
+  // If status message is set display that message, otherwise show generic
+  // unrecoverable error message.
+  ProfileSyncService::Status status;
+  service->QueryDetailedSyncStatus(&status);
+  GetStatusForActionableError(status.sync_protocol_error, status_label,
+                              action_type);
+  if (status_label->empty()) {
+    *action_type = REAUTHENTICATE;
+
+#if !defined(OS_CHROMEOS)
+    status_label->assign(l10n_util::GetStringUTF16(
+        IDS_SYNC_STATUS_UNRECOVERABLE_ERROR));
+    // The message for managed accounts is the same as that of the cros.
+    if (SigninManagerFactory::GetForProfile(profile)->IsSignoutProhibited()) {
+      status_label->assign(l10n_util::GetStringUTF16(
+          IDS_SYNC_STATUS_UNRECOVERABLE_ERROR_NEEDS_SIGNOUT));
+    }
+#else
+    status_label->assign(l10n_util::GetStringUTF16(
+        IDS_SYNC_STATUS_UNRECOVERABLE_ERROR_NEEDS_SIGNOUT));
+#endif
+  }
+}
+
+// Depending on the authentication state, returns labels to be used to display
+// information about the sync status.
+void GetStatusForAuthError(Profile* profile,
+                           const SigninManagerBase& signin_manager,
+                           base::string16* status_label,
+                           base::string16* link_label,
+                           ActionType* action_type) {
+  DCHECK(status_label);
+  DCHECK(link_label);
+  const GoogleServiceAuthError::State state =
+      SigninErrorControllerFactory::GetForProfile(profile)->
+          auth_error().state();
+  switch (state) {
+    case GoogleServiceAuthError::SERVICE_UNAVAILABLE:
+      status_label->assign(
+          l10n_util::GetStringUTF16(IDS_SYNC_SERVICE_UNAVAILABLE));
+      break;
+    case GoogleServiceAuthError::CONNECTION_FAILED:
+      status_label->assign(
+          l10n_util::GetStringUTF16(IDS_SYNC_SERVER_IS_UNREACHABLE));
+      // Note that there is little the user can do if the server is not
+      // reachable. Since attempting to re-connect is done automatically by
+      // the Syncer, we do not show the (re)login link.
+      break;
+    case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS:
+    case GoogleServiceAuthError::SERVICE_ERROR:
+    case GoogleServiceAuthError::ACCOUNT_DELETED:
+    case GoogleServiceAuthError::ACCOUNT_DISABLED:
+    default:
+      status_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_RELOGIN_ERROR));
+      link_label->assign(
+          l10n_util::GetStringUTF16(IDS_SYNC_RELOGIN_LINK_LABEL));
+      *action_type = REAUTHENTICATE;
+      break;
+  }
+}
+
 // TODO(akalin): Write unit tests for these three functions below.
 
 // status_label and link_label must either be both null or both non-null.
 MessageType GetStatusInfo(Profile* profile,
                           ProfileSyncService* service,
                           const SigninManagerBase& signin,
                           StatusLabelStyle style,
                           base::string16* status_label,
-                          base::string16* link_label) {
+                          base::string16* link_label,
+                          ActionType* action_type) {
   DCHECK_EQ(status_label == nullptr, link_label == nullptr);
 
   MessageType result_type(SYNCED);
 
   if (!signin.IsAuthenticated())
     return PRE_SYNCED;
 
   if (!service || service->IsManaged() || service->IsFirstSetupComplete() ||
       !service->IsSyncRequested()) {
     // The order or priority is going to be: 1. Unrecoverable errors.
     // 2. Auth errors. 3. Protocol errors. 4. Passphrase errors.
 
     if (service && service->HasUnrecoverableError()) {
       if (status_label) {
-        // Unrecoverable error is sometimes accompanied by actionable error.
-        // If actionable error is set then display corresponding message,
-        // otherwise show generic unrecoverable error message.
-        ProfileSyncService::Status status;
-        service->QueryDetailedSyncStatus(&status);
-        if (browser_sync::ShouldShowActionOnUI(status.sync_protocol_error)) {
-          GetStatusForActionableError(status.sync_protocol_error, status_label);
-        } else {
-          status_label->assign(l10n_util::GetStringFUTF16(
-              IDS_SYNC_STATUS_UNRECOVERABLE_ERROR,
-              l10n_util::GetStringUTF16(
-                  IDS_SYNC_UNRECOVERABLE_ERROR_HELP_URL)));
-        }
+        GetStatusForUnrecoverableError(profile, service, status_label,
+                                       action_type);
       }
       return SYNC_ERROR;
     }
 
     // For auth errors first check if an auth is in progress.
     if (signin.AuthInProgress()) {
       if (status_label) {
         status_label->assign(
           l10n_util::GetStringUTF16(IDS_SYNC_AUTHENTICATING_LABEL));
       }
       return PRE_SYNCED;
     }
 
     // Check for sync errors if the sync service is enabled.
     if (service) {
       // Since there is no auth in progress, check for an auth error first.
       AuthError auth_error =
           SigninErrorControllerFactory::GetForProfile(profile)->auth_error();
       if (auth_error.state() != AuthError::NONE) {
-        if (status_label && link_label)
-          signin_ui_util::GetStatusLabelsForAuthError(profile, signin,
-                                                      status_label, link_label);
+        if (status_label && link_label) {
+          GetStatusForAuthError(profile, signin, status_label, link_label,
+                                action_type);
+        }
         return SYNC_ERROR;
       }
 
       // We don't have an auth error. Check for an actionable error.
       ProfileSyncService::Status status;
       service->QueryDetailedSyncStatus(&status);
-      if (browser_sync::ShouldShowActionOnUI(status.sync_protocol_error)) {
-        if (status_label) {
-          GetStatusForActionableError(status.sync_protocol_error,
-                                      status_label);
+      if (status_label) {
+        GetStatusForActionableError(status.sync_protocol_error, status_label,
+                                    action_type);
+        if (!status_label->empty())
+          return SYNC_ERROR;
+      }
+
+      // Check for a passphrase error.
+      if (service->IsPassphraseRequired() &&
+          service->IsPassphraseRequiredForDecryption()) {
+        if (status_label && link_label) {
+          status_label->assign(
+              l10n_util::GetStringUTF16(IDS_SYNC_STATUS_NEEDS_PASSWORD));
+          link_label->assign(
+              l10n_util::GetStringUTF16(
+                  IDS_SYNC_STATUS_NEEDS_PASSWORD_LINK_LABEL));
+          *action_type = ENTER_PASSPHRASE;
         }
         return SYNC_ERROR;
       }
 
-      // Check for a passphrase error.
-      if (service->IsPassphraseRequired()) {
-        if (service->IsPassphraseRequiredForDecryption()) {
-          // TODO(lipalani) : Ask tim if this is still needed.
-          // NOT first machine.
-          // Show a link ("needs attention"), but still indicate the
-          // current synced status.  Return SYNC_PROMO so that
-          // the configure link will still be shown.
-          if (status_label && link_label) {
-            status_label->assign(GetSyncedStateStatusLabel(
-                service, signin, style));
-            link_label->assign(
-                l10n_util::GetStringUTF16(IDS_SYNC_PASSWORD_SYNC_ATTENTION));
-          }
-          return SYNC_PROMO;
-        }
-      }
-
       // Check to see if sync has been disabled via the dasboard and needs to be
       // set up once again.
       if (!service->IsSyncRequested() &&
           status.sync_protocol_error.error_type == syncer::NOT_MY_BIRTHDAY) {
         if (status_label) {
           status_label->assign(GetSyncedStateStatusLabel(service,
                                                          signin,
                                                          style));
         }
         return PRE_SYNCED;
@@ skipping 19 matching lines @@
       }
       if (signin.AuthInProgress()) {
         if (status_label) {
           status_label->assign(
               l10n_util::GetStringUTF16(IDS_SYNC_AUTHENTICATING_LABEL));
         }
       } else if (auth_error.state() != AuthError::NONE &&
                  auth_error.state() != AuthError::TWO_FACTOR) {
         if (status_label && link_label) {
           status_label->clear();
-          signin_ui_util::GetStatusLabelsForAuthError(profile, signin,
-                                                      status_label, link_label);
+          GetStatusForAuthError(profile, signin, status_label, link_label,
+                                action_type);
         }
         result_type = SYNC_ERROR;
       }
     } else if (service->HasUnrecoverableError()) {
       result_type = SYNC_ERROR;
-      ProfileSyncService::Status status;
-      service->QueryDetailedSyncStatus(&status);
-      if (browser_sync::ShouldShowActionOnUI(status.sync_protocol_error)) {
-        if (status_label) {
-          GetStatusForActionableError(status.sync_protocol_error,
-              status_label);
-        }
-      } else if (status_label) {
-        status_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_SETUP_ERROR));
+      if (status_label) {
+        GetStatusForUnrecoverableError(profile, service, status_label,
+                                       action_type);
       }
     } else if (signin.IsAuthenticated()) {
       // The user is signed in, but sync has been stopped.
+      result_type = PRE_SYNCED;
       if (status_label) {
-        base::string16 label = l10n_util::GetStringUTF16(
-            IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED);
-        status_label->assign(label);
-        result_type = PRE_SYNCED;
+        status_label->assign(
+            l10n_util::GetStringUTF16(IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED));
       }
     }
   }
   return result_type;
 }
 
 // Returns the status info for use on the new tab page, where we want slightly
 // different information than in the settings panel.
 MessageType GetStatusInfoForNewTabPage(Profile* profile,
                                        ProfileSyncService* service,
@@ skipping 21 matching lines @@
       if (status_label && link_label) {
         status_label->assign(base::string16());
         link_label->assign(
             l10n_util::GetStringUTF16(IDS_SYNC_CONFIGURE_ENCRYPTION));
       }
       return SYNC_ERROR;
     }
   }
 
   // Fallback to default.
+  ActionType actionType(sync_ui_util::NO_ACTION);
   return GetStatusInfo(profile, service, signin, WITH_HTML, status_label,
-                       link_label);
+                       link_label, &actionType);
 }
 
 }  // namespace
 
 MessageType GetStatusLabels(Profile* profile,
                             ProfileSyncService* service,
                             const SigninManagerBase& signin,
                             StatusLabelStyle style,
                             base::string16* status_label,
-                            base::string16* link_label) {
+                            base::string16* link_label,
+                            ActionType* action_type) {
   DCHECK(status_label);
   DCHECK(link_label);
   return sync_ui_util::GetStatusInfo(profile, service, signin, style,
-                                     status_label, link_label);
+                                     status_label, link_label, action_type);
 }
 
 MessageType GetStatusLabelsForNewTabPage(Profile* profile,
                                          ProfileSyncService* service,
                                          const SigninManagerBase& signin,
                                          base::string16* status_label,
                                          base::string16* link_label) {
   DCHECK(status_label);
   DCHECK(link_label);
   return sync_ui_util::GetStatusInfoForNewTabPage(profile, service, signin,
@@ skipping 101 matching lines @@
   }
 
   // There is no error.
   return NO_SYNC_ERROR;
 }
 #endif
 
 MessageType GetStatus(Profile* profile,
                       ProfileSyncService* service,
                       const SigninManagerBase& signin) {
+  ActionType actionType(sync_ui_util::NO_ACTION);
   return sync_ui_util::GetStatusInfo(profile, service, signin, WITH_HTML,
-                                     nullptr, nullptr);
+                                     nullptr, nullptr, &actionType);
 }
 
 base::string16 ConstructTime(int64_t time_in_int) {
   base::Time time = base::Time::FromInternalValue(time_in_int);
 
   // If time is null the format function returns a time in 1969.
   if (time.is_null())
     return base::string16();
   return base::TimeFormatFriendlyDateAndTime(time);
 }
 
 }  // namespace sync_ui_util