Sync: Improve handling of database load failures

chrome/browser/sync/profile_sync_service_unittest.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 "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
@@ skipping 59 matching lines @@
     // posting on the IO thread).
     ui_loop_.RunAllPending();
     io_thread_.Stop();
     // Ensure that the sync objects destruct to avoid memory leaks.
     ui_loop_.RunAllPending();
   }
 
   // TODO(akalin): Refactor the StartSyncService*() functions below.
 
   void StartSyncService() {
-    StartSyncServiceAndSetInitialSyncEnded(true, true, false, true);
+    StartSyncServiceAndSetInitialSyncEnded(true, true, false, true, true);
   }
 
   void StartSyncServiceAndSetInitialSyncEnded(
       bool set_initial_sync_ended,
       bool issue_auth_token,
       bool synchronous_sync_configuration,
-      bool sync_setup_completed) {
+      bool sync_setup_completed,
+      bool expect_create_dtm) {
     if (!service_.get()) {
       // Set bootstrap to true and it will provide a logged in user for test
       service_.reset(new TestProfileSyncService(&factory_,
                                                 profile_.get(),
                                                 "test", true, NULL));
       if (!set_initial_sync_ended)
         service_->dont_set_initial_sync_ended_on_init();
       if (synchronous_sync_configuration)
         service_->set_synchronous_sync_configuration();
       if (!sync_setup_completed)
         profile_->GetPrefs()->SetBoolean(prefs::kSyncHasSetupCompleted, false);
 
-      // Register the bookmark data type.
-      EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
-          WillOnce(ReturnNewDataTypeManager());
+      if (expect_create_dtm) {
+        // Register the bookmark data type.
+        EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
+            WillOnce(ReturnNewDataTypeManager());
+      } else {
+        EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
+      }
 
       if (issue_auth_token) {
         profile_->GetTokenService()->IssueAuthTokenForTest(
             GaiaConstants::kSyncService, "token");
       }
       service_->Initialize();
     }
   }
 
   MessageLoop ui_loop_;
@@ skipping 72 matching lines @@
   EXPECT_TRUE(service_->GetBackendForTest() != NULL);
 
   JsController* js_controller = service_->GetJsController();
   StrictMock<MockJsEventHandler> event_handler;
   js_controller->AddJsEventHandler(&event_handler);
   js_controller->RemoveJsEventHandler(&event_handler);
 }
 
 TEST_F(ProfileSyncServiceTest,
        JsControllerHandlersDelayedBackendInitialization) {
-  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true);
+  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, true);
 
   StrictMock<MockJsEventHandler> event_handler;
   EXPECT_CALL(event_handler, HandleJsEvent(_, _)).Times(AtLeast(1));
 
   EXPECT_EQ(NULL, service_->GetBackendForTest());
   EXPECT_FALSE(service_->sync_initialized());
 
   JsController* js_controller = service_->GetJsController();
   js_controller->AddJsEventHandler(&event_handler);
   // Since we're doing synchronous initialization, backend should be
@@ skipping 21 matching lines @@
                                     reply_handler.AsWeakHandle());
   }
 
   // This forces the sync thread to process the message and reply.
   service_.reset();
   ui_loop_.RunAllPending();
 }
 
 TEST_F(ProfileSyncServiceTest,
        JsControllerProcessJsMessageBasicDelayedBackendInitialization) {
-  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true);
+  StartSyncServiceAndSetInitialSyncEnded(true, false, false, true, true);
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue arg_list1;
   arg_list1.Append(Value::CreateBooleanValue(false));
   JsArgList args1(&arg_list1);
   EXPECT_CALL(reply_handler,
               HandleJsReply("getNotificationState", HasArgs(args1)));
 
   {
@@ skipping 22 matching lines @@
   FilePath sync_file2 = temp_directory.AppendASCII("SyncData.sqlite3");
   FilePath sync_file3 = temp_directory.AppendASCII("nonsense_file");
   ASSERT_TRUE(file_util::CreateDirectory(temp_directory));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file1, nonsense1, strlen(nonsense1)));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file2, nonsense2, strlen(nonsense2)));
   ASSERT_NE(-1,
             file_util::WriteFile(sync_file3, nonsense3, strlen(nonsense3)));
 
-  StartSyncServiceAndSetInitialSyncEnded(false, false, true, false);
+  StartSyncServiceAndSetInitialSyncEnded(false, false, true, false, true);
   EXPECT_FALSE(service_->HasSyncSetupCompleted());
+  EXPECT_FALSE(service_->sync_initialized());
 
   // Since we're doing synchronous initialization, backend should be
   // initialized by this call.
   profile_->GetTokenService()->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "token");
 
   // Stop the service so we can read the new Sync Data files that were
   // created.
   service_.reset();
 
   // This file should have been deleted when the whole directory was nuked.
   ASSERT_FALSE(file_util::PathExists(sync_file3));
   ASSERT_FALSE(file_util::PathExists(sync_file1));
 
   // This will still exist, but the text should have changed.
   ASSERT_TRUE(file_util::PathExists(sync_file2));
   std::string file2text;
   ASSERT_TRUE(file_util::ReadFileToString(sync_file2, &file2text));
   ASSERT_NE(file2text.compare(nonsense2), 0);
 }
 
+TEST_F(ProfileSyncServiceTest, CorruptDatabase) {
+  const char * nonesense = "not a database";

[Nicolas Zea, 2011/11/14 19:29:21]

"const char* nonsense"

[rlarocque, 2011/11/14 22:56:26]

Done.

+
+  FilePath temp_directory = profile_->GetPath().AppendASCII("Sync Data");
+  FilePath sync_db_file = temp_directory.AppendASCII("SyncData.sqlite3");
+
+  ASSERT_TRUE(file_util::CreateDirectory(temp_directory));
+  ASSERT_NE(-1,
+            file_util::WriteFile(sync_db_file, nonesense, strlen(nonesense)));
+
+  // Initialize with HasSyncSetupCompleted() set to true and InitialSyncEnded
+  // false.  This is to model the scenario that would result when opening the
+  // sync database fails.
+  StartSyncServiceAndSetInitialSyncEnded(false, true, true, true, false);
+
+  // The backend is not ready.  Ensure the PSS knows this.
+  EXPECT_FALSE(service_->sync_initialized());
+
+  // Ensure we will be prepared to initialize a fresh DB next time.
+  EXPECT_FALSE(service_->HasSyncSetupCompleted());
+}
+
 }  // namespace
 
 }  // namespace browser_sync