[SyncFS] Make routines using metadata database async

chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <stack>
 
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/drive/drive_uploader.h"
 #include "chrome/browser/drive/fake_drive_service.h"
 #include "chrome/browser/drive/test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/common/extension.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 
 #define FPL(a) FILE_PATH_LITERAL(a)
 
 namespace sync_file_system {
 namespace drive_backend {
 
 typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
-void SetSyncStatus(const base::Closure& closure,
-                   SyncStatusCode* status_out,
-                   SyncStatusCode status) {
-  *status_out = status;
+template <typename T>
+void SetValueAndCallClosure(const base::Closure& closure,
+                            T* arg_out,
+                            T arg) {
+  *arg_out = base::internal::CallbackForward(arg);
   closure.Run();
 }
 
 void SetSyncStatusAndUrl(const base::Closure& closure,
                          SyncStatusCode* status_out,
                          fileapi::FileSystemURL* url_out,
                          SyncStatusCode status,
                          const fileapi::FileSystemURL& url) {
   *status_out = status;
   *url_out = url;
@@ skipping 93 matching lines @@
   }
 
   fileapi::FileSystemURL CreateURL(const std::string& app_id,
                                    const base::FilePath& path) {
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     return CreateSyncableFileSystemURL(origin, path);
   }
 
   bool GetAppRootFolderID(const std::string& app_id,
                           std::string* folder_id) {
+    base::RunLoop run_loop;
+    bool success = false;
     FileTracker tracker;
-    if (!metadata_database()->FindAppRootTracker(app_id, &tracker))
+    PostTaskAndReplyWithResult(
+        worker_task_runner_,
+        FROM_HERE,
+        base::Bind(&MetadataDatabase::FindAppRootTracker,
+                   base::Unretained(metadata_database()),
+                   app_id,
+                   &tracker),
+        base::Bind(&SetValueAndCallClosure<bool>,
+                   run_loop.QuitClosure(),
+                   &success));
+    run_loop.Run();
+    if (!success)
       return false;
     *folder_id = tracker.file_id();
     return true;
   }
 
   std::string GetFileIDByPath(const std::string& app_id,
                               const base::FilePath::StringType& path) {
     return GetFileIDByPath(app_id, base::FilePath(path));
   }
 
   std::string GetFileIDByPath(const std::string& app_id,
                               const base::FilePath& path) {
+    base::RunLoop run_loop;
+    bool success = false;
     FileTracker tracker;
     base::FilePath result_path;
     base::FilePath normalized_path = path.NormalizePathSeparators();
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        app_id, normalized_path, &tracker, &result_path));
+    PostTaskAndReplyWithResult(
+        worker_task_runner_,
+        FROM_HERE,
+        base::Bind(&MetadataDatabase::FindNearestActiveAncestor,
+                   base::Unretained(metadata_database()),
+                   app_id,
+                   normalized_path,
+                   &tracker,
+                   &result_path),
+        base::Bind(&SetValueAndCallClosure<bool>,
+                   run_loop.QuitClosure(),
+                   &success));
+    run_loop.Run();
+    EXPECT_TRUE(success);
     EXPECT_EQ(normalized_path, result_path);
     return tracker.file_id();
   }
 
   SyncStatusCode RegisterApp(const std::string& app_id) {
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     if (!ContainsKey(file_systems_, app_id)) {
       CannedSyncableFileSystem* file_system = new CannedSyncableFileSystem(
           origin, in_memory_env_.get(),
           io_task_runner_.get(), file_task_runner_.get());
       file_system->SetUp(CannedSyncableFileSystem::QUOTA_DISABLED);
 
       SyncStatusCode status = SYNC_STATUS_UNKNOWN;
       base::RunLoop run_loop;
       local_sync_service_->MaybeInitializeFileSystemContext(
           origin, file_system->file_system_context(),
-          base::Bind(&SetSyncStatus, run_loop.QuitClosure(), &status));
+          base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                     run_loop.QuitClosure(), &status));
       run_loop.Run();
       EXPECT_EQ(SYNC_STATUS_OK, status);
 
       file_system->backend()->sync_context()->
           set_mock_notify_changes_duration_in_sec(0);
 
       EXPECT_EQ(base::File::FILE_OK, file_system->OpenFileSystem());
       file_systems_[app_id] = file_system;
     }
 
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     base::RunLoop run_loop;
     remote_sync_service_->RegisterOrigin(
         origin,
-        base::Bind(&SetSyncStatus, run_loop.QuitClosure(), &status));
+        base::Bind(&SetValueAndCallClosure<SyncStatusCode>,
+                   run_loop.QuitClosure(), &status));
     run_loop.Run();
     return status;
   }
 
   void AddLocalFolder(const std::string& app_id,
                       const base::FilePath::StringType& path) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->CreateDirectory(
                   CreateURL(app_id, path)));
@@ skipping 81 matching lines @@
         return remote_sync_status;
 
       if (local_sync_status == SYNC_STATUS_NO_CHANGE_TO_SYNC &&
           remote_sync_status == SYNC_STATUS_NO_CHANGE_TO_SYNC) {
         remote_sync_service_->PromoteDemotedChanges();
         local_sync_service_->PromoteDemotedChanges();
 
         if (pending_remote_changes_ || pending_local_changes_)
           continue;
 
-        int64 largest_fetched_change_id =
-            metadata_database()->GetLargestFetchedChangeID();
+        base::RunLoop run_loop;
+        int64 largest_fetched_change_id = -1;
+        PostTaskAndReplyWithResult(
+            worker_task_runner_,
+            FROM_HERE,
+            base::Bind(&MetadataDatabase::GetLargestFetchedChangeID,
+                       base::Unretained(metadata_database())),
+            base::Bind(&SetValueAndCallClosure<int64>,
+                       run_loop.QuitClosure(),
+                       &largest_fetched_change_id));
+        run_loop.Run();
         if (largest_fetched_change_id != GetLargestChangeID()) {
           FetchRemoteChanges();
           continue;
         }
         break;
       }
     }
     return SYNC_STATUS_OK;
   }
 
@@ skipping 155 matching lines @@
                          const base::FilePath::StringType& path) {
     SCOPED_TRACE(testing::Message() << "Verifying local file: "
                                     << "app_id = " << app_id
                                     << ", path = " << path);
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->DirectoryExists(CreateURL(app_id, path)));
   }
 
   size_t CountMetadata() {
-    return metadata_database()->CountFileMetadata();
+    size_t count = 0;
+    base::RunLoop run_loop;
+    PostTaskAndReplyWithResult(
+        worker_task_runner_,
+        FROM_HERE,
+        base::Bind(&MetadataDatabase::CountFileMetadata,
+                   base::Unretained(metadata_database())),
+        base::Bind(&SetValueAndCallClosure<size_t>,
+                   run_loop.QuitClosure(),
+                   &count));
+    run_loop.Run();
+    return count;
   }
 
   size_t CountTracker() {
-    return metadata_database()->CountFileTracker();
+    size_t count = 0;
+    base::RunLoop run_loop;
+    PostTaskAndReplyWithResult(
+        worker_task_runner_,
+        FROM_HERE,
+        base::Bind(&MetadataDatabase::CountFileTracker,
+                   base::Unretained(metadata_database())),
+        base::Bind(&SetValueAndCallClosure<size_t>,
+                   run_loop.QuitClosure(), &count));
+    run_loop.Run();
+    return count;
   }
 
   drive::FakeDriveService* fake_drive_service() {
     return static_cast<drive::FakeDriveService*>(
         remote_sync_service_->GetDriveService());
   }
 
   FakeDriveServiceHelper* fake_drive_service_helper() {
     return fake_drive_service_helper_.get();
   }
 
+ private:
+  // NOTE: Member functions of MetadataDatabase class must not be called
+  // directly through this method.  Call them via PostTask.
   MetadataDatabase* metadata_database() {
-    return remote_sync_service_->GetMetadataDatabase();
+    return remote_sync_service_->sync_worker_->GetMetadataDatabase();
   }
 
- private:
   content::TestBrowserThreadBundle thread_bundle_;
 
   base::ScopedTempDir base_dir_;
   scoped_ptr<leveldb::Env> in_memory_env_;
   TestingProfile profile_;
 
   scoped_ptr<SyncEngine> remote_sync_service_;
   scoped_ptr<LocalFileSyncService> local_sync_service_;
 
   int64 pending_remote_changes_;
@@ skipping 1089 matching lines @@
 
   EXPECT_EQ(1u, CountApp());
   EXPECT_EQ(1u, CountLocalFile(app_id));
 
   EXPECT_EQ(2u, CountMetadata());
   EXPECT_EQ(2u, CountTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system