[SyncFS] Implement MetadataDatabase initialization

chrome/browser/sync_file_system/drive_backend/metadata_database.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_
 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_
 
+#include <map>
+
 #include "base/callback_forward.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "webkit/browser/fileapi/syncable/sync_callbacks.h"
 #include "webkit/browser/fileapi/syncable/sync_status_code.h"
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 }
 
 namespace leveldb {
 class DB;
 class WriteBatch;
 }
 
 namespace google_apis {
 class ChangeResource;
 class FileResource;
 class ResourceEntry;
 }
 
 namespace sync_file_system {
 namespace drive_backend {
 
 class ServiceMetadata;
 class DriveFileMetadata;
-struct InitializeInfo;
 
 // This class holds a snapshot of the server side metadata.
 class MetadataDatabase {
  public:
+  struct FileIDComparator {

[kinuko, 2013/07/04 15:59:11]

can't these typenames be kept private?

[tzik, 2013/07/05 07:42:28]

Done.

+    bool operator()(DriveFileMetadata* left, DriveFileMetadata* right);
+  };
+
+  typedef std::set<DriveFileMetadata*, FileIDComparator> FileSet;
+  typedef std::map<std::string, DriveFileMetadata*> FileByFileID;
+  typedef std::map<std::string, FileSet> FilesByParent;
+  typedef std::map<std::pair<std::string, std::string>, DriveFileMetadata*>
+      FileByParentAndTitle;
+  typedef std::map<std::string, DriveFileMetadata*> FileByAppID;
+
+  struct InitializeInfo {
+    SyncStatusCode status;
+    scoped_ptr<leveldb::DB> db;
+
+    scoped_ptr<ServiceMetadata> service_metadata;
+    ScopedVector<DriveFileMetadata> file_metadata;
+
+    FileByFileID file_by_file_id;
+    FilesByParent files_by_parent;
+    FileByAppID app_root_by_app_id;
+    FileByParentAndTitle active_file_by_parent_and_title;

[kinuko, 2013/07/04 15:59:11]

Is there a chance we could simplify some initialization code if we drop these
four fields and db, make ConstructDataStructure non-static, and directly
populate the MetadataDatabase's corresponding fields?

[tzik, 2013/07/05 07:42:28]

Done.

+
+    bool created;
+
+    InitializeInfo();
+    ~InitializeInfo();
+  };
+
   explicit MetadataDatabase(base::SequencedTaskRunner* task_runner);
   ~MetadataDatabase();
 
   // Initializes the internal database and loads its content to memory.
   // This function works asynchronously.

[kinuko, 2013/07/04 15:59:11]

nit: its async-ness seems obvious from the signature

[tzik, 2013/07/05 07:42:28]

Done.

   void Initialize(const base::FilePath& database_path,
                   const SyncStatusCallback& callback);
 
   int64 GetLargestChangeID() const;
 
   // Registers existing folder as the app-root for |app_id|.  The folder
   // must be an inactive folder that does not yet associated to any App.
   // This method associates the folder with |app_id| and activates it.
   void RegisterApp(const std::string& app_id,
                    const std::string& folder_id,
@@ skipping 62 matching lines @@
   void UpdateByChangeList(ScopedVector<google_apis::ChangeResource> changes,
                           const SyncStatusCallback& callback);
 
   // Populates |folder| with |children|.  Each |children| initially has empty
   // |synced_details| and |remote_details|.
   void PopulateFolder(const std::string& folder_id,
                       ScopedVector<google_apis::ResourceEntry> children,
                       const SyncStatusCallback& callback);
 
  private:
+  friend class SyncFS_MetadataDatabaseTest;
+
+  static const char* kDatabaseVersionKey;
+  static const int64 kCurrentDatabaseVersion;
+  static const char* kServiceMetadataKey;
+  static const char* kFileMetadataKeyPrefix;
+
+  static scoped_ptr<leveldb::DB> OpenDatabase(
+      const base::FilePath& path,
+      SyncStatusCode* status,
+      bool* created);
+  static SyncStatusCode WriteInitialData(leveldb::DB* db);
+  static SyncStatusCode MigrateDatabaseIfNeeded(leveldb::DB* db);
+  static SyncStatusCode ReadDatabaseContents(leveldb::DB* db,
+                                             InitializeInfo* info);
+  static SyncStatusCode ConstructDataStructure(InitializeInfo* info,
+                                               leveldb::WriteBatch* batch);
+  static scoped_ptr<InitializeInfo> InitializeOnWorker(
+      const base::FilePath& db_path);
+
+  void WriteToDB(scoped_ptr<leveldb::WriteBatch> batch,

[kinuko, 2013/07/04 15:59:11]

Do you want to use Database or DB in methods names?  OpenDatabase uses Database.

[tzik, 2013/07/05 07:42:28]

Changed to WriteToDatabase. I prefer using Database.

+                 const SyncStatusCallback& callback);
+
+  void DidInitialize(const SyncStatusCallback& callback,
+                     scoped_ptr<InitializeInfo> contents);
+
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  scoped_ptr<leveldb::DB> db_;
+
+  scoped_ptr<ServiceMetadata> service_metadata_;
+  FileByFileID file_by_file_id_;  // Owned.
+
+  FilesByParent files_by_parent_;  // Not owned.
+  FileByAppID app_root_by_app_id_;  // Not owned.
+  FileByParentAndTitle active_file_by_parent_and_title_;  // Not owned.
+
+  base::WeakPtrFactory<MetadataDatabase> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabase);
 };
 
 }  // namespace drive_backend
 }  // namespace sync_file_system
 
 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_METADATA_DATABASE_H_