SyncFS: Convert WAPI ResourceID to DriveAPI FileID

chrome/browser/sync_file_system/drive_metadata_store.cc

 // Copyright (c) 2012 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_metadata_store.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
+#include "chrome/browser/sync_file_system/drive/metadata_db_migration_util.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_service.h"
+#include "chrome/browser/sync_file_system/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/fileapi/file_system_util.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 
 typedef DriveMetadataStore::ResourceIdByOrigin ResourceIdByOrigin;
 typedef DriveMetadataStore::OriginByResourceId OriginByResourceId;
 
 const base::FilePath::CharType DriveMetadataStore::kDatabaseName[] =
     FILE_PATH_LITERAL("DriveMetadata");
 
 namespace {
 
 const char* const kServiceName = DriveFileSyncService::kServiceName;
 const char kDatabaseVersionKey[] = "VERSION";
-const int64 kCurrentDatabaseVersion = 1;
+const int64 kCurrentDatabaseVersion = 2;
 const char kChangeStampKey[] = "CHANGE_STAMP";
 const char kSyncRootDirectoryKey[] = "SYNC_ROOT_DIR";
 const char kDriveMetadataKeyPrefix[] = "METADATA: ";
 const char kMetadataKeySeparator = ' ';
 const char kDriveBatchSyncOriginKeyPrefix[] = "BSYNC_ORIGIN: ";
 const char kDriveIncrementalSyncOriginKeyPrefix[] = "ISYNC_ORIGIN: ";
 const char kDriveDisabledOriginKeyPrefix[] = "DISABLED_ORIGIN: ";
 const size_t kDriveMetadataKeyPrefixLength = arraysize(kDriveMetadataKeyPrefix);
 
 const base::FilePath::CharType kV0FormatPathPrefix[] =
@@ skipping 44 matching lines @@
   ResourceIdByOrigin::iterator found = map->find(origin);
   if (found == map->end())
     return false;
   reverse_map->erase(found->second);
   reverse_map->insert(std::make_pair(resource_id, origin));
 
   found->second = resource_id;
   return true;
 }
 
+std::string RemovePrefix(const std::string& str, const std::string& prefix) {
+  if (StartsWithASCII(str, prefix, true))
+    return std::string(str.begin() + prefix.size(), str.end());

[tzik, 2013/05/29 04:30:24]

str.substr(prefix.size())?

[nhiroki, 2013/05/29 06:31:03]

Done.

+  return str;
+}
+
 }  // namespace
 
 class DriveMetadataDB {
  public:
   enum OriginSyncType {
     INCREMENTAL_SYNC_ORIGIN,
     DISABLED_ORIGIN
   };
 
   typedef DriveMetadataStore::MetadataMap MetadataMap;
 
   DriveMetadataDB(const base::FilePath& base_dir,
                   base::SequencedTaskRunner* task_runner);
   ~DriveMetadataDB();
 
   SyncStatusCode Initialize(bool* created);
   SyncStatusCode ReadContents(DriveMetadataDBContents* contents);
 
   SyncStatusCode MigrateDatabaseIfNeeded();
-  SyncStatusCode MigrateFromVersion0Database();
+  SyncStatusCode MigrateFromVersion0To1Database();
 
   SyncStatusCode SetLargestChangestamp(int64 largest_changestamp);
   SyncStatusCode SetSyncRootDirectory(const std::string& resource_id);
   SyncStatusCode GetSyncRootDirectory(std::string* resource_id);
   SyncStatusCode SetOriginRootDirectory(const GURL& origin,
                                         OriginSyncType sync_type,
                                         const std::string& resource_id);
   SyncStatusCode UpdateEntry(const FileSystemURL& url,
-                             const DriveMetadata& metadata);
+                             DriveMetadata metadata);
   SyncStatusCode DeleteEntry(const FileSystemURL& url);
 
   // TODO(calvinlo): consolidate these state transition functions for sync
   // origins like "UpdateOrigin(GURL, SyncStatusEnum)". And manage origins in
   // just one map like "Map<SyncStatusEnum, ResourceIDMap>".
   // http://crbug.com/211600
   SyncStatusCode UpdateOriginAsBatchSync(const GURL& origin,
                                          const std::string& resource_id);
   SyncStatusCode UpdateOriginAsIncrementalSync(const GURL& origin,
                                                const std::string& resource_id);
