[SyncFS] Migrate ServiceMetadata from MDDB to MDDBIndex.

chrome/browser/sync_file_system/drive_backend/metadata_database_index.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 "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_restrictions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.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/logger.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 // LevelDB database schema
 // =======================
@@ skipping 172 matching lines @@
       PutFileMetadataDeletionToBatch(metadata->file_id(), batch);
     }
   }
   contents->file_metadata = referred_file_metadata.Pass();
 }
 
 }  // namespace
 
 // static
 scoped_ptr<MetadataDatabaseIndex>
-MetadataDatabaseIndex::Create(leveldb::DB* db,
-                              int64 sync_root_tracker_id,
-                              leveldb::WriteBatch* batch) {
+MetadataDatabaseIndex::Create(leveldb::DB* db, leveldb::WriteBatch* batch) {
+  DCHECK(db);
+  DCHECK(batch);
+
+  scoped_ptr<ServiceMetadata> service_metadata =
+      InitializeServiceMetadata(db, batch);
+
   DatabaseContents contents;
   ReadDatabaseContents(db, &contents);
-  RemoveUnreachableItems(&contents, sync_root_tracker_id, batch);
+  RemoveUnreachableItems(&contents,
+                         service_metadata->sync_root_tracker_id(),
+                         batch);
 
   scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex);
-  index->Initialize(&contents);
+  index->Initialize(service_metadata.Pass(), &contents);
   return index.Pass();
 }
 
 // static
 scoped_ptr<MetadataDatabaseIndex>
 MetadataDatabaseIndex::CreateForTesting(DatabaseContents* contents) {
   scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex);
-  index->Initialize(contents);
+  index->Initialize(scoped_ptr<ServiceMetadata>(new ServiceMetadata), contents);

[tzik, 2014/07/15 07:17:58]

can be make_scoped_ptr?

   return index.Pass();
 }
 
-void MetadataDatabaseIndex::Initialize(DatabaseContents* contents) {
+void MetadataDatabaseIndex::Initialize(
+    scoped_ptr<ServiceMetadata> service_metadata,
+    DatabaseContents* contents) {
+  service_metadata_ = service_metadata.Pass();
+
   for (size_t i = 0; i < contents->file_metadata.size(); ++i)
     StoreFileMetadata(make_scoped_ptr(contents->file_metadata[i]), NULL);
   contents->file_metadata.weak_clear();
 
   for (size_t i = 0; i < contents->file_trackers.size(); ++i)
     StoreFileTracker(make_scoped_ptr(contents->file_trackers[i]), NULL);
   contents->file_trackers.weak_clear();
 
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.MetadataNumber", metadata_by_id_.size());
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.TrackerNumber", tracker_by_id_.size());
@@ skipping 171 matching lines @@
 }
 
 size_t MetadataDatabaseIndex::CountFileMetadata() const {
   return metadata_by_id_.size();
 }
 
 size_t MetadataDatabaseIndex::CountFileTracker() const {
   return tracker_by_id_.size();
 }
 
+void MetadataDatabaseIndex::SetSyncRootTrackerID(
+    int64 sync_root_id, leveldb::WriteBatch* batch) const {
+  service_metadata_->set_sync_root_tracker_id(sync_root_id);
+  if (batch)
+    PutServiceMetadataToBatch(*service_metadata_, batch);
+}
+
+void MetadataDatabaseIndex::SetLargestChangeID(
+    int64 largest_change_id, leveldb::WriteBatch* batch) const {
+  service_metadata_->set_largest_change_id(largest_change_id);
+  if (batch)
+    PutServiceMetadataToBatch(*service_metadata_, batch);
+}
+
+void MetadataDatabaseIndex::SetNextTrackerID(
+    int64 next_tracker_id, leveldb::WriteBatch* batch) const {
+  service_metadata_->set_next_tracker_id(next_tracker_id);
+  if (batch)
+    PutServiceMetadataToBatch(*service_metadata_, batch);
+}
+
+int64 MetadataDatabaseIndex::GetSyncRootTrackerID() const {
+  if (!service_metadata_->has_sync_root_tracker_id())
+    return kInvalidTrackerID;
+  return service_metadata_->sync_root_tracker_id();
+}
+
+int64 MetadataDatabaseIndex::GetLargestChangeID() const {
+  if (!service_metadata_->has_largest_change_id())
+    return kInvalidTrackerID;
+  return service_metadata_->largest_change_id();
+}
+
+int64 MetadataDatabaseIndex::GetNextTrackerID() const {
+  if (!service_metadata_->has_next_tracker_id())
+    return kInvalidTrackerID;

[tzik, 2014/07/15 07:17:58]

could you put NOTREACHED for this case?

[peria, 2014/07/15 09:00:58]

Done.

+  return service_metadata_->next_tracker_id();
+}
+
 std::vector<std::string> MetadataDatabaseIndex::GetRegisteredAppIDs() const {
   std::vector<std::string> result;
   result.reserve(app_root_by_app_id_.size());
   for (TrackerIDByAppID::const_iterator itr = app_root_by_app_id_.begin();
        itr != app_root_by_app_id_.end(); ++itr)
     result.push_back(itr->first);
   return result;
 }
 
 std::vector<int64> MetadataDatabaseIndex::GetAllTrackerIDs() const {
@@ skipping 265 matching lines @@
 
     DVLOG(3) << "  Remove from dirty_trackers_: " << tracker_id;
     dirty_trackers_.erase(tracker_id);
 
     demoted_dirty_trackers_.erase(tracker_id);
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system