[Sync] Stop deleting LevelDB files when deleting Directory

components/sync/driver/glue/sync_backend_host_core.cc

 // Copyright 2013 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/sync/driver/glue/sync_backend_host_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 10 matching lines @@
 #include "components/sync/engine/cycle/commit_counters.h"
 #include "components/sync/engine/cycle/status_counters.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "components/sync/engine/cycle/update_counters.h"
 #include "components/sync/engine/engine_components_factory.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/engine/net/http_post_provider_factory.h"
 #include "components/sync/engine/sync_backend_registrar.h"
 #include "components/sync/engine/sync_manager.h"
 #include "components/sync/engine/sync_manager_factory.h"
+#include "components/sync/syncable/directory.h"
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncers involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 static const int kSaveChangesIntervalSeconds = 10;
 
 namespace net {
 class URLFetcher;
 }
 
 namespace {
 
 void BindFetcherToDataTracker(net::URLFetcher* fetcher) {
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::SYNC);
 }
 
 }  // namespace
 
 namespace syncer {
 
 class EngineComponentsFactory;
 
 SyncBackendHostCore::SyncBackendHostCore(
     const std::string& name,
-    const base::FilePath& sync_data_folder_path,
+    const base::FilePath& sync_data_folder,
     const base::WeakPtr<SyncBackendHostImpl>& backend)
     : name_(name),
-      sync_data_folder_path_(sync_data_folder_path),
+      sync_data_folder_(sync_data_folder),
       host_(backend),
       weak_ptr_factory_(this) {
   DCHECK(backend.get());
   // This is constructed on the UI thread but used from the sync thread.
   thread_checker_.DetachFromThread();
 }
 
 SyncBackendHostCore::~SyncBackendHostCore() {
   DCHECK(!sync_manager_.get());
 }
@@ skipping 244 matching lines @@
   host_.Call(FROM_HERE, &SyncBackendHostImpl::UpdateInvalidationVersions,
              last_invalidation_versions_);
 }
 
 void SyncBackendHostCore::DoInitialize(SyncEngine::InitParams params) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Blow away the partial or corrupt sync data folder before doing any more
   // initialization, if necessary.
   if (params.delete_sync_data_folder) {
-    DeleteSyncDataFolder();
+    syncable::Directory::DeleteDirectoryFiles(sync_data_folder_);
   }
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
-  if (!base::CreateDirectory(sync_data_folder_path_)) {
+  if (!base::CreateDirectory(sync_data_folder_)) {
     DLOG(FATAL) << "Sync Data directory creation failed.";
   }
 
   // Load the previously persisted set of invalidation versions into memory.
   last_invalidation_versions_ = params.invalidation_versions;
 
   DCHECK(!registrar_);
   registrar_ = std::move(params.registrar);
   DCHECK(registrar_);
 
   sync_manager_ = params.sync_manager_factory->CreateSyncManager(name_);
   sync_manager_->AddObserver(this);
 
   SyncManager::InitArgs args;
-  args.database_location = sync_data_folder_path_;
+  args.database_location = sync_data_folder_;
   args.event_handler = params.event_handler;
   args.service_url = params.service_url;
   args.enable_local_sync_backend = params.enable_local_sync_backend;
   args.local_sync_backend_folder = params.local_sync_backend_folder;
   args.post_factory =
       params.http_factory_getter.Run(&release_request_context_signal_);
   // Finish initializing the HttpBridgeFactory.  We do this here because
   // building the user agent may block on some platforms.
   args.post_factory->Init(params.sync_user_agent,
                           base::Bind(&BindFetcherToDataTracker));
@@ skipping 114 matching lines @@
 }
 
 void SyncBackendHostCore::DoShutdown(ShutdownReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DoDestroySyncManager(reason);
 
   registrar_ = nullptr;
 
   if (reason == DISABLE_SYNC)
-    DeleteSyncDataFolder();
+    syncable::Directory::DeleteDirectoryFiles(sync_data_folder_);
 
   host_.Reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void SyncBackendHostCore::DoDestroySyncManager(ShutdownReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
   if (sync_manager_) {
@@ skipping 100 matching lines @@
 
   if (!forward_type_info_)
     return;
 
   forward_type_info_ = false;
 
   if (sync_manager_->HasDirectoryTypeDebugInfoObserver(this))
     sync_manager_->UnregisterDirectoryTypeDebugInfoObserver(this);
 }
 
-void SyncBackendHostCore::DeleteSyncDataFolder() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (base::DirectoryExists(sync_data_folder_path_)) {
-    if (!base::DeleteFile(sync_data_folder_path_, true))
-      SLOG(DFATAL) << "Could not delete the Sync Data folder.";
-  }
-}
-
 void SyncBackendHostCore::StartSavingChanges() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!save_changes_timer_.get());
   save_changes_timer_ = base::MakeUnique<base::RepeatingTimer>();
   save_changes_timer_->Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &SyncBackendHostCore::SaveChanges);
 }
 
 void SyncBackendHostCore::SaveChanges() {
@@ skipping 17 matching lines @@
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 }  // namespace syncer