[sync] Display an error when sync settings aren't confirmed

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 43 matching lines @@
 namespace sync_ui_util {
 
 namespace {
 
 bool IsChromeDashboardEnabled() {
   const std::string group_name =
       base::FieldTrialList::FindFullName("ChromeDashboard");
   return group_name == "Enabled";
 }
 
+bool IsSyncConfirmationNeeded(ProfileSyncService* service) {
+  // The user is signed in and sync is requested, but setup is incomplete.
+  // Sync confirmation needs to be completed.
+  return service->IsSyncRequested() && !service->IsFirstSetupComplete();
+}
+
 // 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,
                                          bool sync_everything) {
   if (!service || service->IsManaged()) {
     // User is signed in, but sync is disabled.
     return l10n_util::GetStringUTF16(IDS_SIGNED_IN_WITH_SYNC_DISABLED);
@@ skipping 242 matching lines @@
         }
         result_type = SYNC_ERROR;
       }
     } else if (service->HasUnrecoverableError()) {
       result_type = SYNC_ERROR;
       if (status_label && link_label) {
         GetStatusForUnrecoverableError(profile, service, status_label,
                                        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));
+      if (IsSyncConfirmationNeeded(service)) {
+        if (status_label && link_label) {
+          status_label->assign(
+              l10n_util::GetStringUTF16(IDS_SYNC_SETTINGS_NOT_CONFIRMED));
+          link_label->assign(l10n_util::GetStringUTF16(
+              IDS_SYNC_ERROR_USER_MENU_CONFIRM_SYNC_SETTINGS_BUTTON));
+        }
+        *action_type = CONFIRM_SYNC_SETTINGS;
+        if (!status_label->empty())

[skym, 2017/06/01 19:48:44]

First, what a function. Combines figuring out your state, with setting UI. And
everyone had to deal with status_label and link_label to being null, maybe.

This check of status_label->empty() isn't guarded by if(status_label), right? So
this will deref nullptr, right?

[Patrick Noland, 2017/06/07 19:07:23]

Done.

+          return SYNC_ERROR;
+      } else {
+        // 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));
+        }
       }
     }
   }
   return result_type;
 }
 
 // Returns the status info for use on the new tab page, where we want slightly
 // different information than in the settings panel.
 MessageType GetStatusInfoForNewTabPage(Profile* profile,
                                        ProfileSyncService* service,
@@ skipping 53 matching lines @@
                                          const SigninManagerBase& signin,
                                          base::string16* status_label,
                                          base::string16* link_label) {
   DCHECK(status_label);
   DCHECK(link_label);
   return sync_ui_util::GetStatusInfoForNewTabPage(profile, service, signin,
                                                   status_label, link_label);
 }
 
 #if !defined(OS_CHROMEOS)
-AvatarSyncErrorType GetMessagesForAvatarSyncError(Profile* profile,
-                                                  int* content_string_id,
-                                                  int* button_string_id) {
+AvatarSyncErrorType GetMessagesForAvatarSyncError(
+    Profile* profile,
+    const SigninManagerBase& signin,
+    int* content_string_id,
+    int* button_string_id) {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile);
 
   // The order or priority is going to be: 1. Unrecoverable errors.
   // 2. Auth errors. 3. Protocol errors. 4. Passphrase errors.
   if (service && service->HasUnrecoverableError()) {
     // An unrecoverable error is sometimes accompanied by an actionable error.
     // If an actionable error is not set to be UPGRADE_CLIENT, then show a
     // generic unrecoverable error message.
     ProfileSyncService::Status status;
@@ skipping 45 matching lines @@
     }
 
     // Check for a sync passphrase error.
     syncer::SyncErrorController* sync_error_controller =
         service->sync_error_controller();
     if (sync_error_controller && sync_error_controller->HasError()) {
       *content_string_id = IDS_SYNC_ERROR_USER_MENU_PASSPHRASE_MESSAGE;
       *button_string_id = IDS_SYNC_ERROR_USER_MENU_PASSPHRASE_BUTTON;
       return PASSPHRASE_ERROR;
     }
+
+    // Check for a sync confirmation error.
+    if (signin.IsAuthenticated() && IsSyncConfirmationNeeded(service)) {
+      *content_string_id = IDS_SYNC_SETTINGS_NOT_CONFIRMED;
+      *button_string_id = IDS_SYNC_ERROR_USER_MENU_CONFIRM_SYNC_SETTINGS_BUTTON;
+      return SETTINGS_UNCONFIRMED_ERROR;
+    }
   }
 
   // There is no error.
   return NO_SYNC_ERROR;
 }
 #endif
 
 MessageType GetStatus(Profile* profile,
                       ProfileSyncService* service,
                       const SigninManagerBase& signin) {
   ActionType action_type = NO_ACTION;
   return sync_ui_util::GetStatusInfo(profile, service, signin, WITH_HTML,
                                      nullptr, nullptr, &action_type);
 }
 
 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