[SyncFS] Add generic result reciever

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.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 "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 #define FPL(a) FILE_PATH_LITERAL(a)
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 typedef MetadataDatabase::FileIDList FileIDList;
-
-using test_util::DatabaseCreateResultCallback;
-using test_util::SyncStatusResultCallback;
+using test_util::CreateResultReceiver;
 
 const int64 kInitialChangeID = 1234;
 const int64 kSyncRootTrackerID = 100;
 const char kSyncRootFolderID[] = "sync_root_folder_id";
 
 // This struct is used to setup initial state of the database in the test and
 // also used to match to the modified content of the database as the
 // expectation.
 struct TrackedFile {
   // Holds the latest remote metadata which may be not-yet-synced to |tracker|.
@@ skipping 125 matching lines @@
       EXPECT_FALSE(trackers.empty());
       return (*trackers.begin())->tracker_id();
     }
     return 0;
   }
 
   SyncStatusCode InitializeMetadataDatabase() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     MetadataDatabase::Create(base::MessageLoopProxy::current(),
                              database_dir_.path(),
-                             base::Bind(&DatabaseCreateResultCallback,
-                                        &status, &metadata_database_));
+                             CreateResultReceiver(&status,
+                                                  &metadata_database_));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   void DropDatabase() {
     metadata_database_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void SetUpDatabaseByTrackedFiles(const TrackedFile** tracked_files,
@@ skipping 313 matching lines @@
     SCOPED_TRACE("Expect equivalent tracker[" +
                  base::Int64ToString(tracker.tracker_id()) + "]");
     ExpectEquivalent(&tracker, &tracker_in_metadata_database);
   }
 
   SyncStatusCode RegisterApp(const std::string& app_id,
                              const std::string& folder_id) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->RegisterApp(
         app_id, folder_id,
-        base::Bind(&SyncStatusResultCallback, &status));
+        CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode DisableApp(const std::string& app_id) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->DisableApp(
-        app_id, base::Bind(&SyncStatusResultCallback, &status));
+        app_id, CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode EnableApp(const std::string& app_id) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->EnableApp(
-        app_id, base::Bind(&SyncStatusResultCallback, &status));
+        app_id, CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode UnregisterApp(const std::string& app_id) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->UnregisterApp(
-        app_id, base::Bind(&SyncStatusResultCallback, &status));
+        app_id, CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode UpdateByChangeList(
       ScopedVector<google_apis::ChangeResource> changes) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->UpdateByChangeList(
-        changes.Pass(), base::Bind(&SyncStatusResultCallback, &status));
+        changes.Pass(), CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode PopulateFolder(const std::string& folder_id,
                                 const FileIDList& listed_children) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->PopulateFolderByChildList(
         folder_id, listed_children,
-        base::Bind(&SyncStatusResultCallback, &status));
+        CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode UpdateTracker(const FileTracker& tracker) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->UpdateTracker(
         tracker.tracker_id(), tracker.synced_details(),
-        base::Bind(&SyncStatusResultCallback, &status));
+        CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   SyncStatusCode PopulateInitialData(
       int64 largest_change_id,
       const google_apis::FileResource& sync_root_folder,
       const ScopedVector<google_apis::FileResource>& app_root_folders) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     metadata_database_->PopulateInitialData(
         largest_change_id,
         sync_root_folder,
         app_root_folders,
-        base::Bind(&SyncStatusResultCallback, &status));
+        CreateResultReceiver(&status));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   void ResetTrackerID(FileTracker* tracker) {
     tracker->set_tracker_id(GetTrackerIDByFileID(tracker->file_id()));
   }
 
  private:
   base::ScopedTempDir database_dir_;
@@ skipping 387 matching lines @@
   ResetTrackerID(&sync_root.tracker);
   ResetTrackerID(&app_root.tracker);
   app_root.tracker.set_parent_tracker_id(sync_root.tracker.tracker_id());
 
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
   VerifyReloadConsistency();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system