[Sync] Replacing NULL with nullptr/null throughout sync code.

components/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 "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 346 matching lines @@
 
 #if defined(OS_CHROMEOS)
   std::string bootstrap_token = sync_prefs_.GetEncryptionBootstrapToken();
   if (bootstrap_token.empty()) {
     sync_prefs_.SetEncryptionBootstrapToken(
         sync_prefs_.GetSpareBootstrapToken());
   }
 #endif
 
 #if !defined(OS_ANDROID)
-  DCHECK(sync_error_controller_ == NULL)
+  DCHECK(sync_error_controller_ == nullptr)
       << "Initialize() called more than once.";
   sync_error_controller_ = base::MakeUnique<syncer::SyncErrorController>(this);
   AddObserver(sync_error_controller_.get());
 #endif
 
   memory_pressure_listener_ = base::MakeUnique<base::MemoryPressureListener>(
       base::Bind(&ProfileSyncService::OnMemoryPressure,
                  sync_enabled_weak_factory_.GetWeakPtr()));
   startup_controller_->Reset(GetRegisteredDataTypes());
 
@@ skipping 45 matching lines @@
   DataTypeController::TypeMap::const_iterator iter =
       data_type_controllers_.find(type);
   if (iter == data_type_controllers_.end()) {
     return false;
   }
   return iter->second->state() == DataTypeController::RUNNING;
 }
 
 sync_sessions::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() {
   if (!IsDataTypeControllerRunning(syncer::SESSIONS))
-    return NULL;
+    return nullptr;
   return sessions_sync_manager_.get();
 }
 
 sync_sessions::FaviconCache* ProfileSyncService::GetFaviconCache() {
   return sessions_sync_manager_->GetFaviconCache();
 }
 
 syncer::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker() const {
   // One of the two should always be non-null after initialization is done.
   if (device_info_service_) {
@@ skipping 1330 matching lines @@
   }
 
   data_type_manager_->Configure(types, reason);
 }
 
 syncer::UserShare* ProfileSyncService::GetUserShare() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->GetUserShare();
   }
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 syncer::SyncCycleSnapshot ProfileSyncService::GetLastCycleSnapshot() const {
   if (backend_)
     return backend_->GetLastCycleSnapshot();
   return syncer::SyncCycleSnapshot();
 }
 
 bool ProfileSyncService::HasUnsyncedItems() const {
   if (HasSyncingBackend() && backend_initialized_) {
@@ skipping 135 matching lines @@
 
   // If we get here, we don't have pending keys (or at least, the passphrase
   // doesn't decrypt them) - just try to re-encrypt using the encryption
   // passphrase.
   if (!IsUsingSecondaryPassphrase())
     SetEncryptionPassphrase(passphrase, IMPLICIT);
 }
 
 void ProfileSyncService::RequestAccessToken() {
   // Only one active request at a time.
-  if (access_token_request_ != NULL)
+  if (access_token_request_ != nullptr)
     return;
   request_access_token_retry_timer_.Stop();
   OAuth2TokenService::ScopeSet oauth2_scopes;
   oauth2_scopes.insert(signin_->GetSyncScopeToUse());
 
   // Invalidate previous token, otherwise token service will return the same
   // token again.
   const std::string& account_id = signin_->GetAccountIdToUse();
   if (!access_token_.empty()) {
     oauth2_token_service_->InvalidateAccessToken(account_id, oauth2_scopes,
@@ skipping 332 matching lines @@
   sync_prefs_.SetSyncRequested(false);
   StopImpl(data_fate);
 }
 
 bool ProfileSyncService::IsSyncRequested() const {
   return sync_prefs_.IsSyncRequested();
 }
 
 SigninManagerBase* ProfileSyncService::signin() const {
   if (!signin_)
-    return NULL;
+    return nullptr;
   return signin_->GetOriginal();
 }
 
 void ProfileSyncService::RequestStart() {
   if (!IsSyncAllowed()) {
     // Sync cannot be requested if it's not allowed.
     return;
   }
   DCHECK(sync_client_);
   if (!IsSyncRequested()) {
@@ skipping 82 matching lines @@
     status.next_token_request_time = next_token_request_time_;
   return status;
 }
 
 void ProfileSyncService::OverrideNetworkResourcesForTest(
     std::unique_ptr<syncer::NetworkResources> network_resources) {
   network_resources_ = std::move(network_resources);
 }
 
 bool ProfileSyncService::HasSyncingBackend() const {
-  return backend_ != NULL;
+  return backend_ != nullptr;
 }
 
 void ProfileSyncService::UpdateFirstSyncTimePref() {
   if (!IsSignedIn()) {
     sync_prefs_.ClearFirstSyncTime();
   } else if (sync_prefs_.GetFirstSyncTime().is_null()) {
     // Set if not set before and it's syncing now.
     sync_prefs_.SetFirstSyncTime(base::Time::Now());
   }
 }
 
 void ProfileSyncService::FlushDirectory() const {
-  // backend_initialized_ implies backend_ isn't NULL and the manager exists.
+  // backend_initialized_ implies backend_ isn't null and the manager exists.
   // If sync is not initialized yet, we fail silently.
   if (backend_initialized_)
     backend_->FlushDirectory();
 }
 
 base::FilePath ProfileSyncService::GetDirectoryPathForTest() const {
   return directory_path_;
 }
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   if (sync_thread_) {
     return sync_thread_->message_loop();
   } else if (backend_) {
     return backend_->GetSyncLoopForTesting();
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
 void ProfileSyncService::RefreshTypesForTest(syncer::ModelTypeSet types) {
   if (backend_initialized_)
     backend_->RefreshTypesForTest(types);
 }
 
 void ProfileSyncService::RemoveClientFromServer() const {
   if (!backend_initialized_)
@@ skipping 60 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync