Revert 177136 due to memory error on Mac ASAN

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 "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 26 matching lines @@
 
 namespace sync_ui_util {
 
 namespace {
 
 // Given an authentication state this helper function returns various labels
 // that can be used to display information about the state.
 void GetStatusLabelsForAuthError(const AuthError& auth_error,
                                  const ProfileSyncService& service,
                                  string16* status_label,
-                                 string16* link_label) {
+                                 string16* link_label,
+                                 string16* global_error_menu_label,
+                                 string16* global_error_bubble_message,
+                                 string16* global_error_bubble_accept_label) {
   string16 username = UTF8ToUTF16(service.profile()->GetPrefs()->GetString(
       prefs::kGoogleServicesUsername));
   string16 product_name = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
   if (link_label)
     link_label->assign(l10n_util::GetStringUTF16(IDS_SYNC_RELOGIN_LINK_LABEL));
 
   switch (auth_error.state()) {
     case AuthError::INVALID_GAIA_CREDENTIALS:
     case AuthError::ACCOUNT_DELETED:
     case AuthError::ACCOUNT_DISABLED:
       // If the user name is empty then the first login failed, otherwise the
       // credentials are out-of-date.
       if (username.empty()) {
         if (status_label) {
           status_label->assign(
               l10n_util::GetStringUTF16(IDS_SYNC_INVALID_USER_CREDENTIALS));
         }
       } else {
         if (status_label) {
           status_label->assign(
               l10n_util::GetStringUTF16(IDS_SYNC_LOGIN_INFO_OUT_OF_DATE));
         }
+        if (global_error_menu_label) {
+          global_error_menu_label->assign(l10n_util::GetStringUTF16(
+              IDS_SYNC_SIGN_IN_ERROR_WRENCH_MENU_ITEM));
+        }
+        if (global_error_bubble_message) {
+          global_error_bubble_message->assign(l10n_util::GetStringFUTF16(
+              IDS_SYNC_SIGN_IN_ERROR_BUBBLE_VIEW_MESSAGE, product_name));
+        }
+        if (global_error_bubble_accept_label) {
+          global_error_bubble_accept_label->assign(l10n_util::GetStringUTF16(
+              IDS_SYNC_SIGN_IN_ERROR_BUBBLE_VIEW_ACCEPT));
+        }
       }
       break;
     case AuthError::SERVICE_UNAVAILABLE:
       if (status_label) {
         status_label->assign(
             l10n_util::GetStringUTF16(IDS_SYNC_SERVICE_UNAVAILABLE));
       }
       if (link_label)
         link_label->clear();
+      if (global_error_menu_label) {
+        global_error_menu_label->assign(l10n_util::GetStringUTF16(
+            IDS_SYNC_SIGN_IN_ERROR_WRENCH_MENU_ITEM));
+      }
+      if (global_error_bubble_message) {
+        global_error_bubble_message->assign(l10n_util::GetStringFUTF16(
+            IDS_SYNC_UNAVAILABLE_ERROR_BUBBLE_VIEW_MESSAGE, product_name));
+      }
+      if (global_error_bubble_accept_label) {
+        global_error_bubble_accept_label->assign(l10n_util::GetStringUTF16(
+            IDS_SYNC_UNAVAILABLE_ERROR_BUBBLE_VIEW_ACCEPT));
+      }
       break;
     case AuthError::CONNECTION_FAILED:
       // 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.
       if (status_label) {
         status_label->assign(
             l10n_util::GetStringFUTF16(IDS_SYNC_SERVER_IS_UNREACHABLE,
                                        product_name));
       }
       break;
     default:
       if (status_label) {
         status_label->assign(l10n_util::GetStringUTF16(
             IDS_SYNC_ERROR_SIGNING_IN));
       }
+      if (global_error_menu_label) {
+        global_error_menu_label->assign(l10n_util::GetStringUTF16(
+            IDS_SYNC_SIGN_IN_ERROR_WRENCH_MENU_ITEM));
+      }
+      if (global_error_bubble_message) {
+        global_error_bubble_message->assign(l10n_util::GetStringFUTF16(
+            IDS_SYNC_OTHER_SIGN_IN_ERROR_BUBBLE_VIEW_MESSAGE, product_name));
+      }
+      if (global_error_bubble_accept_label) {
+        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,
                                    StatusLabelStyle style) {
   if (!service->sync_initialized())
@@ skipping 85 matching lines @@
       if (status_label) {
         status_label->assign(
           l10n_util::GetStringUTF16(IDS_SYNC_AUTHENTICATING_LABEL));
       }
       return PRE_SYNCED;
     }
 
     // No auth in progress check for an auth error.
     if (auth_error.state() != AuthError::NONE) {
       if (status_label && link_label) {
-        GetStatusLabelsForAuthError(
-            auth_error, *service, status_label, link_label);
+        GetStatusLabelsForAuthError(auth_error, *service,
+                                    status_label, link_label, NULL, NULL, NULL);
       }
       return SYNC_ERROR;
     }
 
     // We dont have an auth error. Check for protocol error.
     if (ShouldShowActionOnUI(status.sync_protocol_error)) {
       if (status_label) {
         GetStatusForActionableError(status.sync_protocol_error,
             status_label);
       }
@@ skipping 35 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) {
           status_label->clear();
-          GetStatusLabelsForAuthError(auth_error, *service, status_label, NULL);
+          GetStatusLabelsForAuthError(auth_error, *service, status_label, NULL,
+                                      NULL, NULL, NULL);
         }
         result_type = SYNC_ERROR;
       }
     } else if (service->HasUnrecoverableError()) {
       result_type = SYNC_ERROR;
       ProfileSyncService::Status status;
       service->QueryDetailedSyncStatus(&status);
       if (ShouldShowActionOnUI(status.sync_protocol_error)) {
         if (status_label) {
           GetStatusForActionableError(status.sync_protocol_error,
@@ skipping 73 matching lines @@
                                        string16* menu_label,
                                        string16* bubble_message,
                                        string16* bubble_accept_label) {
   DCHECK(menu_label);
   DCHECK(bubble_message);
   DCHECK(bubble_accept_label);
   *menu_label = string16();
   *bubble_message = string16();
   *bubble_accept_label = string16();
 
-  // Only display an error if we've completed sync setup.
   if (!service->HasSyncSetupCompleted())
     return;
 
-  // Display a passphrase error if we have one.
+  MessageType status = GetStatus(service, signin);
+  if (status == SYNC_ERROR) {
+    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);
+      // If we have an actionable auth error, display it.
+      if (!menu_label->empty())
+        return;
+    }
+  }
+
+  // No actionable auth error - display the passphrase error.
   if (service->IsPassphraseRequired() &&
       service->IsPassphraseRequiredForDecryption()) {
     // This is not the first machine so ask user to enter passphrase.
     *menu_label = l10n_util::GetStringUTF16(
         IDS_SYNC_PASSPHRASE_ERROR_WRENCH_MENU_ITEM);
     string16 product_name = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
     *bubble_message = l10n_util::GetStringFUTF16(
         IDS_SYNC_PASSPHRASE_ERROR_BUBBLE_VIEW_MESSAGE, product_name);
     *bubble_accept_label = l10n_util::GetStringUTF16(
         IDS_SYNC_PASSPHRASE_ERROR_BUBBLE_VIEW_ACCEPT);
     return;
   }
 }
 
 MessageType GetStatus(
     ProfileSyncService* service, const SigninManager& signin) {
   return sync_ui_util::GetStatusInfo(service, signin, WITH_HTML, NULL, NULL);
 }
 
+string16 GetSyncMenuLabel(
+    ProfileSyncService* service, const SigninManager& signin) {
+  MessageType type = GetStatus(service, signin);
+
+  if (type == sync_ui_util::SYNCED)
+    return l10n_util::GetStringUTF16(IDS_SYNC_MENU_SYNCED_LABEL);
+  else if (type == sync_ui_util::SYNC_ERROR)
+    return l10n_util::GetStringUTF16(IDS_SYNC_MENU_SYNC_ERROR_LABEL);
+  else
+    return l10n_util::GetStringUTF16(IDS_SYNC_START_SYNC_BUTTON_LABEL);
+}
+
 string16 ConstructTime(int64 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 string16();
   return base::TimeFormatFriendlyDateAndTime(time);
 }
 
+std::string MakeSyncAuthErrorText(
+    const GoogleServiceAuthError::State& state) {
+  switch (state) {
+    case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS:
+    case GoogleServiceAuthError::ACCOUNT_DELETED:
+    case GoogleServiceAuthError::ACCOUNT_DISABLED:
+    case GoogleServiceAuthError::SERVICE_UNAVAILABLE:
+      return "INVALID_GAIA_CREDENTIALS";
+    case GoogleServiceAuthError::USER_NOT_SIGNED_UP:
+      return "USER_NOT_SIGNED_UP";
+    case GoogleServiceAuthError::CONNECTION_FAILED:
+      return "CONNECTION_FAILED";
+    default:
+      return std::string();
+  }
+}
+
 }  // namespace sync_ui_util