MD Settings People: Display "On - custom settings" for custom data types

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 15 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/signin_error_controller.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/sync/base/model_type.h"
+#include "components/sync/base/sync_prefs.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/sync/protocol/sync_protocol_error.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_manager.h"
 #else
@@ skipping 13 matching lines @@
   const std::string group_name =
       base::FieldTrialList::FindFullName("ChromeDashboard");
   return group_name == "Enabled";
 }
 
 // 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.
 base::string16 GetSyncedStateStatusLabel(ProfileSyncService* service,
                                          const SigninManagerBase& signin,
-                                         StatusLabelStyle style) {
+                                         StatusLabelStyle style,
+                                         bool all_data_types_synced) {

[Nicolas Zea, 2017/01/18 01:15:45]

nit: for consistency sake, maybe rename to sync_everything (here and elsewhere)?

[tommycli, 2017/01/18 16:36:09]

Done.

   if (!service || service->IsManaged()) {
     // User is signed in, but sync is disabled.
     return l10n_util::GetStringUTF16(IDS_SIGNED_IN_WITH_SYNC_DISABLED);
   } else if (!service->IsSyncRequested()) {
     // User is signed in, but sync has been stopped.
     return l10n_util::GetStringUTF16(IDS_SIGNED_IN_WITH_SYNC_SUPPRESSED);
   } else if (!service->IsSyncActive()) {
     // User is not signed in, or sync is still initializing.
     return base::string16();
   }
 
   // Message may also carry additional advice with an HTML link, if acceptable.
   switch (style) {
     case PLAIN_TEXT:
-      return l10n_util::GetStringUTF16(IDS_SYNC_ACCOUNT_SYNCING);
+      return l10n_util::GetStringUTF16(
+          all_data_types_synced ? IDS_SYNC_ACCOUNT_SYNCING
+                                : IDS_SYNC_ACCOUNT_SYNCING_CUSTOM_DATA_TYPES);
     case WITH_HTML:
       if (IsChromeDashboardEnabled()) {
         return l10n_util::GetStringFUTF16(
             IDS_SYNC_ACCOUNT_SYNCING_WITH_MANAGE_LINK_NEW,
             base::ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
       }
       return l10n_util::GetStringFUTF16(
           IDS_SYNC_ACCOUNT_SYNCING_WITH_MANAGE_LINK,
           base::ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
     default:
@@ skipping 126 matching lines @@
 
     // 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;
     }
 
+    PrefService* pref_service = profile->GetPrefs();
+    syncer::SyncPrefs sync_prefs(pref_service);
+    bool all_data_types_synced = sync_prefs.HasKeepEverythingSynced();
+
     // 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);
         }
@@ skipping 22 matching lines @@
           *action_type = ENTER_PASSPHRASE;
         }
         return SYNC_ERROR;
       }
 
       // 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));
+          status_label->assign(GetSyncedStateStatusLabel(
+              service, signin, style, all_data_types_synced));
         }
         return PRE_SYNCED;
       }
     }
 
     // There is no error. Display "Last synced..." message.
-    if (status_label)
-      status_label->assign(GetSyncedStateStatusLabel(service, signin, style));
+    if (status_label) {
+      status_label->assign(GetSyncedStateStatusLabel(service, signin, style,
+                                                     all_data_types_synced));
+    }
     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.
     if (service->IsFirstSetupInProgress()) {
       result_type = PRE_SYNCED;
       ProfileSyncService::Status status;
       service->QueryDetailedSyncStatus(&status);
       AuthError auth_error =
           SigninErrorControllerFactory::GetForProfile(profile)->auth_error();
@@ skipping 214 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