Adding parameter to GetStatusLabels to indicate if links are acceptable.

chrome/browser/sync/sync_ui_util.cc

 // Copyright (c) 2011 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 "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 113 matching lines @@
         global_error_bubble_accept_label->assign(l10n_util::GetStringUTF16(
             IDS_SYNC_SIGN_IN_ERROR_BUBBLE_VIEW_ACCEPT));
       }
       break;
   }
 }
 
 // Returns the message that should be displayed when the user is authenticated
 // and can connect to the sync server. If the user hasn't yet authenticated, an
 // empty string is returned.
-string16 GetSyncedStateStatusLabel(ProfileSyncService* service) {
+string16 GetSyncedStateStatusLabel(ProfileSyncService* service,
+    bool html_links) {
   string16 label;
   string16 user_name(service->GetAuthenticatedUsername());
   if (user_name.empty())
     return label;
 
-  return l10n_util::GetStringFUTF16(
-      IDS_SYNC_ACCOUNT_SYNCING_TO_USER,
-      user_name,
-      ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
+  // Message may also carry additional advice with an HTML link, if acceptable.
+  if (html_links)

[stuartmorgan, 2011/10/27 11:51:20]

These are multi-line, so need to have braces.

[jimblackler, 2011/10/27 14:53:52]

Done.

+    return l10n_util::GetStringFUTF16(
+        IDS_SYNC_ACCOUNT_SYNCING_TO_USER_WITH_MANAGE_LINK,
+        user_name,
+        ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
+  else
+    return l10n_util::GetStringFUTF16(
+        IDS_SYNC_ACCOUNT_SYNCING_TO_USER,
+        user_name);
 }
 
 void GetStatusForActionableError(
     const browser_sync::SyncProtocolError& error,
     string16* status_label) {
   DCHECK(status_label);
   switch (error.action) {
     case browser_sync::STOP_AND_RESTART_SYNC:
        status_label->assign(
            l10n_util::GetStringUTF16(IDS_SYNC_STOP_AND_RESTART_SYNC));
@@ skipping 14 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 // 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(ProfileSyncService* service,
                           string16* status_label,
-                          string16* link_label) {
+                          string16* link_label,
+                          bool html_links) {
   DCHECK_EQ(status_label == NULL, link_label == NULL);
 
   MessageType result_type(SYNCED);
 
   if (!service) {
     return PRE_SYNCED;
   }
 
   if (service->HasSyncSetupCompleted()) {
     ProfileSyncService::Status status(service->QueryDetailedSyncStatus());
@@ skipping 40 matching lines @@
 
     // Now finally 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));
+          status_label->assign(GetSyncedStateStatusLabel(service, html_links));
           link_label->assign(
               l10n_util::GetStringUTF16(IDS_SYNC_PASSWORD_SYNC_ATTENTION));
         }
         return SYNC_PROMO;
       }
     }
 
     // There is no error. Display "Last synced..." message.
     if (status_label)
-      status_label->assign(GetSyncedStateStatusLabel(service));
+      status_label->assign(GetSyncedStateStatusLabel(service, html_links));
     return SYNCED;
   } else {
     // Either show auth error information with a link to re-login, auth in prog,
     // or provide a link to continue with setup.
     result_type = PRE_SYNCED;
     if (service->SetupInProgress()) {
       ProfileSyncService::Status status(service->QueryDetailedSyncStatus());
       const AuthError& auth_error = service->GetAuthError();
       if (status_label) {
         status_label->assign(
@@ skipping 61 matching lines @@
       if (status_label && link_label) {
         status_label->assign(string16());
         link_label->assign(
             l10n_util::GetStringUTF16(IDS_SYNC_CONFIGURE_ENCRYPTION));
       }
       return SYNC_ERROR;
     }
   }
 
   // Fallback to default.
-  return GetStatusInfo(service, status_label, link_label);
+  return GetStatusInfo(service, status_label, link_label, true);
 }
 
 }  // namespace
 
 MessageType GetStatusLabels(ProfileSyncService* service,
                             string16* status_label,
-                            string16* link_label) {
+                            string16* link_label,
+                            bool html_links) {
   DCHECK(status_label);
   DCHECK(link_label);
-  return sync_ui_util::GetStatusInfo(service, status_label, link_label);
+  return sync_ui_util::GetStatusInfo(service, status_label, link_label,
+      html_links);
 }
 
 MessageType GetStatusLabelsForNewTabPage(ProfileSyncService* service,
                                          string16* status_label,
                                          string16* link_label) {
   DCHECK(status_label);
   DCHECK(link_label);
   return sync_ui_util::GetStatusInfoForNewTabPage(
       service, status_label, link_label);
 }
@@ skipping 30 matching lines @@
     return;
 
   const AuthError& auth_error = service->GetAuthError();
   if (auth_error.state() != AuthError::NONE) {
     GetStatusLabelsForAuthError(auth_error, *service, NULL, NULL,
         menu_label, bubble_message, bubble_accept_label);
   }
 }
 
 MessageType GetStatus(ProfileSyncService* service) {
-  return sync_ui_util::GetStatusInfo(service, NULL, NULL);
+  return sync_ui_util::GetStatusInfo(service, NULL, NULL, true);
 }
 
 bool ShouldShowSyncErrorButton(ProfileSyncService* service) {
   if (!service)
     return false;
 
   if (service->IsManaged() || !service->HasSyncSetupCompleted())
     return false;
 
   // Don't display error button for unrecoverable errors; they are not
@@ skipping 270 matching lines @@
         DictionaryValue* val = new DictionaryValue;
         val->SetString("model_type", ModelTypeToString(it->first));
         val->SetString("group", ModelSafeGroupToString(it->second));
         routing_info->Append(val);
       }
     }
   }
 }
 
 }  // namespace sync_ui_util