@@ skipping 288 matching lines @@
 
   if (found->second.erase(url.path()) == 1) {
     base::PostTaskAndReplyWithResult(
         file_task_runner_, FROM_HERE,
         base::Bind(&DriveMetadataDB::DeleteEntry,
                    base::Unretained(db_.get()), url),
         base::Bind(&DriveMetadataStore::UpdateDBStatusAndInvokeCallback,
                    AsWeakPtr(), callback));
     return;
   }
+
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
 }
 
 SyncStatusCode DriveMetadataStore::ReadEntry(const FileSystemURL& url,
                                              DriveMetadata* metadata) const {
   DCHECK(CalledOnValidThread());
   DCHECK(metadata);
 
@@ skipping 353 matching lines @@
       DCHECK(success);
     } else if (StartsWithASCII(key, kDriveMetadataKeyPrefix, true)) {
       GURL origin;
       base::FilePath path;
       MetadataKeyToOriginAndPath(key, &origin, &path);
 
       DriveMetadata metadata;
       bool success = metadata.ParseFromString(itr->value().ToString());
       DCHECK(success);
 
+      if (!IsDriveAPIEnabled()) {
+        metadata.set_resource_id(
+            drive::AddWapiIdPrefix(metadata.resource_id(), metadata.type()));
+      }
+
       success = contents->metadata_map[origin].insert(
           std::make_pair(path, metadata)).second;
       DCHECK(success);
     }
   }
 
   SyncStatusCode status = GetOrigins(&contents->incremental_sync_origins,
                                      &contents->disabled_origins);
   if (status != SYNC_STATUS_OK &&
       status != SYNC_DATABASE_ERROR_NOT_FOUND)
@@ skipping 16 matching lines @@
     bool success = base::StringToInt64(itr->value().ToString(),
                                        &database_version);
     if (!success)
       return SYNC_DATABASE_ERROR_FAILED;
     if (database_version > kCurrentDatabaseVersion)
       return SYNC_DATABASE_ERROR_FAILED;
     if (database_version == kCurrentDatabaseVersion)
       return SYNC_STATUS_OK;
   }
 
-  if (database_version == 0) {
-    MigrateFromVersion0Database();
-    return SYNC_STATUS_OK;
+  switch (database_version) {
+    case 0:
+      MigrateFromVersion0To1Database();
+      // fall-through
+    case 1:
+      drive::MigrateDatabaseFromV1ToV2(db_.get());
+      return SYNC_STATUS_OK;
   }
   return SYNC_DATABASE_ERROR_FAILED;
 }
 
-SyncStatusCode DriveMetadataDB::MigrateFromVersion0Database() {
+SyncStatusCode DriveMetadataDB::MigrateFromVersion0To1Database() {
   // Version 0 database format:
   //   key: "CHANGE_STAMP"
   //   value: <Largest Changestamp>
   //
   //   key: "SYNC_ROOT_DIR"
   //   value: <Resource ID of the sync root directory>
   //
   //   key: "METADATA: " +
   //        <FileSystemURL serialized by SerializeSyncableFileSystemURL>
   //   value: <Serialized DriveMetadata>
@@ skipping 20 matching lines @@
   //   key: "BSYNC_ORIGIN: " + <URL string of a batch sync origin>
   //   value: <Resource ID of the drive directory for the origin>
   //
   //   key: "ISYNC_ORIGIN: " + <URL string of a incremental sync origin>
   //   value: <Resource ID of the drive directory for the origin>
   //
   //   key: "DISABLED_ORIGIN: " + <URL string of a disabled origin>
   //   value: <Resource ID of the drive directory for the origin>
 
   leveldb::WriteBatch write_batch;
-  write_batch.Put(kDatabaseVersionKey,
-                  base::Int64ToString(kCurrentDatabaseVersion));
+  write_batch.Put(kDatabaseVersionKey, "1");
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(kDriveMetadataKeyPrefix); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveMetadataKeyPrefix, true))
       break;
     std::string serialized_url(
         key.begin() + kDriveMetadataKeyPrefixLength - 1, key.end());
 
     GURL origin;
