[SyncFS] Remove a friendship between MetadataDatabase and MetadataDatabaseIndex

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 701 matching lines @@
   return service_metadata_->has_sync_root_tracker_id() &&
       !!service_metadata_->sync_root_tracker_id();
 }
 
 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());
-  DCHECK(index_->tracker_by_id_.empty());
-  DCHECK(index_->metadata_by_id_.empty());
 
   scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   service_metadata_->set_largest_change_id(largest_change_id);
   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);
@@ skipping 726 matching lines @@
   return index_->HasDemotedDirtyTracker();
 }
 
 bool MetadataDatabase::HasDirtyTracker() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->PickDirtyTracker() != kInvalidTrackerID;
 }
 
 size_t MetadataDatabase::CountDirtyTracker() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return index_->dirty_trackers_.size() +
-      index_->demoted_dirty_trackers_.size();
+  return index_->CountDirtyTracker();
 }
 
 bool MetadataDatabase::GetMultiParentFileTrackers(std::string* file_id_out,
                                                   TrackerIDSet* trackers_out) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(file_id_out);
   DCHECK(trackers_out);
 
   std::string file_id = index_->PickMultiTrackerFileID();
   if (file_id.empty())
     return false;
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (trackers.size() <= 1) {
     NOTREACHED();
     return false;
   }
 
   *file_id_out = file_id;
   std::swap(*trackers_out, trackers);
   return true;
 }
 
 size_t MetadataDatabase::CountFileMetadata() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return index_->metadata_by_id_.size();
+  return index_->CountFileMetadata();
 }
 
 size_t MetadataDatabase::CountFileTracker() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  return index_->tracker_by_id_.size();
+  return index_->CountFileTracker();
 }
 
 bool MetadataDatabase::GetConflictingTrackers(TrackerIDSet* trackers_out) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(trackers_out);
 
   ParentIDAndTitle parent_and_title = index_->PickMultiBackingFilePath();
   if (parent_and_title.parent_id == kInvalidTrackerID)
     return false;
 
@@ skipping 456 matching lines @@
   };
   std::vector<std::string> key_strings(
       trackerKeys, trackerKeys + ARRAYSIZE_UNSAFE(trackerKeys));
   base::ListValue* keys = new base::ListValue;
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Trackers");
   metadata->Set("keys", keys);
   trackers->Append(metadata);
 
   // Append tracker data.
-  for (MetadataDatabaseIndex::TrackerByID::const_iterator itr =
-           index_->tracker_by_id_.begin();
-       itr != index_->tracker_by_id_.end(); ++itr) {
-    const FileTracker& tracker = *itr->second;
+  std::vector<int64> tracker_ids(index_->GetAllTrackerIDs());
+  for (std::vector<int64>::const_iterator itr = tracker_ids.begin();
+       itr != tracker_ids.end(); ++itr) {
+    const int64 tracker_id = *itr;
+    const FileTracker* tracker = index_->GetFileTracker(tracker_id);
+    if (!tracker) {
+      NOTREACHED();
+      continue;
+    }
+
     base::DictionaryValue* dict = new base::DictionaryValue;
-    base::FilePath path = BuildDisplayPathForTracker(tracker);
-    dict->SetString("tracker_id", base::Int64ToString(tracker.tracker_id()));
+    base::FilePath path = BuildDisplayPathForTracker(*tracker);
+    dict->SetString("tracker_id", base::Int64ToString(tracker_id));
     dict->SetString("path", path.AsUTF8Unsafe());
-    dict->SetString("file_id", tracker.file_id());
-    TrackerKind tracker_kind = tracker.tracker_kind();
+    dict->SetString("file_id", tracker->file_id());
+    TrackerKind tracker_kind = tracker->tracker_kind();
     dict->SetString(
         "tracker_kind",
         tracker_kind == TRACKER_KIND_APP_ROOT ? "AppRoot" :
         tracker_kind == TRACKER_KIND_DISABLED_APP_ROOT ? "Disabled App" :
-        tracker.tracker_id() == GetSyncRootTrackerID() ? "SyncRoot" :
+        tracker->tracker_id() == GetSyncRootTrackerID() ? "SyncRoot" :
         "Regular");
-    dict->SetString("app_id", tracker.app_id());
-    dict->SetString("active", tracker.active() ? "true" : "false");
-    dict->SetString("dirty", tracker.dirty() ? "true" : "false");
+    dict->SetString("app_id", tracker->app_id());
+    dict->SetString("active", tracker->active() ? "true" : "false");
+    dict->SetString("dirty", tracker->dirty() ? "true" : "false");
     dict->SetString("folder_listing",
-                    tracker.needs_folder_listing() ? "needed" : "no");
-    if (tracker.has_synced_details()) {
-      const FileDetails& details = tracker.synced_details();
+                    tracker->needs_folder_listing() ? "needed" : "no");
+    if (tracker->has_synced_details()) {
+      const FileDetails& details = tracker->synced_details();
       dict->SetString("title", details.title());
       dict->SetString("kind", FileKindToString(details.file_kind()));
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
     }
     trackers->Append(dict);
   }
   return trackers.Pass();
@@ skipping 12 matching lines @@
   };
   std::vector<std::string> key_strings(
       fileKeys, fileKeys + ARRAYSIZE_UNSAFE(fileKeys));
   base::ListValue* keys = new base::ListValue;
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Metadata");
   metadata->Set("keys", keys);
   files->Append(metadata);
 
   // Append metadata data.
-  for (MetadataDatabaseIndex::MetadataByID::const_iterator itr =
-           index_->metadata_by_id_.begin();
-       itr != index_->metadata_by_id_.end(); ++itr) {
-    const FileMetadata& file = *itr->second;
+  std::vector<std::string> metadata_ids(index_->GetAllMetadataIDs());
+  for (std::vector<std::string>::const_iterator itr = metadata_ids.begin();
+       itr != metadata_ids.end(); ++itr) {
+    const std::string& file_id = *itr;
+    const FileMetadata *file = index_->GetFileMetadata(file_id);
+    if (!file) {
+      NOTREACHED();
+      continue;
+    }
 
     base::DictionaryValue* dict = new base::DictionaryValue;
-    dict->SetString("file_id", file.file_id());
-    if (file.has_details()) {
-      const FileDetails& details = file.details();
+    dict->SetString("file_id", file_id);
+    if (file->has_details()) {
+      const FileDetails& details = file->details();
       dict->SetString("title", details.title());
       dict->SetString("type", FileKindToString(details.file_kind()));
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
 
       std::vector<std::string> parents;
       for (int i = 0; i < details.parent_folder_ids_size(); ++i)
         parents.push_back(details.parent_folder_ids(i));
@@ skipping 42 matching lines @@
   index_->StoreFileMetadata(app_root_metadata.Pass());
   index_->StoreFileTracker(app_root_tracker.Pass());
 }
 
 void MetadataDatabase::DetachFromSequence() {
   worker_sequence_checker_.DetachFromSequence();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system