[MD Settings][Options] Fixes bugs with the sync status messages/actions

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 81 matching lines @@
           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,
+                                 base::string16* link_label,
                                  ActionType* action_type) {
   DCHECK(status_label);
+  DCHECK(link_label);
   switch (error.action) {
     case syncer::UPGRADE_CLIENT:
       status_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_UPGRADE_CLIENT));
+      link_label->assign(
+          l10n_util::GetStringUTF16(IDS_SYNC_UPGRADE_CLIENT_LINK_LABEL));
       *action_type = UPGRADE_CLIENT;
       break;
     case syncer::ENABLE_SYNC_ON_ACCOUNT:
       status_label->assign(
           l10n_util::GetStringUTF16(IDS_SYNC_STATUS_ENABLE_SYNC_ON_ACCOUNT));
       break;
     default:
       status_label->clear();
       break;
   }
 }
 
 void GetStatusForUnrecoverableError(Profile* profile,
                                     ProfileSyncService* service,
                                     base::string16* status_label,
+                                    base::string16* link_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);
+                              link_label, action_type);
   if (status_label->empty()) {
     *action_type = REAUTHENTICATE;
+    link_label->assign(
+        l10n_util::GetStringUTF16(IDS_SYNC_RELOGIN_LINK_LABEL));
 
 #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
@@ skipping 56 matching lines @@
 
   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) {
+      if (status_label && link_label) {
         GetStatusForUnrecoverableError(profile, service, status_label,
-                                       action_type);
+                                       link_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) {
           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 (status_label) {
+      if (status_label && link_label) {
         GetStatusForActionableError(status.sync_protocol_error, status_label,
-                                    action_type);
+                                    link_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));
@@ skipping 43 matching lines @@
       } else if (auth_error.state() != AuthError::NONE &&
                  auth_error.state() != AuthError::TWO_FACTOR) {
         if (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;
-      if (status_label) {
+      if (status_label && link_label) {
         GetStatusForUnrecoverableError(profile, service, status_label,
-                                       action_type);
+                                       link_label, action_type);
       }
     } else if (signin.IsAuthenticated()) {
       // The user is signed in, but sync has been stopped.
       result_type = PRE_SYNCED;
       if (status_label) {
         status_label->assign(
             l10n_util::GetStringUTF16(IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED));
       }
     }
   }
@@ skipping 182 matching lines @@
 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