@@ skipping 20 matching lines @@
       leveldb::WriteOptions(),
       kChangeStampKey, base::Int64ToString(largest_changestamp));
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::SetSyncRootDirectory(
     const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
-  leveldb::Status status = db_->Put(
-      leveldb::WriteOptions(), kSyncRootDirectoryKey, resource_id);
+  leveldb::Status status = db_->Put(leveldb::WriteOptions(),
+                                    kSyncRootDirectoryKey,
+                                    drive::RemoveWapiIdPrefix(resource_id));
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::SetOriginRootDirectory(
     const GURL& origin,
     OriginSyncType sync_type,
     const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   std::string key = CreateKeyForOriginRoot(origin, sync_type);
   if (key.empty())
     return SYNC_DATABASE_ERROR_FAILED;
 
-  leveldb::Status status = db_->Put(leveldb::WriteOptions(), key, resource_id);
+  leveldb::Status status = db_->Put(
+      leveldb::WriteOptions(), key, drive::RemoveWapiIdPrefix(resource_id));
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::GetSyncRootDirectory(std::string* resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::Status status = db_->Get(
       leveldb::ReadOptions(), kSyncRootDirectoryKey, resource_id);
+
+  if (!IsDriveAPIEnabled() && status.ok())
+    *resource_id = drive::AddWapiFolderPrefix(*resource_id);
+
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::UpdateEntry(const FileSystemURL& url,
-                                            const DriveMetadata& metadata) {
+                                            DriveMetadata metadata) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
+  if (!IsDriveAPIEnabled()) {
+    metadata.set_resource_id(
+        drive::RemoveWapiIdPrefix(metadata.resource_id()));
+  }
+
   std::string metadata_key = FileSystemURLToMetadataKey(url);
   std::string value;
   bool success = metadata.SerializeToString(&value);
   DCHECK(success);
   leveldb::Status status  = db_->Put(
       leveldb::WriteOptions(), metadata_key, value);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::DeleteEntry(const FileSystemURL& url) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   std::string metadata_key = FileSystemURLToMetadataKey(url);
   leveldb::Status status = db_->Delete(
       leveldb::WriteOptions(), metadata_key);
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::UpdateOriginAsIncrementalSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN),
-            resource_id);
+            drive::RemoveWapiIdPrefix(resource_id));
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::EnableOrigin(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   // No DB entry as enabled origins go back to
   // DriveFileSyncService.pending_batch_sync_origins only.
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::DisableOrigin(
     const GURL& origin_to_disable, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForOriginRoot(origin_to_disable,
                                       INCREMENTAL_SYNC_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin_to_disable, DISABLED_ORIGIN),
-            resource_id);
+            drive::RemoveWapiIdPrefix(resource_id));
 
   // Remove entries specified by |origin_to_disable|.
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   std::string metadata_key = kDriveMetadataKeyPrefix + origin_to_disable.spec();
   for (itr->Seek(metadata_key); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveMetadataKeyPrefix, true))
       break;
     GURL origin;
     base::FilePath path;
@@ skipping 40 matching lines @@
   DCHECK(db_.get());
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 
   // Get incremental sync origins from the DB.
   for (itr->Seek(kDriveIncrementalSyncOriginKeyPrefix);
        itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveIncrementalSyncOriginKeyPrefix, true))
       break;
-    GURL origin(std::string(
-        key.begin() + arraysize(kDriveIncrementalSyncOriginKeyPrefix) - 1,
-        key.end()));
+    GURL origin(RemovePrefix(key, kDriveIncrementalSyncOriginKeyPrefix));
     DCHECK(origin.is_valid());
+
+    std::string origin_resource_id = IsDriveAPIEnabled()
+        ? itr->value().ToString()
+        : drive::AddWapiFolderPrefix(itr->value().ToString());
+
     bool result = incremental_sync_origins->insert(
-        std::make_pair(origin, itr->value().ToString())).second;
+        std::make_pair(origin, origin_resource_id)).second;
     DCHECK(result);
   }
 
   // Get disabled origins from the DB.
   for (itr->Seek(kDriveDisabledOriginKeyPrefix);
        itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveDisabledOriginKeyPrefix, true))
       break;
-    GURL origin(std::string(
-        key.begin() + arraysize(kDriveDisabledOriginKeyPrefix) - 1,
-        key.end()));
+    GURL origin(RemovePrefix(key, kDriveDisabledOriginKeyPrefix));
     DCHECK(origin.is_valid());
+
+    std::string origin_resource_id = IsDriveAPIEnabled()
+        ? itr->value().ToString()
+        : drive::AddWapiFolderPrefix(itr->value().ToString());
+
     bool result = disabled_origins->insert(
-        std::make_pair(origin, itr->value().ToString())).second;
+        std::make_pair(origin, origin_resource_id)).second;
     DCHECK(result);
   }
 
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system