Allow signin to continue even if sync is disabled by policy.

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"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/signin/signin_global_error.h"
 #include "chrome/browser/signin/signin_manager.h"
+#include "chrome/browser/signin/signin_ui_util.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/protocol/proto_enum_conversions.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 typedef GoogleServiceAuthError AuthError;
 
 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 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));
-        }
-      }
-      break;
-    case AuthError::SERVICE_UNAVAILABLE:
-      if (status_label) {
-        status_label->assign(
-            l10n_util::GetStringUTF16(IDS_SYNC_SERVICE_UNAVAILABLE));
-      }
-      if (link_label)
-        link_label->clear();
-      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));
-      }
-      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,
+                                   const SigninManager& signin,
                                    StatusLabelStyle style) {
-  if (!service->sync_initialized())
+  string16 user_name = UTF8ToUTF16(signin.GetAuthenticatedUsername());
+
+  if (!user_name.empty() &&
+      (!service || service->IsManaged())) {
+    // User is signed in, but sync is disabled.
+    return l10n_util::GetStringFUTF16(IDS_SIGNED_IN_WITH_SYNC_DISABLED,
+                                      user_name);
+  }
+
+  if (!service || !service->sync_initialized()) {
+    // User is not signed in, or sync is still initializing.
     return string16();
+  }
 
-  string16 user_name = UTF8ToUTF16(service->profile()->GetPrefs()->GetString(
-      prefs::kGoogleServicesUsername));
   DCHECK(!user_name.empty());
 
   // Message may also carry additional advice with an HTML link, if acceptable.
   switch (style) {
     case PLAIN_TEXT:
       return l10n_util::GetStringFUTF16(
           IDS_SYNC_ACCOUNT_SYNCING_TO_USER,
           user_name);
     case WITH_HTML:
       return l10n_util::GetStringFUTF16(
@@ skipping 38 matching lines @@
 // status_label and link_label must either be both NULL or both non-NULL.
 MessageType GetStatusInfo(ProfileSyncService* service,
                           const SigninManager& signin,
                           StatusLabelStyle style,
                           string16* status_label,
                           string16* link_label) {
   DCHECK_EQ(status_label == NULL, link_label == NULL);
 
   MessageType result_type(SYNCED);
 
-  if (!service) {
+  if (signin.GetAuthenticatedUsername().empty())
     return PRE_SYNCED;
-  }
 
-  if (service->HasSyncSetupCompleted()) {
-    ProfileSyncService::Status status;
-    service->QueryDetailedSyncStatus(&status);
-    const AuthError& auth_error = service->GetAuthError();
-
+  if (!service || service->IsManaged() || service->HasSyncSetupCompleted()) {
     // The order or priority is going to be: 1. Unrecoverable errors.
     // 2. Auth errors. 3. Protocol errors. 4. Passphrase errors.
 
-    if (service->HasUnrecoverableError()) {
+    if (service && service->HasUnrecoverableError()) {
       if (status_label) {
         status_label->assign(l10n_util::GetStringFUTF16(
             IDS_SYNC_STATUS_UNRECOVERABLE_ERROR,
             l10n_util::GetStringUTF16(IDS_SYNC_UNRECOVERABLE_ERROR_HELP_URL)));
       }
       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;
     }
 
     // No auth in progress check for an auth error.
+    AuthError auth_error = signin.signin_global_error()->GetLastAuthError();
     if (auth_error.state() != AuthError::NONE) {
-      if (status_label && link_label) {
-        GetStatusLabelsForAuthError(
-            auth_error, *service, status_label, link_label);
-      }
+      if (status_label && link_label)
+        signin_ui_util::GetStatusLabelsForAuthError(
+            signin, status_label, link_label);
       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);
+    // We dont have an auth error. Check for sync errors if the sync service
+    // is enabled.
+    if (service) {
+      ProfileSyncService::Status status;
+      service->QueryDetailedSyncStatus(&status);
+
+      if (ShouldShowActionOnUI(status.sync_protocol_error)) {
+        if (status_label) {
+          GetStatusForActionableError(status.sync_protocol_error,
+                                      status_label);
+        }
+        return SYNC_ERROR;
       }
-      return SYNC_ERROR;
-    }
 
-    // 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, style));
-          link_label->assign(
-              l10n_util::GetStringUTF16(IDS_SYNC_PASSWORD_SYNC_ATTENTION));
+      // 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, signin, style));
+            link_label->assign(
+                l10n_util::GetStringUTF16(IDS_SYNC_PASSWORD_SYNC_ATTENTION));
+          }
+          return SYNC_PROMO;
         }
-        return SYNC_PROMO;
       }
     }
 
     // There is no error. Display "Last synced..." message.
     if (status_label)
-      status_label->assign(GetSyncedStateStatusLabel(service, style));
+      status_label->assign(GetSyncedStateStatusLabel(service, signin, style));
     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->FirstSetupInProgress()) {
+      result_type = PRE_SYNCED;
       ProfileSyncService::Status status;
       service->QueryDetailedSyncStatus(&status);
-      const AuthError& auth_error = service->GetAuthError();
+      AuthError auth_error = signin.signin_global_error()->GetLastAuthError();
       if (status_label) {
         status_label->assign(
             l10n_util::GetStringUTF16(IDS_SYNC_NTP_SETUP_IN_PROGRESS));
       }
       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);
+          signin_ui_util::GetStatusLabelsForAuthError(
+              signin, status_label, 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 107 matching lines @@
 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);
 }
 
 }  // namespace sync_ui_util