Sync: Improve handling of database load failures

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 199 matching lines @@
       registrar_->StopOnUIThread();
   } else {
     // If the sync thread isn't running, then the syncer is effectively
     // stopped.  Moreover, it implies that we never attempted initialization,
     // so the registrar won't need stopping either.
     DCHECK_EQ(NOT_ATTEMPTED, initialization_state_);
     DCHECK(!registrar_.get());
   }
 }
 
-void SyncBackendHost::Shutdown(bool sync_disabled) {
+void SyncBackendHost::Shutdown(bool delete_stale_data) {
   // TODO(tim): DCHECK(registrar_->StoppedOnUIThread()) would be nice.
   if (sync_thread_.IsRunning()) {
     sync_thread_.message_loop()->PostTask(FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoShutdown, core_.get(),
-                   sync_disabled));
+                   delete_stale_data));
   }
 
   // Stop will return once the thread exits, which will be after DoShutdown
   // runs. DoShutdown needs to run from sync_thread_ because the sync backend
   // requires any thread that opened sqlite handles to relinquish them
   // personally. We need to join threads, because otherwise the main Chrome
   // thread (ui loop) can exit before DoShutdown finishes, at which point
   // virtually anything the sync backend does (or the post-back to
   // frontend_loop_ by our Core) will epically fail because the CRT won't be
   // initialized.
@@ skipping 177 matching lines @@
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   host_->frontend_loop_->PostTask(FROM_HERE,
       base::Bind(&Core::HandleInitializationCompletedOnFrontendLoop, this,
                  js_backend, success));
 
-  // Initialization is complete, so we can schedule recurring SaveChanges.
-  sync_loop_->PostTask(FROM_HERE, base::Bind(&Core::StartSavingChanges, this));
+  if (success) {
+    // Initialization is complete, so we can schedule recurring SaveChanges.
+    sync_loop_->PostTask(FROM_HERE,
+                         base::Bind(&Core::StartSavingChanges, this));
+  }
 }
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // Post to our core loop so we can modify state. Could be on another thread.
   host_->frontend_loop_->PostTask(FROM_HERE,
       base::Bind(&Core::HandleAuthErrorEventOnFrontendLoop, this, auth_error));
 }
@@ skipping 166 matching lines @@
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       host_->MakeHttpBridgeFactory(options.request_context_getter),
       options.registrar /* as ModelSafeWorkerRegistrar */,
       options.registrar /* as SyncManager::ChangeDelegate */,
       MakeUserAgentForSyncApi(),
       options.credentials,
       host_->sync_notifier_factory_.CreateSyncNotifier(),
       options.restored_key_for_bootstrapping,
       options.setup_for_test_mode);
-  DCHECK(success) << "Syncapi initialization failed!";

[Nicolas Zea, 2011/11/08 22:12:18]

LOG_IF(ERROR, !success) would still be useful I think

[rlarocque, 2011/11/11 22:24:56]

Done.

 }
 
 void SyncBackendHost::Core::DoCheckServerReachable() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->CheckServerReachable();
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
@@ skipping 37 matching lines @@
   sync_manager_->RefreshEncryption();
   done_callback.Run();
 }
 
 void SyncBackendHost::Core::DoStopSyncManagerForShutdown(
     const base::Closure& closure) {
   DCHECK(sync_manager_.get());
   sync_manager_->StopSyncingForShutdown(closure);
 }
 
-void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
+void SyncBackendHost::Core::DoShutdown(bool delete_stale_data) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!sync_manager_.get())
     return;
 
   save_changes_timer_.Stop();
   sync_manager_->ShutdownOnSyncThread();
   sync_manager_->RemoveObserver(this);
   sync_manager_.reset();
   registrar_ = NULL;
 
-  if (sync_disabled)
+  if (delete_stale_data)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_ = NULL;
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
     const syncable::ModelTypeBitSet& types_to_config,
     sync_api::ConfigureReason reason) {
@@ skipping 354 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync