Add 'Dump Database' tab to syncfs-internals (only for v2 for now)

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 738 matching lines @@
         !current.active())
       return false;
   }
 
   if (path)
     *path = ReverseConcatPathComponents(components);
 
   return true;
 }
 
+base::FilePath MetadataDatabase::BuildDisplayPathForTracker(
+    const FileTracker& tracker) const {
+  base::FilePath path;
+  if (tracker.active()) {
+    BuildPathForTracker(tracker.tracker_id(), &path);
+    return path;
+  }
+  BuildPathForTracker(tracker.parent_tracker_id(), &path);
+  if (tracker.has_synced_details()) {
+    path = path.Append(
+        base::FilePath::FromUTF8Unsafe(tracker.synced_details().title()));
+  } else {
+    path = path.Append(FILE_PATH_LITERAL("<unknown>"));
+  }
+  return path;
+}
+
 bool MetadataDatabase::FindNearestActiveAncestor(
     const std::string& app_id,
     const base::FilePath& full_path,
     FileTracker* tracker,
     base::FilePath* path) const {
   DCHECK(tracker);
   DCHECK(path);
 
   if (full_path.IsAbsolute() ||
       !FindAppRootTracker(app_id, tracker) ||
@@ skipping 971 matching lines @@
         std::back_inserter(stack));
   while (!stack.empty()) {
     int64 tracker_id = stack.back();
     stack.pop_back();
     PushChildTrackersToContainer(
         trackers_by_parent_and_title_, tracker_id, std::back_inserter(stack));
 
     FileTracker* tracker = tracker_by_id_[tracker_id];
     base::DictionaryValue* file = new DictionaryValue;
 
-    base::FilePath path;
-    if (tracker->active()) {
-      BuildPathForTracker(tracker->tracker_id(), &path);
-    } else {
-      BuildPathForTracker(tracker->parent_tracker_id(), &path);
-      if (tracker->has_synced_details()) {
-        path = path.Append(
-            base::FilePath::FromUTF8Unsafe(tracker->synced_details().title()));
-      } else {
-        path = path.Append(FILE_PATH_LITERAL("unknown"));
-      }
-    }
+    base::FilePath path = BuildDisplayPathForTracker(*tracker);
     file->SetString("path", path.AsUTF8Unsafe());
     if (tracker->has_synced_details()) {
       file->SetString("title", tracker->synced_details().title());
       file->SetString("type",
                       FileKindToString(tracker->synced_details().file_kind()));
     }
 
     base::DictionaryValue* details = new DictionaryValue;
     details->SetString("file_id", tracker->file_id());
     if (tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FILE)
       details->SetString("md5", tracker->synced_details().md5());
     details->SetString("active", tracker->active() ? "true" : "false");
     details->SetString("dirty", tracker->dirty() ? "true" : "false");
 
     file->Set("details", details);
 
     files->Append(file);
   }
 
   return files.Pass();
 }
 
+scoped_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
+  scoped_ptr<base::ListValue> list(new base::ListValue);
+  list->Append(DumpTrackers().release());
+  list->Append(DumpMetadata().release());
+  return list.Pass();
+}
+
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
                                             int64 change_id) {
   FileByID::const_iterator found = file_by_id_.find(file_id);
   if (found == file_by_id_.end())
     return false;
   DCHECK(found->second->has_details());
   return found->second->details().change_id() >= change_id;
 }
 
+scoped_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
+  scoped_ptr<base::ListValue> trackers(new base::ListValue);
+
+  // Append the first element for metadata.
+  base::DictionaryValue* metadata = new DictionaryValue;
+  const char *trackerKeys[] = {
+    "tracker_id", "path", "file_id", "tracker_kind", "app_id",
+    "active", "dirty", "folder_listing",
+    "title", "kind", "md5", "etag", "missing", "change_id",
+  };
+  std::vector<std::string> key_strings(
+      trackerKeys, trackerKeys + ARRAYSIZE_UNSAFE(trackerKeys));
+  base::ListValue* keys = new ListValue;
+  keys->AppendStrings(key_strings);
+  metadata->SetString("title", "Trackers");
+  metadata->Set("keys", keys);
+  trackers->Append(metadata);
+
+  // Append tracker data.
+  for (TrackerByID::const_iterator itr = tracker_by_id_.begin();
+       itr != tracker_by_id_.end(); ++itr) {
+    const FileTracker& tracker = *itr->second;
+    base::DictionaryValue* dict = new DictionaryValue;
+    base::FilePath path = BuildDisplayPathForTracker(tracker);
+    dict->SetString("tracker_id", base::Int64ToString(tracker.tracker_id()));
+    dict->SetString("path", path.AsUTF8Unsafe());
+    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" :
+        "Regular");
+    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();
+      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();
+}
+
+scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
+  scoped_ptr<base::ListValue> files(new base::ListValue);
+
+  // Append the first element for metadata.
+  base::DictionaryValue* metadata = new DictionaryValue;
+  const char *fileKeys[] = {
+    "file_id", "title", "type", "md5", "etag", "missing",
+    "change_id", "parents"
+  };
+  std::vector<std::string> key_strings(
+      fileKeys, fileKeys + ARRAYSIZE_UNSAFE(fileKeys));
+  base::ListValue* keys = new ListValue;
+  keys->AppendStrings(key_strings);
+  metadata->SetString("title", "Metadata");
+  metadata->Set("keys", keys);
+  files->Append(metadata);
+
+  // Append metadata data.
+  for (FileByID::const_iterator itr = file_by_id_.begin();
+       itr != file_by_id_.end(); ++itr) {
+    const FileMetadata& file = *itr->second;
+
+    base::DictionaryValue* dict = new DictionaryValue;
+    dict->SetString("file_id", file.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));
+      dict->SetString("parents", JoinString(parents, ","));
+    }
+    files->Append(dict);
+  }
+  return files.Pass();
+}
+
 }  // namespace drive_backend
 }  // namespace sync_file_system