[Sync] Stop deleting LevelDB files when deleting Directory

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 154 matching lines @@
     // has no significant state, -1 to never discard.
     -1,
 
     // Don't use initial delay unless the last request was an error.
     false,
 };
 
 const base::FilePath::CharType kLevelDBFolderName[] =
     FILE_PATH_LITERAL("LevelDB");
 
-// Perform the actual sync data folder deletion.
-// This should only be called on the sync thread.
-void DeleteSyncDataFolder(const base::FilePath& directory_path) {
-  if (base::DirectoryExists(directory_path)) {
-    if (!base::DeleteFile(directory_path, true))
-      LOG(DFATAL) << "Could not delete the Sync Data folder.";
-  }
-}
-
 }  // namespace
 
 ProfileSyncService::InitParams::InitParams() = default;
 ProfileSyncService::InitParams::InitParams(InitParams&& other) = default;
 ProfileSyncService::InitParams::~InitParams() = default;
 
 ProfileSyncService::ProfileSyncService(InitParams init_params)
     : SyncServiceBase(std::move(init_params.sync_client),
                       std::move(init_params.signin_wrapper),
                       init_params.channel,
@@ skipping 87 matching lines @@
                  syncer::ModelTypeSet(syncer::SESSIONS)));
 
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner(
         blocking_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
             blocking_pool_->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
     // TODO(skym): Stop creating leveldb files when signed out.
     // TODO(skym): Verify using AsUTF8Unsafe is okay here. Should work as long
     // as the Local State file is guaranteed to be UTF-8.
-    device_info_service_ = base::MakeUnique<DeviceInfoSyncBridge>(
+    device_info_sync_bridge_ = base::MakeUnique<DeviceInfoSyncBridge>(
         local_device_.get(),
         base::Bind(&ModelTypeStore::CreateStore, syncer::DEVICE_INFO,
-                   directory_path_.Append(base::FilePath(kLevelDBFolderName))
+                   sync_data_folder_.Append(base::FilePath(kLevelDBFolderName))
                        .AsUTF8Unsafe(),
                    blocking_task_runner),
         base::Bind(&ModelTypeChangeProcessor::Create));
   } else {
     device_info_sync_service_ =
         base::MakeUnique<DeviceInfoSyncService>(local_device_.get());
   }
 
   syncer::SyncApiComponentFactory::RegisterDataTypesMethod
       register_platform_types_callback =
@@ skipping 135 matching lines @@
 }
 
 sync_sessions::FaviconCache* ProfileSyncService::GetFaviconCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return sessions_sync_manager_->GetFaviconCache();
 }
 
 syncer::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // One of the two should always be non-null after initialization is done.
-  if (device_info_service_) {
-    return device_info_service_.get();
+  if (device_info_sync_bridge_) {
+    return device_info_sync_bridge_.get();
   } else {
     return device_info_sync_service_.get();
   }
 }
 
 syncer::LocalDeviceInfoProvider*
 ProfileSyncService::GetLocalDeviceInfoProvider() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return local_device_.get();
 }
@@ skipping 126 matching lines @@
 
   startup_controller_->OnDataTypeRequestsSyncStartup(type);
 }
 
 void ProfileSyncService::StartUpSlowEngineComponents() {
   invalidation::InvalidationService* invalidator =
       sync_client_->GetInvalidationService();
 
   engine_.reset(sync_client_->GetSyncApiComponentFactory()->CreateSyncEngine(
       debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
-      directory_path_));
+      sync_data_folder_));
 
   // Clear any old errors the first time sync starts.
   if (!IsFirstSetupComplete())
     ClearStaleErrors();
 
   InitializeEngine();
 
   UpdateFirstSyncTimePref();
 
   ReportPreviousSessionMemoryWarningCount();
@@ skipping 112 matching lines @@
   if (sync_thread_)
     sync_thread_->Stop();
 }
 
 void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) {
   if (!engine_) {
     if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) {
       // If the engine is already shut down when a DISABLE_SYNC happens,
       // the data directory needs to be cleaned up here.
       sync_thread_->task_runner()->PostTask(
-          FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_));
+          FROM_HERE,
+          base::Bind(&syncer::syncable::Directory::DeleteDirectoryFiles,
+                     sync_data_folder_));
     }
     return;
   }
 
   if (reason == syncer::ShutdownReason::STOP_SYNC ||
       reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
   // First, we spin down the engine to stop change processing as soon as
@@ skipping 1733 matching lines @@
   return sessions_sync_manager_.get();
 }
 
 syncer::SyncableService* ProfileSyncService::GetDeviceInfoSyncableService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return device_info_sync_service_.get();
 }
 
 syncer::ModelTypeSyncBridge* ProfileSyncService::GetDeviceInfoSyncBridge() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return device_info_service_.get();
+  return device_info_sync_bridge_.get();
 }
 
 syncer::SyncService::SyncTokenStatus ProfileSyncService::GetSyncTokenStatus()
     const {
   DCHECK(thread_checker_.CalledOnValidThread());
   SyncTokenStatus status;
   status.connection_status_update_time = connection_status_update_time_;
   status.connection_status = connection_status_;
   status.token_request_time = token_request_time_;
   status.token_receive_time = token_receive_time_;
@@ skipping 25 matching lines @@
 void ProfileSyncService::FlushDirectory() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // engine_initialized_ implies engine_ isn't null and the manager exists.
   // If sync is not initialized yet, we fail silently.
   if (engine_initialized_)
     engine_->FlushDirectory();
 }
 
 base::FilePath ProfileSyncService::GetDirectoryPathForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return directory_path_;
+  return sync_data_folder_;
 }
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (sync_thread_) {
     return sync_thread_->message_loop();
   } else {
     return nullptr;
   }
 }
@@ skipping 72 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync