[SyncFS] Migrate ServiceMetadata from MDDB to MDDBIndex.

chrome/browser/sync_file_system/drive_backend/metadata_database.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 <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 277 matching lines @@
 
 SyncStatusCode WriteVersionInfo(leveldb::DB* db) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db);
   return LevelDBStatusToSyncStatusCode(
       db->Put(leveldb::WriteOptions(),
               kDatabaseVersionKey,
               base::Int64ToString(kCurrentDatabaseVersion)));
 }
 
-scoped_ptr<ServiceMetadata> ReadServiceMetadata(leveldb::DB* db) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(db);
-
-  std::string value;
-  leveldb::Status status = db->Get(leveldb::ReadOptions(),
-                                   kServiceMetadataKey,
-                                   &value);
-  if (!status.ok())
-    return scoped_ptr<ServiceMetadata>();
-
-  scoped_ptr<ServiceMetadata> service_metadata(new ServiceMetadata);
-  if (!service_metadata->ParseFromString(value)) {
-    util::Log(logging::LOG_WARNING, FROM_HERE,
-              "Failed to parse SyncServiceMetadata");
-    return scoped_ptr<ServiceMetadata>();
-  }
-  return service_metadata.Pass();
-}
-
-scoped_ptr<ServiceMetadata> InitializeServiceMetadata(
-    leveldb::DB* db, leveldb::WriteBatch* batch) {
-  scoped_ptr<ServiceMetadata> service_metadata = ReadServiceMetadata(db);
-  if (!service_metadata) {
-    service_metadata.reset(new ServiceMetadata);
-    service_metadata->set_next_tracker_id(1);
-
-    std::string value;
-    service_metadata->SerializeToString(&value);
-    if (batch)
-      batch->Put(kServiceMetadataKey, value);
-  }
-  return service_metadata.Pass();
-}
-
 bool HasInvalidTitle(const std::string& title) {
   return title.empty() ||
       title.find('/') != std::string::npos ||
       title.find('\\') != std::string::npos;
 }
 
 void MarkTrackerSetDirty(const TrackerIDSet& trackers,
                          MetadataDatabaseIndexInterface* index,
                          leveldb::WriteBatch* batch) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
@@ skipping 308 matching lines @@
   metadata_database.reset();
 
   file_task_runner->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(base::DeleteFile),
                  database_path, true /* recursive */));
 }
 
 int64 MetadataDatabase::GetLargestFetchedChangeID() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return service_metadata_->largest_change_id();
+  return index_->GetLargestChangeID();
 }
 
 int64 MetadataDatabase::GetSyncRootTrackerID() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return service_metadata_->sync_root_tracker_id();
+  return index_->GetSyncRootTrackerID();
 }
 
 int64 MetadataDatabase::GetLargestKnownChangeID() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_LE(GetLargestFetchedChangeID(), largest_known_change_id_);
   return largest_known_change_id_;
 }
 
 void MetadataDatabase::UpdateLargestKnownChangeID(int64 change_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   if (largest_known_change_id_ < change_id)
     largest_known_change_id_ = change_id;
 }
 
 bool MetadataDatabase::HasSyncRoot() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return service_metadata_->has_sync_root_tracker_id() &&
-      !!service_metadata_->sync_root_tracker_id();
+  return index_->GetSyncRootTrackerID() != kInvalidTrackerID;
 }
 
 void MetadataDatabase::PopulateInitialData(
     int64 largest_change_id,
     const google_apis::FileResource& sync_root_folder,
     const ScopedVector<google_apis::FileResource>& app_root_folders,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-  service_metadata_->set_largest_change_id(largest_change_id);
+  index_->SetLargestChangeID(largest_change_id, batch.get());
   UpdateLargestKnownChangeID(largest_change_id);
 
   AttachSyncRoot(sync_root_folder, batch.get());
   for (size_t i = 0; i < app_root_folders.size(); ++i)
     AttachInitialAppRoot(*app_root_folders[i], batch.get());
 
   WriteToDatabase(batch.Pass(), callback);
 }
 
 bool MetadataDatabase::IsAppEnabled(const std::string& app_id) const {
@@ skipping 33 matching lines @@
   if (trackers.has_active()) {
     // The folder is tracked by another tracker.
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Failed to register App for %s", app_id.c_str());
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_STATUS_HAS_CONFLICT));
     return;
   }
 
-  int64 sync_root_tracker_id = service_metadata_->sync_root_tracker_id();
+  int64 sync_root_tracker_id = index_->GetSyncRootTrackerID();
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
@@ skipping 244 matching lines @@
   }
 
   return true;
 }
 
 void MetadataDatabase::UpdateByChangeList(
     int64 largest_change_id,
     ScopedVector<google_apis::ChangeResource> changes,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  DCHECK_LE(service_metadata_->largest_change_id(), largest_change_id);
+  DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE,
                          batch.get());
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
-  service_metadata_->set_largest_change_id(largest_change_id);
-  PutServiceMetadataToBatch(*service_metadata_, batch.get());
+  index_->SetLargestChangeID(largest_change_id, batch.get());
   WriteToDatabase(batch.Pass(), callback);
 }
 
 void MetadataDatabase::UpdateByFileResource(
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
 
@@ skipping 479 matching lines @@
     status = WriteVersionInfo(db_.get());
     if (status != SYNC_STATUS_OK)
       return status;
   } else {
     status = MigrateDatabaseIfNeeded(db_.get());
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
   leveldb::WriteBatch batch;
-  service_metadata_ = InitializeServiceMetadata(db_.get(), &batch);
-  index_ = MetadataDatabaseIndex::Create(
-      db_.get(), service_metadata_->sync_root_tracker_id(), &batch);
+  index_ = MetadataDatabaseIndex::Create(db_.get(), &batch);
 
   status = LevelDBStatusToSyncStatusCode(
       db_->Write(leveldb::WriteOptions(), &batch));
   if (status != SYNC_STATUS_OK)
     return status;
 
-  UpdateLargestKnownChangeID(service_metadata_->largest_change_id());
+  UpdateLargestKnownChangeID(index_->GetLargestChangeID());
 
   return status;
 }
 
 void MetadataDatabase::CreateTrackerForParentAndFileID(
     const FileTracker& parent_tracker,
     const std::string& file_id,
     leveldb::WriteBatch* batch) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   CreateTrackerInternal(parent_tracker, file_id, NULL,
@@ skipping 87 matching lines @@
 
       CreateTrackerForParentAndFileMetadata(
           parent_tracker, metadata, option, batch);
     }
   }
 }
 
 int64 MetadataDatabase::IncrementTrackerID(leveldb::WriteBatch* batch) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  int64 tracker_id = service_metadata_->next_tracker_id();
-  service_metadata_->set_next_tracker_id(tracker_id + 1);
-  PutServiceMetadataToBatch(*service_metadata_, batch);
+  int64 tracker_id = index_->GetNextTrackerID();
+  index_->SetNextTrackerID(tracker_id + 1, batch);
   DCHECK_GT(tracker_id, 0);
   return tracker_id;
 }
 
 bool MetadataDatabase::CanActivateTracker(const FileTracker& tracker) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!tracker.active());
-  DCHECK_NE(service_metadata_->sync_root_tracker_id(), tracker.tracker_id());
+  DCHECK_NE(index_->GetSyncRootTrackerID(), tracker.tracker_id());
 
   if (HasActiveTrackerForFileID(tracker.file_id()))
     return false;
 
   if (tracker.app_id().empty() &&
       tracker.tracker_id() != GetSyncRootTrackerID()) {
     return false;
   }
 
   if (!tracker.has_synced_details())
@@ skipping 325 matching lines @@
     const google_apis::FileResource& sync_root_folder,
     leveldb::WriteBatch* batch) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<FileMetadata> sync_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), sync_root_folder);
   scoped_ptr<FileTracker> sync_root_tracker =
       CreateSyncRootTracker(IncrementTrackerID(batch), *sync_root_metadata);
 
-  service_metadata_->set_sync_root_tracker_id(sync_root_tracker->tracker_id());
-  PutServiceMetadataToBatch(*service_metadata_, batch);
-
+  index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id(), batch);
   index_->StoreFileMetadata(sync_root_metadata.Pass(), batch);
   index_->StoreFileTracker(sync_root_tracker.Pass(), batch);
 }
 
 void MetadataDatabase::AttachInitialAppRoot(
     const google_apis::FileResource& app_root_folder,
     leveldb::WriteBatch* batch) {
   scoped_ptr<FileMetadata> app_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), app_root_folder);
   scoped_ptr<FileTracker> app_root_tracker =
       CreateInitialAppRootTracker(IncrementTrackerID(batch),
                                   GetSyncRootTrackerID(),
                                   *app_root_metadata);
 
   index_->StoreFileMetadata(app_root_metadata.Pass(), batch);
   index_->StoreFileTracker(app_root_tracker.Pass(), batch);
 }
 
 void MetadataDatabase::DetachFromSequence() {
   worker_sequence_checker_.DetachFromSequence();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system