SyncFS: Convert WAPI ResourceID to DriveAPI FileID

To migrate SyncFS from WAPI to DriveAPI, this change adds utility functions to
convert from/to WAPI ResourceID to/from DriveAPI FileID as below, and replaces
WAPI ResourceIDs stored in DriveMetadataDB with DriveAPI FileIDs using
DB migration mechanism (DB schema version: 1 -> 2).

(WAPI) "file:xxxx" <=> "xxxx" (DriveAPI)
(WAPI) "folder:yyyy" <=> "yyyy" (DriveAPI)

When using WAPI (i.e. IsDriveAPIEnabled() returns false), DriveMetadataDB
passes ResourceIDs re-converted from FileIDs to DriveMetadataStore so that the
SyncFS can use migrated DB contents on WAPI.


BUG=234557
TEST=unit_tests --gtest_filter=\*DriveMetadataDBMigrationUtilTest\*

Review URL: https://chromiumcodereview.appspot.com/15808002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@202858 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync_file_system/drive/metadata_db_migration_util.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/metadata_db_migration_util.h"
+
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/string_util.h"
+#include "googleurl/src/gurl.h"
+#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
+
+namespace sync_file_system {
+namespace drive {
+
+namespace {
+
+const char kWapiFileIdPrefix[] = "file:";
+const char kWapiFolderIdPrefix[] = "folder:";
+
+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());
+  return str;
+}
+
+}  // namespace
+
+std::string AddWapiFilePrefix(const std::string& resource_id) {
+  DCHECK(!StartsWithASCII(resource_id, kWapiFileIdPrefix, true));
+  DCHECK(!StartsWithASCII(resource_id, kWapiFolderIdPrefix, true));
+
+  if (resource_id.empty() ||
+      StartsWithASCII(resource_id, kWapiFileIdPrefix, true) ||
+      StartsWithASCII(resource_id, kWapiFolderIdPrefix, true))
+    return resource_id;
+  return kWapiFileIdPrefix + resource_id;
+}
+
+std::string AddWapiFolderPrefix(const std::string& resource_id) {
+  DCHECK(!StartsWithASCII(resource_id, kWapiFileIdPrefix, true));
+  DCHECK(!StartsWithASCII(resource_id, kWapiFolderIdPrefix, true));
+
+  if (resource_id.empty() ||
+      StartsWithASCII(resource_id, kWapiFileIdPrefix, true) ||
+      StartsWithASCII(resource_id, kWapiFolderIdPrefix, true))
+    return resource_id;
+  return kWapiFolderIdPrefix + resource_id;
+}
+
+std::string AddWapiIdPrefix(const std::string& resource_id,
+                            DriveMetadata_ResourceType type) {
+  switch (type) {
+    case DriveMetadata_ResourceType_RESOURCE_TYPE_FILE:
+      return AddWapiFilePrefix(resource_id);
+    case DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER:
+      return AddWapiFolderPrefix(resource_id);
+  }
+  NOTREACHED();
+  return resource_id;
+}
+
+std::string RemoveWapiIdPrefix(const std::string& resource_id) {
+  if (StartsWithASCII(resource_id, kWapiFileIdPrefix, true))
+    return RemovePrefix(resource_id, kWapiFileIdPrefix);
+  if (StartsWithASCII(resource_id, kWapiFolderIdPrefix, true))
+    return RemovePrefix(resource_id, kWapiFolderIdPrefix);
+  return resource_id;
+}
+
+SyncStatusCode MigrateDatabaseFromV1ToV2(leveldb::DB* db) {
+  // Strips prefix of WAPI resource ID.
+  // (i.e. "file:xxxx" => "xxxx", "folder:yyyy" => "yyyy")
+  //
+  // Version 2 database format (changed keys/fields are marked with '*'):
+  //   key: "VERSION"
+  // * value: 2
+  //
+  //   key: "CHANGE_STAMP"
+  //   value: <Largest Changestamp>
+  //
+  //   key: "SYNC_ROOT_DIR"
+  // * value: <Resource ID of the sync root directory> (striped)
+  //
+  //   key: "METADATA: " + <Origin and URL>
+  // * value: <Serialized DriveMetadata> (striped)
+  //
+  //   key: "ISYNC_ORIGIN: " + <URL string of a incremental sync origin>
+  // * value: <Resource ID of the drive directory for the origin> (striped)
+  //
+  //   key: "DISABLED_ORIGIN: " + <URL string of a disabled origin>
+  // * value: <Resource ID of the drive directory for the origin> (striped)
+
+  const char kDatabaseVersionKey[] = "VERSION";
+  const char kSyncRootDirectoryKey[] = "SYNC_ROOT_DIR";
+  const char kDriveMetadataKeyPrefix[] = "METADATA: ";
+  const char kDriveIncrementalSyncOriginKeyPrefix[] = "ISYNC_ORIGIN: ";
+  const char kDriveDisabledOriginKeyPrefix[] = "DISABLED_ORIGIN: ";
+
+  leveldb::WriteBatch write_batch;
+  write_batch.Put(kDatabaseVersionKey, "2");
+
+  scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
+  for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
+    std::string key = itr->key().ToString();
+
+    // Strip resource id for the sync root directory.
+    if (StartsWithASCII(key, kSyncRootDirectoryKey, true)) {
+      write_batch.Put(key, RemoveWapiIdPrefix(itr->value().ToString()));
+      continue;
+    }
+
+    // Strip resource ids in the drive metadata.
+    if (StartsWithASCII(key, kDriveMetadataKeyPrefix, true)) {
+      DriveMetadata metadata;
+      bool success = metadata.ParseFromString(itr->value().ToString());
+      DCHECK(success);
+
+      metadata.set_resource_id(RemoveWapiIdPrefix(metadata.resource_id()));
+      std::string metadata_string;
+      metadata.SerializeToString(&metadata_string);
+
+      write_batch.Put(key, metadata_string);
+      continue;
+    }
+
+    // Strip resource ids of the incremental sync origins.
+    if (StartsWithASCII(key, kDriveIncrementalSyncOriginKeyPrefix, true)) {
+      write_batch.Put(key, RemoveWapiIdPrefix(itr->value().ToString()));
+      continue;
+    }
+
+    // Strip resource ids of the disabled sync origins.
+    if (StartsWithASCII(key, kDriveDisabledOriginKeyPrefix, true)) {
+      write_batch.Put(key, RemoveWapiIdPrefix(itr->value().ToString()));
+      continue;
+    }
+  }
+
+  return LevelDBStatusToSyncStatusCode(
+      db->Write(leveldb::WriteOptions(), &write_batch));
+}
+
+}  // namespace drive
+}  // namespace sync_file_system

chrome/browser/sync_file_system/drive/metadata_db_migration_util.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_METADATA_DB_MIGRATION_UTIL_H_
+#define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_METADATA_DB_MIGRATION_UTIL_H_
+
+#include <string>
+
+#include "chrome/browser/sync_file_system/sync_file_system.pb.h"
+#include "third_party/leveldatabase/src/include/leveldb/db.h"
+#include "webkit/browser/fileapi/syncable/sync_status_code.h"
+
+namespace sync_file_system {
+namespace drive {
+
+// Adds "file:" prefix to WAPI resource ID.
+// EXAMPLE:  "xxx" => "file:xxx"
+std::string AddWapiFilePrefix(const std::string& resource_id);
+
+// Adds "folder:" prefix to WAPI resource ID.
+// EXAMPLE:  "xxx" => "folder:xxx"
+std::string AddWapiFolderPrefix(const std::string& resource_id);
+
+// Adds a prefix corresponding to the given |type|.
+std::string AddWapiIdPrefix(const std::string& resource_id,
+                            DriveMetadata_ResourceType type);
+
+// Removes a prefix from WAPI resource ID.
+// EXAMPLE:
+//   "file:xxx"    =>  "xxx"
+//   "folder:yyy"  =>  "yyy"
+//   "zzz"         =>  "zzz"
+std::string RemoveWapiIdPrefix(const std::string& resource_id);
+
+// Migrate |db| scheme from version 1 to version 2.
+SyncStatusCode MigrateDatabaseFromV1ToV2(leveldb::DB* db);
+
+}  // namespace drive
+}  // namespace sync_file_system
+
+#endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_METADATA_DB_MIGRATION_UTIL_H_

