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_file_sync_service.h"
+#include "chrome/browser/sync_file_system/drive_file_sync_util.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/fileapi/file_system_url.h"
 #include "webkit/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 char kWapiFileIdPrefix[] = "file:";
+const char kWapiFolderIdPrefix[] = "folder:";
+
 const base::FilePath::CharType kV0FormatPathPrefix[] =
     FILE_PATH_LITERAL("drive/");
 
 bool ParseV0FormatFileSystemURLString(const GURL& url,
                                       GURL* origin,
                                       base::FilePath* path) {
   fileapi::FileSystemType mount_type;
   base::FilePath virtual_path;
 
   if (!fileapi::FileSystemURL::ParseFileSystemSchemeURL(
@@ skipping 35 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 AddWapiFilePrefix(const std::string& resource_id) {
+  if (resource_id.empty() ||
+      StartsWithASCII(resource_id, kWapiFileIdPrefix, true))
+    return resource_id;
+  return kWapiFileIdPrefix + resource_id;
+}
+
+std::string AddWapiFolderPrefix(const std::string& resource_id) {
+  if (resource_id.empty() ||
+      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);
+    default:
+      NOTREACHED();
+      return resource_id;
+  }
+}
+
+std::string RemoveWapiIdPrefix(const std::string& resource_id) {
+  if (StartsWithASCII(resource_id, kWapiFileIdPrefix, true))
+    return std::string(resource_id.begin() + arraysize(kWapiFileIdPrefix) - 1,
+                       resource_id.end());
+  if (StartsWithASCII(resource_id, kWapiFolderIdPrefix, true))
+    return std::string(resource_id.begin() + arraysize(kWapiFolderIdPrefix) - 1,
+                       resource_id.end());
+  return resource_id;
+}
+
 }  // namespace
 
 class DriveMetadataDB {
  public:
   enum OriginSyncType {
     BATCH_SYNC_ORIGIN,
     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 MigrateFromVersion1To2Database();
 
   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 294 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 388 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(
+            AddWapiIdPrefix(metadata.resource_id(), metadata.type()));
+      }
+
       success = contents->metadata_map[origin].insert(
           std::make_pair(path, metadata)).second;
       DCHECK(success);
     }
   }
 
   SyncStatusCode status = GetOrigins(&contents->batch_sync_origins,
                                      &contents->incremental_sync_origins,
                                      &contents->disabled_origins);
   if (status != SYNC_STATUS_OK &&
@@ skipping 17 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:
+      MigrateFromVersion1To2Database();
+      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;
     base::FilePath path;
     bool success = ParseV0FormatFileSystemURLString(
         GURL(serialized_url), &origin, &path);
     DCHECK(success) << serialized_url;
     std::string new_key = kDriveMetadataKeyPrefix + origin.spec() +
         kMetadataKeySeparator + path.AsUTF8Unsafe();
 
     write_batch.Put(new_key, itr->value());
     write_batch.Delete(key);
   }
   return LevelDBStatusToSyncStatusCode(
       db_->Write(leveldb::WriteOptions(), &write_batch));
 }
 
+SyncStatusCode DriveMetadataDB::MigrateFromVersion1To2Database() {
+  // 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: "BSYNC_ORIGIN: " + <URL string of a batch sync origin>
+  // * value: <Resource ID of the drive directory for the origin> (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)
+
+  leveldb::WriteBatch write_batch;
+  write_batch.Put(kDatabaseVersionKey, "2");
+
+  // Strip resource id for the sync root directory.
+  std::string sync_root_resource_id;
+  leveldb::Status status = db_->Get(
+      leveldb::ReadOptions(), kSyncRootDirectoryKey, &sync_root_resource_id);
+  write_batch.Put(kSyncRootDirectoryKey,
+                  RemoveWapiIdPrefix(sync_root_resource_id));
+
+  // Strip resource ids in the drive metadata.
+  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;
+
+    DriveMetadata metadata;
+    bool success = metadata.ParseFromString(itr->value().ToString());
+    DCHECK(success);
+
+    metadata.set_resource_id(RemoveWapiIdPrefix(metadata.resource_id()));
+
+    write_batch.Put(key, itr->value());
+  }
+
+  // Strip resource ids of the batch sync origins.
+  for (itr->Seek(kDriveBatchSyncOriginKeyPrefix);
+       itr->Valid(); itr->Next()) {
+    std::string key = itr->key().ToString();
+    if (!StartsWithASCII(key, kDriveBatchSyncOriginKeyPrefix, true))
+      break;
+
+    GURL origin(std::string(
+        key.begin() + arraysize(kDriveBatchSyncOriginKeyPrefix) - 1,
+        key.end()));
+    DCHECK(origin.is_valid());
+
+    write_batch.Put(CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN),
+                    RemoveWapiIdPrefix(itr->value().ToString()));
+  }
+
+  // Strip resource ids of the incremental sync origins.
+  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()));
+    DCHECK(origin.is_valid());
+
+    write_batch.Put(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN),
+                    RemoveWapiIdPrefix(itr->value().ToString()));
+  }
+
+  // Strip resource ids of the disabled sync origins.
+  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()));
+    DCHECK(origin.is_valid());
+
+    write_batch.Put(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN),
+                    RemoveWapiIdPrefix(itr->value().ToString()));
+  }
+
+  return LevelDBStatusToSyncStatusCode(
+      db_->Write(leveldb::WriteOptions(), &write_batch));
+}
+
 SyncStatusCode DriveMetadataDB::SetLargestChangestamp(
     int64 largest_changestamp) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::Status status = db_->Put(
       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,
+                                    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, 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 = 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(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::UpdateOriginAsBatchSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::Status status = db_->Put(
       leveldb::WriteOptions(),
       CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN),
-      resource_id);
+      RemoveWapiIdPrefix(resource_id));
   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, BATCH_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN),
-            resource_id);
+            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());
 
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
-  batch.Put(CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN), resource_id);
+  batch.Put(CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN),
+            RemoveWapiIdPrefix(resource_id));
   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, BATCH_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin_to_disable,
                                       INCREMENTAL_SYNC_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin_to_disable, DISABLED_ORIGIN),
-            resource_id);
+            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 46 matching lines @@
   // Get batch sync origins from the DB.
   for (itr->Seek(kDriveBatchSyncOriginKeyPrefix);
        itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveBatchSyncOriginKeyPrefix, true))
       break;
     GURL origin(std::string(
         key.begin() + arraysize(kDriveBatchSyncOriginKeyPrefix) - 1,
         key.end()));
     DCHECK(origin.is_valid());
+
+    std::string origin_resource_id =
+        IsDriveAPIEnabled() ? itr->value().ToString()
+                            : AddWapiFolderPrefix(itr->value().ToString());
+
     bool result = batch_sync_origins->insert(
-        std::make_pair(origin, itr->value().ToString())).second;
+        std::make_pair(origin, origin_resource_id)).second;
     DCHECK(result);
   }
 
   // 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()));
     DCHECK(origin.is_valid());
+
+    std::string origin_resource_id =
+        IsDriveAPIEnabled() ? itr->value().ToString()
+                            : 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()));
     DCHECK(origin.is_valid());
+
+    std::string origin_resource_id =
+        IsDriveAPIEnabled() ? itr->value().ToString()
+                            : 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