Client changes for disabled dasher account

chrome/browser/sync/profile_sync_service.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/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 107 matching lines @@
   for (int i = 0; i < kRelevantTokenServicesCount; ++i) {
     if (service == kRelevantTokenServices[i])
       return true;
   }
   return false;
 }
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error) {
   return (error.action != syncer::UNKNOWN_ACTION &&
-          error.action != syncer::DISABLE_SYNC_ON_CLIENT);
+          error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
+          error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT);
 }
 
 ProfileSyncService::ProfileSyncService(ProfileSyncComponentsFactory* factory,
                                        Profile* profile,
                                        SigninManagerBase* signin_manager,
                                        StartBehavior start_behavior)
     : last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
@@ skipping 528 matching lines @@
     doomed_backend->Shutdown(sync_disabled);
 
     doomed_backend.reset();
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
   // Clear various flags.
+  start_up_time_ = base::Time();
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
   // NULL if we're called from Shutdown().
   if (invalidator_registrar_)
     UpdateInvalidatorRegistrarState();
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
@@ skipping 473 matching lines @@
       }
       // Trigger an unrecoverable error to stop syncing.
       OnInternalUnrecoverableError(FROM_HERE,
                                    last_actionable_error_.error_description,
                                    true,
                                    ERROR_REASON_ACTIONABLE_ERROR);
       break;
     case syncer::DISABLE_SYNC_ON_CLIENT:
       OnStopSyncingPermanently();
       break;
+    case syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT:
+      // Sync disabled by domain admin. we should stop syncing until
+      // user signs out and signs in again.
+      sync_prefs_.SetSyncDisabledByAdmin(true);
+      DisableForUser();
+      break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 }
 
 void ProfileSyncService::OnConfigureBlocked() {
   NotifyObservers();
 }
 
@@ skipping 736 matching lines @@
       break;
     }
     case chrome::NOTIFICATION_TOKENS_CLEARED: {
       // GetCredentials() will generate invalid credentials to cause the backend
       // to generate an auth error.
       if (backend_)
         backend_->UpdateCredentials(GetCredentials());
       break;
     }
     case chrome::NOTIFICATION_GOOGLE_SIGNED_OUT:
-      // Disable sync if the user is signed out.
+      // Disable sync if the user is signed out. Clear DisabledByAdmin flag so
+      // when next time user signs in sync can try to connect to server again.
+      sync_prefs_.SetSyncDisabledByAdmin(false);

[Andrew T Wilson (Slow), 2013/05/14 12:34:01]

As I mentioned previously, on ChromeOS the user never signs out so this code
will never get run on ChromeOS.

       DisableForUser();
       break;
     default: {
       NOTREACHED();
     }
   }
 }
 
 void ProfileSyncService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
@@ skipping 16 matching lines @@
 }
 
 // static
 bool ProfileSyncService::IsSyncEnabled() {
   // We have switches::kEnableSync just in case we need to change back to
   // sync-disabled-by-default on a platform.
   return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableSync);
 }
 
 bool ProfileSyncService::IsManaged() const {
-  return sync_prefs_.IsManaged();
+  return sync_prefs_.IsManaged() || sync_prefs_.IsSyncDisabledByAdmin();
 }
 
 bool ProfileSyncService::ShouldPushChanges() {
   // True only after all bootstrapping has succeeded: the sync backend
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (HasUnrecoverableError())
     return false;
 
   if (!data_type_manager_)
@@ skipping 84 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }