Disable sync for Lightspeed experimentation.

chrome/browser/supervised_user/supervised_user_service.cc

 // Copyright 2014 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/supervised_user/supervised_user_service.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
@@ skipping 199 matching lines @@
 void SupervisedUserService::Shutdown() {
   if (!did_init_)
     return;
   DCHECK(!did_shutdown_);
   did_shutdown_ = true;
   if (ProfileIsSupervised()) {
     content::RecordAction(UserMetricsAction("ManagedUsers_QuitBrowser"));
   }
   SetActive(false);
 
-  ProfileSyncService* sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  // Can be null in tests.
-  if (sync_service)
-    sync_service->RemovePreferenceProvider(this);
+  if (profile_sync_service_)
+    profile_sync_service_->RemovePreferenceProvider(this);
 }
 
 bool SupervisedUserService::ProfileIsSupervised() const {
   return profile_->IsSupervised();
 }
 
 void SupervisedUserService::OnCustodianInfoChanged() {
   FOR_EACH_OBSERVER(
       SupervisedUserServiceObserver, observer_list_, OnCustodianInfoChanged());
 }
@@ skipping 170 matching lines @@
   result.Put(syncer::APP_SETTINGS);
   result.Put(syncer::APP_NOTIFICATIONS);
   result.Put(syncer::APP_LIST);
   return result;
 }
 
 void SupervisedUserService::OnHistoryRecordingStateChanged() {
   bool record_history =
       profile_->GetPrefs()->GetBoolean(prefs::kRecordHistory);
   includes_sync_sessions_type_ = record_history;
-  ProfileSyncServiceFactory::GetForProfile(profile_)
-      ->ReconfigureDatatypeManager();
+
+  if (profile_sync_service_)
+    profile_sync_service_->ReconfigureDatatypeManager();
 }
 
 bool SupervisedUserService::IncludesSyncSessionsType() const {
   return includes_sync_sessions_type_;
 }
 
 void SupervisedUserService::OnStateChanged() {
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (waiting_for_sync_initialization_ && service->backend_initialized() &&
-      service->backend_mode() == ProfileSyncService::SYNC) {
+  if (waiting_for_sync_initialization_ &&
+      profile_sync_service_ &&
+      profile_sync_service_->backend_initialized() &&
+      profile_sync_service_->backend_mode() == ProfileSyncService::SYNC) {
     waiting_for_sync_initialization_ = false;
-    service->RemoveObserver(this);
+    profile_sync_service_->RemoveObserver(this);
     FinishSetupSync();
     return;
   }
 
-  DLOG_IF(ERROR, service->GetAuthError().state() ==
+  DLOG_IF(ERROR, profile_sync_service_->GetAuthError().state() ==
                      GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS)
       << "Credentials rejected";
 }
 
 void SupervisedUserService::SetupSync() {
   StartSetupSync();
   FinishSetupSyncWhenReady();
 }
 
 void SupervisedUserService::StartSetupSync() {
   // Tell the sync service that setup is in progress so we don't start syncing
   // until we've finished configuration.
-  ProfileSyncServiceFactory::GetForProfile(profile_)->SetSetupInProgress(true);
+  if (profile_sync_service_)
+    profile_sync_service_->SetSetupInProgress(true);
 }
 
 void SupervisedUserService::FinishSetupSyncWhenReady() {
   // If we're already waiting for the Sync backend, there's nothing to do here.
-  if (waiting_for_sync_initialization_)
+  if (waiting_for_sync_initialization_ || !profile_sync_service_)
     return;
 
   // Continue in FinishSetupSync() once the Sync backend has been initialized.
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (service->backend_initialized() &&
-      service->backend_mode() == ProfileSyncService::SYNC) {
+  if (profile_sync_service_->backend_initialized() &&
+      profile_sync_service_->backend_mode() == ProfileSyncService::SYNC) {
     FinishSetupSync();
   } else {
-    service->AddObserver(this);
+    profile_sync_service_->AddObserver(this);
     waiting_for_sync_initialization_ = true;
   }
 }
 
 void SupervisedUserService::FinishSetupSync() {
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  DCHECK(service->backend_initialized());
-  DCHECK(service->backend_mode() == ProfileSyncService::SYNC);
+  if (!profile_sync_service_)
+    return;
+
+  DCHECK(profile_sync_service_->backend_initialized());
+  DCHECK(profile_sync_service_->backend_mode() == ProfileSyncService::SYNC);
 
   // Sync nothing (except types which are set via GetPreferredDataTypes).
   bool sync_everything = false;
   syncer::ModelTypeSet synced_datatypes;
-  service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
+  profile_sync_service_->OnUserChoseDatatypes(sync_everything,
+                                              synced_datatypes);
 
   // Notify ProfileSyncService that we are done with configuration.
-  service->SetSetupInProgress(false);
-  service->SetSyncSetupCompleted();
+  profile_sync_service_->SetSetupInProgress(false);
+  profile_sync_service_->SetSyncSetupCompleted();
 }
 
 #if defined(ENABLE_EXTENSIONS)
 bool SupervisedUserService::ExtensionManagementPolicyImpl(
     const extensions::Extension* extension,
     base::string16* error) const {
   // |extension| can be NULL in unit_tests.
   if (!ProfileIsSupervised() || (extension && extension->is_theme()))
     return true;
 
@@ skipping 144 matching lines @@
   token_service->UpdateCredentials(supervised_users::kSupervisedUserPseudoEmail,
                                    refresh_token);
 
   FinishSetupSyncWhenReady();
 }
 
 void SupervisedUserService::Init() {
   DCHECK(!did_init_);
   did_init_ = true;
   DCHECK(GetSettingsService()->IsReady());
+  profile_sync_service_ =

[Alexei Svitkine (slow), 2015/02/19 22:04:08]

Initialize this in the ctor too, or some bots will yell at you.

[Mike Lerman, 2015/02/20 16:38:01]

Done.

+      ProfileSyncServiceFactory::GetForProfile(profile_);
 
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kSupervisedUserId,
       base::Bind(&SupervisedUserService::OnSupervisedUserIdChanged,
           base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kRecordHistory,
       base::Bind(&SupervisedUserService::OnHistoryRecordingStateChanged,
                  base::Unretained(this)));
 
-  ProfileSyncService* sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  // Can be null in tests.
-  if (sync_service)
-    sync_service->AddPreferenceProvider(this);
+  if (profile_sync_service_)
+    profile_sync_service_->AddPreferenceProvider(this);
 
   std::string client_id = component_updater::SupervisedUserWhitelistInstaller::
       ClientIdForProfilePath(profile_->GetPath());
   whitelist_service_.reset(new SupervisedUserWhitelistService(
       profile_->GetPrefs(),
       g_browser_process->supervised_user_whitelist_installer(), client_id));
   whitelist_service_->AddSiteListsChangedCallback(
       base::Bind(&SupervisedUserService::OnSiteListsChanged,
                  weak_ptr_factory_.GetWeakPtr()));
 
@@ skipping 19 matching lines @@
 
       ProfileOAuth2TokenService* token_service =
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
       token_service->LoadCredentials(
           supervised_users::kSupervisedUserPseudoEmail);
 
       permissions_creators_.push_back(new PermissionRequestCreatorSync(
           GetSettingsService(),
           SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile_),
-          ProfileSyncServiceFactory::GetForProfile(profile_),
+          profile_sync_service_,
           GetSupervisedUserName(),
           profile_->GetPrefs()->GetString(prefs::kSupervisedUserId)));
 
-      SetupSync();
+      if (profile_sync_service_)
+        SetupSync();
     }
   }
 
   // Now activate/deactivate anything not handled by the delegate yet.
 
 #if defined(ENABLE_THEMES)
   // Re-set the default theme to turn the SU theme on/off.
   ThemeService* theme_service = ThemeServiceFactory::GetForProfile(profile_);
   if (theme_service->UsingDefaultTheme() || theme_service->UsingSystemTheme()) {
     ThemeServiceFactory::GetForProfile(profile_)->UseDefaultTheme();
   }
 #endif
 
-  ProfileSyncService* sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  sync_service->SetEncryptEverythingAllowed(!active_);
+  if (profile_sync_service_)
+    profile_sync_service_->SetEncryptEverythingAllowed(!active_);
 
   GetSettingsService()->SetActive(active_);
 
 #if defined(ENABLE_EXTENSIONS)
   SetExtensionsActive();
 #endif
 
   if (active_) {
     pref_change_registrar_.Add(
         prefs::kDefaultSupervisedUserFilteringBehavior,
@@ skipping 46 matching lines @@
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualHosts);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualURLs);
     for (const char* pref : kCustodianInfoPrefs) {
       pref_change_registrar_.Remove(pref);
     }
 
     url_filter_context_.Clear();
     FOR_EACH_OBSERVER(
         SupervisedUserServiceObserver, observer_list_, OnURLFilterChanged());
 
-    if (waiting_for_sync_initialization_)
-      ProfileSyncServiceFactory::GetForProfile(profile_)->RemoveObserver(this);
+    if (waiting_for_sync_initialization_ && profile_sync_service_)
+      profile_sync_service_->RemoveObserver(this);
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::RemoveObserver(this);
 #endif
   }
 }
 
 void SupervisedUserService::RegisterAndInitSync(
@@ skipping 104 matching lines @@
   // The active user can be NULL in unit tests.
   if (user_manager::UserManager::Get()->GetActiveUser()) {
     return UTF16ToUTF8(user_manager::UserManager::Get()->GetUserDisplayName(
         user_manager::UserManager::Get()->GetActiveUser()->GetUserID()));
   }
   return std::string();
 #else
   return profile_->GetPrefs()->GetString(prefs::kProfileName);
 #endif
 }