Move storage-related files from webkit/ to new top-level directory storage/

chrome/browser/sync_file_system/drive_backend/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_backend/metadata_db_migration_util.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.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 "url/gurl.h"
-#include "webkit/browser/fileapi/external_mount_points.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/browser/fileapi/external_mount_points.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 #define FPL FILE_PATH_LITERAL
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 const char kV0ServiceName[] = "drive";
 
 bool CreateV0SerializedSyncableFileSystemURL(
     const GURL& origin,
     const base::FilePath& path,
     std::string* serialized_url) {
-  fileapi::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
-      kV0ServiceName, fileapi::kFileSystemTypeSyncable,
-      fileapi::FileSystemMountOption(), base::FilePath());
-  fileapi::FileSystemURL url =
-      fileapi::ExternalMountPoints::GetSystemInstance()->
-          CreateExternalFileSystemURL(origin, kV0ServiceName, path);
-  fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+  storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+      kV0ServiceName,
+      storage::kFileSystemTypeSyncable,
+      storage::FileSystemMountOption(),
+      base::FilePath());
+  storage::FileSystemURL url =
+      storage::ExternalMountPoints::GetSystemInstance()
+          ->CreateExternalFileSystemURL(origin, kV0ServiceName, path);
+  storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
       kV0ServiceName);
 
   if (!url.is_valid())
     return false;
-  *serialized_url = fileapi::GetExternalFileSystemRootURIString(
-        origin, kV0ServiceName) + url.path().AsUTF8Unsafe();
+  *serialized_url =
+      storage::GetExternalFileSystemRootURIString(origin, kV0ServiceName) +
+      url.path().AsUTF8Unsafe();
   return true;
 }
 
 void VerifyKeyAndValue(const std::string& key,
                        const std::string& expect_val,
                        leveldb::DB* db) {
   scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
 
   itr->Seek(key);
   EXPECT_TRUE(itr->Valid());
@@ skipping 68 matching lines @@
   const base::FilePath kFile(FPL("foo bar"));
   const std::string kFileMD5("file_md5");
 
   base::ScopedTempDir base_dir;
   ASSERT_TRUE(base_dir.CreateUniqueTempDir());
 
   leveldb::Options options;
   options.create_if_missing = true;
   options.max_open_files = 0;  // Use minimum.
   leveldb::DB* db_ptr = NULL;
-  std::string db_dir = fileapi::FilePathToString(
+  std::string db_dir = storage::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 schema version 0.
   leveldb::WriteBatch batch;
   batch.Put(kChangeStampKey, "1");
   batch.Put(kSyncRootDirectoryKey, kSyncRootResourceId);
@@ skipping 88 matching lines @@
   const std::string kFileMD5("file_md5");
 
   RegisterSyncableFileSystem();
 
   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(
+  std::string db_dir = storage::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 schema version 1.
   leveldb::WriteBatch batch;
   batch.Put(kDatabaseVersionKey, "1");
   batch.Put(kChangeStampKey, "1");
   batch.Put(kSyncRootDirectoryKey, kSyncRootResourceId);
 
-  fileapi::FileSystemURL url = CreateSyncableFileSystemURL(kOrigin1, kFile);
+  storage::FileSystemURL url = CreateSyncableFileSystemURL(kOrigin1, 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() +
@@ skipping 83 matching lines @@
   const char kDemotedDirtyIDKeyPrefix[] = "DEMOTED_DIRTY: ";
 
   // Set up environment.
   leveldb::DB* db_ptr = NULL;
   {
     base::ScopedTempDir base_dir;
     ASSERT_TRUE(base_dir.CreateUniqueTempDir());
 
     leveldb::Options options;
     options.create_if_missing = true;
-    std::string db_dir = fileapi::FilePathToString(
+    std::string db_dir = storage::FilePathToString(
         base_dir.path().Append(DriveMetadataStore::kDatabaseName));
     leveldb::Status status = leveldb::DB::Open(options, db_dir, &db_ptr);
     ASSERT_TRUE(status.ok());
   }
   scoped_ptr<leveldb::DB> db(db_ptr);
 
   // Setup the database with the schema version 4, without IDs.
   leveldb::WriteBatch batch;
   batch.Put(kDatabaseVersionKey, "4");
   batch.Put(kServiceMetadataKey, "service_metadata");
@@ skipping 30 matching lines @@
   VerifyNotExist(kMultiTrackerByFileIDKeyPrefix, db.get());
   VerifyNotExist(kActiveTrackerIDByParentAndTitleKeyPrefix, db.get());
   VerifyNotExist(kTrackerIDByParentAndTitleKeyPrefix, db.get());
   VerifyNotExist(kMultiBackingParentAndTitleKeyPrefix, db.get());
   VerifyNotExist(kDirtyIDKeyPrefix, db.get());
   VerifyNotExist(kDemotedDirtyIDKeyPrefix, db.get());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system