chrome/browser/sync_file_system/drive/metadata_db_migration_util_unittest.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/metadata_db_migration_util.h"
+
+#include "base/files/scoped_temp_dir.h"
+#include "base/string_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/sync_file_system/drive_metadata_store.h"
+#include "googleurl/src/gurl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/leveldatabase/src/include/leveldb/db.h"
+#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
+#include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
+#include "webkit/common/fileapi/file_system_util.h"
+
+#define FPL FILE_PATH_LITERAL
+
+namespace sync_file_system {
+namespace drive {
+
+TEST(DriveMetadataDBMigrationUtilTest, AddWapiIdPrefix) {
+  DriveMetadata_ResourceType type_file =
+      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE;
+  DriveMetadata_ResourceType type_folder =
+      DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER;
+
+  EXPECT_EQ("file:xxx", AddWapiFilePrefix("xxx"));
+  EXPECT_EQ("folder:yyy", AddWapiFolderPrefix("yyy"));
+  EXPECT_EQ("file:xxx", AddWapiIdPrefix("xxx", type_file));
+  EXPECT_EQ("folder:yyy", AddWapiIdPrefix("yyy", type_folder));
+
+  EXPECT_EQ("", AddWapiFilePrefix(""));
+  EXPECT_EQ("", AddWapiFolderPrefix(""));
+  EXPECT_EQ("", AddWapiIdPrefix("", type_file));
+  EXPECT_EQ("", AddWapiIdPrefix("", type_folder));
+}
+
+TEST(DriveMetadataDBMigrationUtilTest, RemoveWapiIdPrefix) {
+  EXPECT_EQ("xxx", RemoveWapiIdPrefix("xxx"));
+  EXPECT_EQ("yyy", RemoveWapiIdPrefix("file:yyy"));
+  EXPECT_EQ("zzz", RemoveWapiIdPrefix("folder:zzz"));
+
+  EXPECT_EQ("", RemoveWapiIdPrefix(""));
+  EXPECT_EQ("foo:xxx", RemoveWapiIdPrefix("foo:xxx"));
+}
+
+TEST(DriveMetadataDBMigrationUtilTest, MigrationFromV1) {
+  const char kDatabaseVersionKey[] = "VERSION";
+  const char kChangeStampKey[] = "CHANGE_STAMP";
+  const char kSyncRootDirectoryKey[] = "SYNC_ROOT_DIR";
+  const char kDriveMetadataKeyPrefix[] = "METADATA: ";
+  const char kMetadataKeySeparator = ' ';
+  const char kDriveIncrementalSyncOriginKeyPrefix[] = "ISYNC_ORIGIN: ";
+  const char kDriveDisabledOriginKeyPrefix[] = "DISABLED_ORIGIN: ";
+
+  const GURL kOrigin1("chrome-extension://example1");
+  const GURL kOrigin2("chrome-extension://example2");
+
+  const std::string kSyncRootResourceId("folder:sync_root_resource_id");
+  const std::string kResourceId1("folder:hoge");
+  const std::string kResourceId2("folder:fuga");
+  const std::string kFileResourceId("file:piyo");
+  const base::FilePath kFile(FPL("foo bar"));
+  const std::string kFileMD5("file_md5");
+
+  const char kV1ServiceName[] = "drive";
+  ASSERT_TRUE(RegisterSyncableFileSystem(kV1ServiceName));
+
+  base::ScopedTempDir base_dir;
+  ASSERT_TRUE(base_dir.CreateUniqueTempDir());
+
+  leveldb::Options options;
+  options.create_if_missing = true;
+  leveldb::DB* db_ptr = NULL;
+  std::string db_dir = fileapi::FilePathToString(
+      base_dir.path().Append(DriveMetadataStore::kDatabaseName));
+  leveldb::Status status = leveldb::DB::Open(options, db_dir, &db_ptr);
+
+  scoped_ptr<leveldb::DB> db(db_ptr);
+  ASSERT_TRUE(status.ok());
+
+  // Setup the database with the scheme version 1.
+  leveldb::WriteBatch batch;
+  batch.Put(kDatabaseVersionKey, "1");
+  batch.Put(kChangeStampKey, "1");
+  batch.Put(kSyncRootDirectoryKey, kSyncRootResourceId);
+
+  fileapi::FileSystemURL url =
+      CreateSyncableFileSystemURL(kOrigin1, kV1ServiceName, kFile);
+
+  // Setup drive metadata.
+  DriveMetadata drive_metadata;
+  drive_metadata.set_resource_id(kFileResourceId);
+  drive_metadata.set_md5_checksum(kFileMD5);
+  drive_metadata.set_conflicted(false);
+  drive_metadata.set_to_be_fetched(false);
+  std::string metadata_string;
+  drive_metadata.SerializeToString(&metadata_string);
+  std::string metadata_key = kDriveMetadataKeyPrefix + kOrigin1.spec() +
+                             kMetadataKeySeparator + url.path().AsUTF8Unsafe();
+  batch.Put(metadata_key, metadata_string);
+
+  // Setup incremental sync origin and disabled origin.
+  batch.Put(kDriveIncrementalSyncOriginKeyPrefix + kOrigin1.spec(),
+            kResourceId1);
+  batch.Put(kDriveDisabledOriginKeyPrefix + kOrigin2.spec(),
+            kResourceId2);
+
+  status = db->Write(leveldb::WriteOptions(), &batch);
+  EXPECT_EQ(SYNC_STATUS_OK, LevelDBStatusToSyncStatusCode(status));
+  EXPECT_TRUE(RevokeSyncableFileSystem(kV1ServiceName));
+
+  // Migrate the database.
+  drive::MigrateDatabaseFromV1ToV2(db.get());
+
+  scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
+
+  // Verify DB scheme version.
+  int64 database_version = 0;
+  itr->Seek(kDatabaseVersionKey);
+  EXPECT_TRUE(itr->Valid());
+  EXPECT_TRUE(base::StringToInt64(itr->value().ToString(), &database_version));
+  EXPECT_EQ(2, database_version);
+
+  // Verify the sync root directory.
+  itr->Seek(kSyncRootDirectoryKey);
+  EXPECT_TRUE(itr->Valid());
+  EXPECT_EQ(RemoveWapiIdPrefix(kSyncRootResourceId), itr->value().ToString());
+
+  // Verify the metadata.
+  itr->Seek(kDriveMetadataKeyPrefix);
+  EXPECT_TRUE(itr->Valid());
+  DriveMetadata metadata;
+  EXPECT_TRUE(metadata.ParseFromString(itr->value().ToString()));
+  EXPECT_EQ(RemoveWapiIdPrefix(kFileResourceId), metadata.resource_id());
+  EXPECT_EQ(kFileMD5, metadata.md5_checksum());
+  EXPECT_FALSE(metadata.conflicted());
+  EXPECT_FALSE(metadata.to_be_fetched());
+
+  // Verify the incremental sync origin.
+  itr->Seek(kDriveIncrementalSyncOriginKeyPrefix);
+  EXPECT_TRUE(itr->Valid());
+  EXPECT_EQ(RemoveWapiIdPrefix(kResourceId1), itr->value().ToString());
+
+  // Verify the disabled origin.
+  itr->Seek(kDriveDisabledOriginKeyPrefix);
+  EXPECT_TRUE(itr->Valid());
+  EXPECT_EQ(RemoveWapiIdPrefix(kResourceId2), itr->value().ToString());
+}
+
+}  // namespace drive
+}  // namespace sync_file_system

chrome/browser/sync_file_system/drive_file_sync_service_sync_unittest.cc

@@ -24,8 +24,8 @@ namespace sync_file_system {
 
 namespace {
 
-const char kSyncRootResourceId[] = "sync_root_resource_id";
-const char kParentResourceId[] = "parent_resource_id";
+const char kSyncRootResourceId[] = "folder:sync_root_resource_id";
+const char kParentResourceId[] = "folder:parent_resource_id";
 const char kAppId[] = "app-id";
 const char kAppOrigin[] = "chrome-extension://app-id";
 
@@ -198,8 +198,19 @@ class DriveFileSyncServiceSyncTest : public testing::Test {
     std::pair<iterator, bool> inserted =
         resources_.insert(std::make_pair(title, std::string()));
     if (inserted.second) {
-      inserted.first->second =
-          base::StringPrintf("%" PRId64, ++resource_count_);
+      switch (type) {
+        case SYNC_FILE_TYPE_UNKNOWN:
+          NOTREACHED();
+          break;
+        case SYNC_FILE_TYPE_FILE:
+          inserted.first->second =
+              base::StringPrintf("file:%" PRId64, ++resource_count_);
+          break;
+        case SYNC_FILE_TYPE_DIRECTORY:
+          inserted.first->second =
+              base::StringPrintf("folder:%" PRId64, ++resource_count_);
+          break;
+      }
     }
     std::string resource_id = inserted.first->second;
     std::string md5_checksum;

chrome/browser/sync_file_system/drive_metadata_store.cc

@@ -17,7 +17,9 @@
 #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"
@@ -41,7 +43,7 @@ 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: ";
@@ -106,6 +108,12 @@ bool UpdateResourceIdMap(ResourceIdByOrigin* map,
   return true;
 }
 
+std::string RemovePrefix(const std::string& str, const std::string& prefix) {
+  if (StartsWithASCII(str, prefix, true))
+    return str.substr(prefix.size());
+  return str;
+}
+
 }  // namespace
 
 class DriveMetadataDB {
@@ -125,7 +133,7 @@ class DriveMetadataDB {
   SyncStatusCode ReadContents(DriveMetadataDBContents* contents);
 
   SyncStatusCode MigrateDatabaseIfNeeded();
-  SyncStatusCode MigrateFromVersion0Database();
+  SyncStatusCode MigrateFromVersion0To1Database();
 
   SyncStatusCode SetLargestChangestamp(int64 largest_changestamp);
   SyncStatusCode SetSyncRootDirectory(const std::string& resource_id);
@@ -134,7 +142,7 @@ class DriveMetadataDB {
                                         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
@@ -443,6 +451,7 @@ void DriveMetadataStore::DeleteEntry(
                    AsWeakPtr(), callback));
     return;
   }
+
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
@@ -816,6 +825,11 @@ SyncStatusCode DriveMetadataDB::ReadContents(
       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);
@@ -852,14 +866,18 @@ SyncStatusCode DriveMetadataDB::MigrateDatabaseIfNeeded() {
       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>
@@ -900,8 +918,7 @@ SyncStatusCode DriveMetadataDB::MigrateFromVersion0Database() {
   //   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()) {
@@ -942,8 +959,9 @@ SyncStatusCode DriveMetadataDB::SetSyncRootDirectory(
   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);
 }
 
@@ -958,7 +976,8 @@ SyncStatusCode DriveMetadataDB::SetOriginRootDirectory(
   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);
 }
 
@@ -968,14 +987,23 @@ SyncStatusCode DriveMetadataDB::GetSyncRootDirectory(std::string* resource_id) {
 
   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);
@@ -1004,7 +1032,7 @@ SyncStatusCode DriveMetadataDB::UpdateOriginAsIncrementalSync(
   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);
@@ -1034,7 +1062,7 @@ SyncStatusCode DriveMetadataDB::DisableOrigin(
   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()));
@@ -1095,12 +1123,15 @@ SyncStatusCode DriveMetadataDB::GetOrigins(
     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);
   }
 
@@ -1110,12 +1141,15 @@ SyncStatusCode DriveMetadataDB::GetOrigins(
     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);
   }
 

chrome/browser/sync_file_system/drive_metadata_store_unittest.cc

@@ -12,12 +12,15 @@
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.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/sync_file_system.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
+#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 
@@ -330,7 +333,7 @@ TEST_F(DriveMetadataStoreTest, ReadWriteTest) {
   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND,
             metadata_store()->ReadEntry(url, &metadata));
 
-  metadata = CreateMetadata("1234567890", "09876543210", true, false);
+  metadata = CreateMetadata("file:1234567890", "09876543210", true, false);
   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(url, metadata));
   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 
@@ -413,7 +416,7 @@ TEST_F(DriveMetadataStoreTest, GetToBeFetchedFilessTest) {
 }
 
 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) {
-  const std::string kResourceId("hoge");
+  const std::string kResourceId("folder:hoge");
 
   InitializeDatabase();
 
@@ -434,8 +437,8 @@ TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) {
 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
-  const std::string kResourceId1("hoge");
-  const std::string kResourceId2("fuga");
+  const std::string kResourceId1("folder:hoge");
+  const std::string kResourceId2("folder:fuga");
 
   InitializeDatabase();
 
@@ -545,9 +548,9 @@ TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
   const GURL kOrigin3("chrome-extension://example3");
-  const std::string kResourceId1("hogera");
-  const std::string kResourceId2("fugaga");
-  const std::string kResourceId3("piyopiyo");
+  const std::string kResourceId1("folder:hogera");
+  const std::string kResourceId2("folder:fugaga");
+  const std::string kResourceId3("folder:piyopiyo");
 
   InitializeDatabase();
   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
@@ -588,10 +591,10 @@ TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) {
 TEST_F(DriveMetadataStoreTest, MigrationFromV0) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
-  const std::string kSyncRootResourceId("sync_root_resource_id");
-  const std::string kResourceId1("hoge");
-  const std::string kResourceId2("fuga");
-  const std::string kFileResourceId("piyo");
+  const std::string kSyncRootResourceId("folder:sync_root_resource_id");
+  const std::string kResourceId1("folder:hoge");
+  const std::string kResourceId2("folder:fuga");
+  const std::string kFileResourceId("file:piyo");
   const base::FilePath kFile(FPL("foo bar"));
   const std::string kFileMD5("file_md5");
 

chrome/chrome_browser.gypi

@@ -2120,6 +2120,8 @@
         'browser/sync_file_system/drive/api_util_interface.h',
         'browser/sync_file_system/drive/local_change_processor_delegate.cc',
         'browser/sync_file_system/drive/local_change_processor_delegate.h',
+        'browser/sync_file_system/drive/metadata_db_migration_util.cc',
+        'browser/sync_file_system/drive/metadata_db_migration_util.h',
         'browser/sync_file_system/drive_file_sync_service.cc',
         'browser/sync_file_system/drive_file_sync_service.h',
         'browser/sync_file_system/drive_file_sync_task_manager.cc',

chrome/chrome_tests_unit.gypi

@@ -1233,6 +1233,7 @@
         'browser/sync_file_system/drive/fake_api_util.cc',
         'browser/sync_file_system/drive/fake_api_util.h',
         'browser/sync_file_system/drive/fake_api_util_unittest.cc',
+        'browser/sync_file_system/drive/metadata_db_migration_util_unittest.cc',
         'browser/sync_file_system/drive_file_sync_service_mock_unittest.cc',
         'browser/sync_file_system/drive_file_sync_service_sync_unittest.cc',
         'browser/sync_file_system/drive_file_sync_service_unittest.cc',