Change fileapi namespace to content for files that are moved under content/

content/browser/fileapi/obfuscated_file_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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 16 matching lines @@
 #include "webkit/browser/fileapi/sandbox_directory_database.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/browser/fileapi/test_file_set.h"
 #include "webkit/browser/quota/mock_special_storage_policy.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/database/database_identifier.h"
 #include "webkit/common/quota/quota_types.h"
 
-namespace fileapi {
+using fileapi::AsyncFileTestHelper;
+using fileapi::FileSystemContext;
+using fileapi::FileSystemOperation;
+using fileapi::FileSystemOperationContext;
+using fileapi::FileSystemType;
+using fileapi::FileSystemURL;
+using fileapi::ObfuscatedFileUtil;
+using fileapi::SandboxDirectoryDatabase;
+using fileapi::SandboxIsolatedOriginDatabase;
+using fileapi::kFileSystemTypeTemporary;
+using fileapi::kFileSystemTypePersistent;
+
+namespace content {
 
 namespace {
 
 bool FileExists(const base::FilePath& path) {
   return base::PathExists(path) && !base::DirectoryExists(path);
 }
 
 int64 GetSize(const base::FilePath& path) {
   int64 size;
   EXPECT_TRUE(base::GetFileSize(path, &size));
@@ skipping 55 matching lines @@
 FileSystemURL FileSystemURLAppendUTF8(
     const FileSystemURL& url, const std::string& child) {
   return FileSystemURL::CreateForTest(
       url.origin(),
       url.mount_type(),
       url.virtual_path().Append(base::FilePath::FromUTF8Unsafe(child)));
 }
 
 FileSystemURL FileSystemURLDirName(const FileSystemURL& url) {
   return FileSystemURL::CreateForTest(
-      url.origin(), url.mount_type(), VirtualPath::DirName(url.virtual_path()));
+      url.origin(), url.mount_type(),
+      fileapi::VirtualPath::DirName(url.virtual_path()));
 }
 
 std::string GetTypeString(FileSystemType type) {
-  return SandboxFileSystemBackendDelegate::GetTypeString(type);
+  return fileapi::SandboxFileSystemBackendDelegate::GetTypeString(type);
 }
 
 bool HasFileSystemType(
     ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
     FileSystemType type) {
   return enumerator->HasTypeDirectory(GetTypeString(type));
 }
 
 }  // namespace
 
 // TODO(ericu): The vast majority of this and the other FSFU subclass tests
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
 class ObfuscatedFileUtilTest : public testing::Test {
  public:
   ObfuscatedFileUtilTest()
       : origin_(GURL("http://www.example.com")),
-        type_(kFileSystemTypeTemporary),
+        type_(fileapi::kFileSystemTypeTemporary),
         weak_factory_(this),
         sandbox_file_system_(origin_, type_),
         quota_status_(quota::kQuotaStatusUnknown),
         usage_(-1) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     storage_policy_ = new quota::MockSpecialStoragePolicy();
 
     quota_manager_ =
         new quota::QuotaManager(false /* is_incognito */,
                                 data_dir_.path(),
                                 base::MessageLoopProxy::current().get(),
                                 base::MessageLoopProxy::current().get(),
                                 storage_policy_.get());
 
     // Every time we create a new sandbox_file_system helper,
     // it creates another context, which creates another path manager,
     // another sandbox_backend, and another OFU.
     // We need to pass in the context to skip all that.
     file_system_context_ = CreateFileSystemContextForTesting(
         quota_manager_->proxy(),
         data_dir_.path());
 
     sandbox_file_system_.SetUp(file_system_context_.get());
 
-    change_observers_ = MockFileChangeObserver::CreateList(&change_observer_);
+    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
+        &change_observer_);
   }
 
   virtual void TearDown() {
     quota_manager_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
   scoped_ptr<FileSystemOperationContext> LimitedContext(
       int64 allowed_bytes_growth) {
     scoped_ptr<FileSystemOperationContext> context(
@@ skipping 13 matching lines @@
     if (file_system)
       context = file_system->NewOperationContext();
     else
       context = sandbox_file_system_.NewOperationContext();
     // Setting allowed_bytes_growth big enough for all tests.
     context->set_allowed_bytes_growth(1024 * 1024);
     context->set_change_observers(change_observers());
     return context;
   }
 
-  const ChangeObserverList& change_observers() const {
+  const fileapi::ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
-  MockFileChangeObserver* change_observer() {
+  fileapi::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
   // This can only be used after SetUp has run and created file_system_context_
   // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
   SandboxFileSystemTestHelper* NewFileSystem(
       const GURL& origin, fileapi::FileSystemType type) {
     SandboxFileSystemTestHelper* file_system =
         new SandboxFileSystemTestHelper(origin, type);
 
     file_system->SetUp(file_system_context_.get());
     return file_system;
   }
 
+  scoped_ptr<ObfuscatedFileUtil> CreateObfuscatedFileUtil(
+      quota::SpecialStoragePolicy* storage_policy) {
+    return scoped_ptr<ObfuscatedFileUtil>(
+      ObfuscatedFileUtil::CreateForTesting(
+          storage_policy, data_dir_path(),
+          base::MessageLoopProxy::current().get()));
+  }
+
   ObfuscatedFileUtil* ofu() {
     return static_cast<ObfuscatedFileUtil*>(sandbox_file_system_.file_util());
   }
 
   const base::FilePath& test_directory() const {
     return data_dir_.path();
   }
 
   const GURL& origin() const {
     return origin_;
@@ skipping 46 matching lines @@
     base::PlatformFileError error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::PLATFORM_FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     return AsyncFileTestHelper::DirectoryExists(file_system_context(), url);
   }
 
   int64 usage() const { return usage_; }
-  FileSystemUsageCache* usage_cache() {
+  fileapi::FileSystemUsageCache* usage_cache() {
     return sandbox_file_system_.usage_cache();
   }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
     return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
   int64 PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
@@ skipping 123 matching lines @@
     int64 usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth - 1), &sandbox_file_system_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<DirectoryEntry> entries;
+    std::vector<fileapi::DirectoryEntry> entries;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
                   file_system_context(), root_url, &entries));
     EXPECT_EQ(0UL, entries.size());
 
     files->clear();
     files->insert(FILE_PATH_LITERAL("first"));
     files->insert(FILE_PATH_LITERAL("second"));
     files->insert(FILE_PATH_LITERAL("third"));
     directories->clear();
@@ skipping 23 matching lines @@
     }
     ValidateTestDirectory(root_url, *files, *directories);
   }
 
   void TestReadDirectoryHelper(const FileSystemURL& root_url) {
     std::set<base::FilePath::StringType> files;
     std::set<base::FilePath::StringType> directories;
     FillTestDirectory(root_url, &files, &directories);
 
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<DirectoryEntry> entries;
+    std::vector<fileapi::DirectoryEntry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
                   file_system_context(), root_url, &entries));
-    std::vector<DirectoryEntry>::iterator entry_iter;
+    std::vector<fileapi::DirectoryEntry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     EXPECT_TRUE(change_observer()->HasNoChange());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
         ++entry_iter) {
-      const DirectoryEntry& entry = *entry_iter;
+      const fileapi::DirectoryEntry& entry = *entry_iter;
       std::set<base::FilePath::StringType>::iterator iter =
           files.find(entry.name);
       if (iter != files.end()) {
         EXPECT_FALSE(entry.is_directory);
         files.erase(iter);
         continue;
       }
       iter = directories.find(entry.name);
       EXPECT_FALSE(directories.end() == iter);
       EXPECT_TRUE(entry.is_directory);
@@ skipping 160 matching lines @@
                                     src_file_url, dest_file_url,
                                     FileSystemOperation::OPTION_NONE,
                                     copy));
     if (copy)
       EXPECT_EQ(base::Time(), GetModifiedTime(src_dir_url));
     else
       EXPECT_NE(base::Time(), GetModifiedTime(src_dir_url));
     EXPECT_NE(base::Time(), GetModifiedTime(dest_dir_url));
   }
 
+  void MaybeDropDatabasesAliveCaseTestBody() {
+    scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(NULL);
+    file_util->InitOriginDatabase(GURL(), true /*create*/);
+    ASSERT_TRUE(file_util->origin_database_ != NULL);
+
+    // Callback to Drop DB is called while ObfuscatedFileUtilTest is
+    // still alive.
+    file_util->db_flush_delay_seconds_ = 0;
+    file_util->MarkUsed();
+    base::RunLoop().RunUntilIdle();
+
+    ASSERT_TRUE(file_util->origin_database_ == NULL);
+  }
+
+  void MaybeDropDatabasesAlreadyDeletedCaseTestBody() {
+    // Run message loop after OFU is already deleted to make sure callback
+    // doesn't cause a crash for use after free.
+    {
+      scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(NULL);
+      file_util->InitOriginDatabase(GURL(), true /*create*/);
+      file_util->db_flush_delay_seconds_ = 0;
+      file_util->MarkUsed();
+    }
+
+    // At this point the callback is still in the message queue but OFU is gone.
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void DestroyDirectoryDatabase_IsolatedTestBody() {
+    storage_policy_->AddIsolated(origin_);
+    scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(
+        storage_policy_.get());
+    const FileSystemURL url = FileSystemURL::CreateForTest(
+        origin_, kFileSystemTypePersistent, base::FilePath());
+
+    // Create DirectoryDatabase for isolated origin.
+    SandboxDirectoryDatabase* db =
+        file_util->GetDirectoryDatabase(url, true /* create */);
+    ASSERT_TRUE(db != NULL);
+
+    // Destory it.
+    ASSERT_TRUE(file_util->DestroyDirectoryDatabase(
+        url.origin(), GetTypeString(url.type())));
+    ASSERT_TRUE(file_util->directories_.empty());
+  }
+
+  void GetDirectoryDatabase_IsolatedTestBody() {
+    storage_policy_->AddIsolated(origin_);
+    scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(
+        storage_policy_.get());
+    const FileSystemURL url = FileSystemURL::CreateForTest(
+        origin_, kFileSystemTypePersistent, base::FilePath());
+
+    // Create DirectoryDatabase for isolated origin.
+    SandboxDirectoryDatabase* db =
+        file_util->GetDirectoryDatabase(url, true /* create */);
+    ASSERT_TRUE(db != NULL);
+    ASSERT_EQ(1U, file_util->directories_.size());
+
+    // Remove isolated.
+    storage_policy_->RemoveIsolated(url.origin());
+
+    // This should still get the same database.
+    SandboxDirectoryDatabase* db2 =
+        file_util->GetDirectoryDatabase(url, false /* create */);
+    ASSERT_EQ(db, db2);
+  }
+
+  void MigrationBackFromIsolatedTestBody() {
+    std::string kFakeDirectoryData("0123456789");
+    base::FilePath old_directory_db_path;
+
+    // Initialize the directory with one origin using
+    // SandboxIsolatedOriginDatabase.
+    {
+      std::string origin_string =
+          webkit_database::GetIdentifierFromOrigin(origin_);
+      SandboxIsolatedOriginDatabase database_old(
+          origin_string, data_dir_path(),
+          base::FilePath(
+              SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory));
+      base::FilePath path;
+      EXPECT_TRUE(database_old.GetPathForOrigin(origin_string, &path));
+      EXPECT_FALSE(path.empty());
+
+      // Populate the origin directory with some fake data.
+      old_directory_db_path = data_dir_path().Append(path);
+      ASSERT_TRUE(base::CreateDirectory(old_directory_db_path));
+      EXPECT_EQ(static_cast<int>(kFakeDirectoryData.size()),
+                file_util::WriteFile(old_directory_db_path.AppendASCII("dummy"),
+                                     kFakeDirectoryData.data(),
+                                     kFakeDirectoryData.size()));
+    }
+
+    storage_policy_->AddIsolated(origin_);
+    scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(
+        storage_policy_.get());
+    base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+    base::FilePath origin_directory = file_util->GetDirectoryForOrigin(
+        origin_, true /* create */, &error);
+    EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+
+    // The database is migrated from the old one.
+    EXPECT_TRUE(base::DirectoryExists(origin_directory));
+    EXPECT_FALSE(base::DirectoryExists(old_directory_db_path));
+
+    // Check we see the same contents in the new origin directory.
+    std::string origin_db_data;
+    EXPECT_TRUE(base::PathExists(origin_directory.AppendASCII("dummy")));
+    EXPECT_TRUE(base::ReadFileToString(
+            origin_directory.AppendASCII("dummy"), &origin_db_data));
+    EXPECT_EQ(kFakeDirectoryData, origin_db_data);
+  }
+
   int64 ComputeCurrentUsage() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   FileSystemContext* file_system_context() {
     return sandbox_file_system_.file_system_context();
   }
 
   const base::FilePath& data_dir_path() const {
     return data_dir_.path();
   }
 
  protected:
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
   scoped_refptr<quota::MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   fileapi::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
   SandboxFileSystemTestHelper sandbox_file_system_;
   quota::QuotaStatusCode quota_status_;
   int64 usage_;
-  MockFileChangeObserver change_observer_;
-  ChangeObserverList change_observers_;
+  fileapi::MockFileChangeObserver change_observer_;
+  fileapi::ChangeObserverList change_observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
 TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   base::PlatformFile file_handle = base::kInvalidPlatformFileValue;
   bool created;
   FileSystemURL url = CreateURLFromUTF8("fake/file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
@@ skipping 411 matching lines @@
 
 TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool created = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
       ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
 
-  std::vector<DirectoryEntry> entries;
+  std::vector<fileapi::DirectoryEntry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
             AsyncFileTestHelper::ReadDirectory(
                 file_system_context(), url, &entries));
 
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestTouch) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
@@ skipping 426 matching lines @@
       origins_expected.end(), origins_found.begin(), origins_found.end(),
       inserter(diff, diff.begin()));
   EXPECT_TRUE(diff.empty());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   int64 expected_quota = 0;
 
-  for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
+  for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     SCOPED_TRACE(testing::Message() << "Creating kRegularTestCase " << i);
-    const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
+    const fileapi::test::TestCaseRecord& test_case =
+        fileapi::test::kRegularTestCases[i];
     base::FilePath file_path(test_case.path);
     expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(file_path);
     if (test_case.is_directory) {
       bool exclusive = true;
       bool recursive = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           ofu()->CreateDirectory(context.get(), CreateURL(file_path),
                                  exclusive, recursive));
     } else {
       bool created = false;
@@ skipping 112 matching lines @@
   scoped_ptr<FileSystemOperationContext> context;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) {
     bool created = false;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->EnsureFileExists(context.get(), kPath[i], &created));
     EXPECT_TRUE(created);
   }
 
-  std::vector<DirectoryEntry> entries;
+  std::vector<fileapi::DirectoryEntry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             AsyncFileTestHelper::ReadDirectory(
                 file_system_context(), empty_path, &entries));
   EXPECT_EQ(3u, entries.size());
 
   base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
   EXPECT_TRUE(base::DeleteFile(local_path, false));
 
@@ skipping 236 matching lines @@
             ofu()->GetLocalFilePath(context.get(), url1, &file_path));
   EXPECT_FALSE(file_path.empty());
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->Touch(context.get(), url1,
                          base::Time::Now() + base::TimeDelta::FromHours(1),
                          base::Time()));
 
   context.reset(NewContext(NULL));
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
+  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       ofu()->CreateFileEnumerator(context.get(), dir, false));
 
   int count = 0;
   base::FilePath file_path_each;
   while (!(file_path_each = file_enum->Next()).empty()) {
     context.reset(NewContext(NULL));
     base::PlatformFileInfo file_info;
     base::FilePath file_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->GetFileInfo(context.get(),
@@ skipping 332 matching lines @@
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateOrOpen(
                 AllowUsageIncrease(-length)->context(), file,
                 base::PLATFORM_FILE_OPEN_TRUNCATED | base::PLATFORM_FILE_WRITE,
                 &file_handle, &created));
   ASSERT_EQ(0, ComputeTotalFileSize());
   EXPECT_TRUE(base::ClosePlatformFile(file_handle));
 }
 
 TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAliveCase) {
-  scoped_ptr<ObfuscatedFileUtil> file_util(
-      ObfuscatedFileUtil::CreateForTesting(
-          NULL, data_dir_path(),
-          base::MessageLoopProxy::current().get()));
-  file_util->InitOriginDatabase(GURL(), true /*create*/);
-  ASSERT_TRUE(file_util->origin_database_ != NULL);
-
-  // Callback to Drop DB is called while ObfuscatedFileUtilTest is still alive.
-  file_util->db_flush_delay_seconds_ = 0;
-  file_util->MarkUsed();
-  base::RunLoop().RunUntilIdle();
-
-  ASSERT_TRUE(file_util->origin_database_ == NULL);
+  MaybeDropDatabasesAliveCaseTestBody();
 }
 
 TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAlreadyDeletedCase) {
-  // Run message loop after OFU is already deleted to make sure callback doesn't
-  // cause a crash for use after free.
-  {
-    scoped_ptr<ObfuscatedFileUtil> file_util(
-        ObfuscatedFileUtil::CreateForTesting(
-            NULL, data_dir_path(),
-            base::MessageLoopProxy::current().get()));
-    file_util->InitOriginDatabase(GURL(), true /*create*/);
-    file_util->db_flush_delay_seconds_ = 0;
-    file_util->MarkUsed();
-  }
-
-  // At this point the callback is still in the message queue but OFU is gone.
-  base::RunLoop().RunUntilIdle();
+  MaybeDropDatabasesAlreadyDeletedCaseTestBody();
 }
 
 TEST_F(ObfuscatedFileUtilTest, DestroyDirectoryDatabase_Isolated) {
-  storage_policy_->AddIsolated(origin_);
-  scoped_ptr<ObfuscatedFileUtil> file_util(
-      ObfuscatedFileUtil::CreateForTesting(
-          storage_policy_.get(), data_dir_path(),
-          base::MessageLoopProxy::current().get()));
-  const FileSystemURL url = FileSystemURL::CreateForTest(
-      origin_, kFileSystemTypePersistent, base::FilePath());
-
-  // Create DirectoryDatabase for isolated origin.
-  SandboxDirectoryDatabase* db =
-      file_util->GetDirectoryDatabase(url, true /* create */);
-  ASSERT_TRUE(db != NULL);
-
-  // Destory it.
-  ASSERT_TRUE(file_util->DestroyDirectoryDatabase(
-      url.origin(), GetTypeString(url.type())));
-  ASSERT_TRUE(file_util->directories_.empty());
+  DestroyDirectoryDatabase_IsolatedTestBody();
 }
 
 TEST_F(ObfuscatedFileUtilTest, GetDirectoryDatabase_Isolated) {
-  storage_policy_->AddIsolated(origin_);
-  scoped_ptr<ObfuscatedFileUtil> file_util(
-      ObfuscatedFileUtil::CreateForTesting(
-          storage_policy_.get(), data_dir_path(),
-          base::MessageLoopProxy::current().get()));
-  const FileSystemURL url = FileSystemURL::CreateForTest(
-      origin_, kFileSystemTypePersistent, base::FilePath());
-
-  // Create DirectoryDatabase for isolated origin.
-  SandboxDirectoryDatabase* db =
-      file_util->GetDirectoryDatabase(url, true /* create */);
-  ASSERT_TRUE(db != NULL);
-  ASSERT_EQ(1U, file_util->directories_.size());
-
-  // Remove isolated.
-  storage_policy_->RemoveIsolated(url.origin());
-
-  // This should still get the same database.
-  SandboxDirectoryDatabase* db2 =
-      file_util->GetDirectoryDatabase(url, false /* create */);
-  ASSERT_EQ(db, db2);
+  GetDirectoryDatabase_IsolatedTestBody();
 }
 
 TEST_F(ObfuscatedFileUtilTest, MigrationBackFromIsolated) {
-  std::string kFakeDirectoryData("0123456789");
-  base::FilePath old_directory_db_path;
-
-  // Initialize the directory with one origin using
-  // SandboxIsolatedOriginDatabase.
-  {
-    std::string origin_string =
-        webkit_database::GetIdentifierFromOrigin(origin_);
-    SandboxIsolatedOriginDatabase database_old(
-        origin_string, data_dir_path(),
-        base::FilePath(
-            SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory));
-    base::FilePath path;
-    EXPECT_TRUE(database_old.GetPathForOrigin(origin_string, &path));
-    EXPECT_FALSE(path.empty());
-
-    // Populate the origin directory with some fake data.
-    old_directory_db_path = data_dir_path().Append(path);
-    ASSERT_TRUE(base::CreateDirectory(old_directory_db_path));
-    EXPECT_EQ(static_cast<int>(kFakeDirectoryData.size()),
-              file_util::WriteFile(old_directory_db_path.AppendASCII("dummy"),
-                                   kFakeDirectoryData.data(),
-                                   kFakeDirectoryData.size()));
-  }
-
-  storage_policy_->AddIsolated(origin_);
-  scoped_ptr<ObfuscatedFileUtil> file_util(
-      ObfuscatedFileUtil::CreateForTesting(
-          storage_policy_.get(), data_dir_path(),
-          base::MessageLoopProxy::current().get()));
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
-  base::FilePath origin_directory = file_util->GetDirectoryForOrigin(
-      origin_, true /* create */, &error);
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
-
-  // The database is migrated from the old one.
-  EXPECT_TRUE(base::DirectoryExists(origin_directory));
-  EXPECT_FALSE(base::DirectoryExists(old_directory_db_path));
-
-  // Check we see the same contents in the new origin directory.
-  std::string origin_db_data;
-  EXPECT_TRUE(base::PathExists(origin_directory.AppendASCII("dummy")));
-  EXPECT_TRUE(base::ReadFileToString(
-      origin_directory.AppendASCII("dummy"), &origin_db_data));
-  EXPECT_EQ(kFakeDirectoryData, origin_db_data);
+  MigrationBackFromIsolatedTestBody();
 }
 
 TEST_F(ObfuscatedFileUtilTest, OpenPathInNonDirectory) {
   FileSystemURL file(CreateURLFromUTF8("file"));
   FileSystemURL path_in_file(CreateURLFromUTF8("file/file"));
   bool created;
 
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(UnlimitedContext().get(), file, &created));
   ASSERT_TRUE(created);
@@ skipping 33 matching lines @@
                                    path_in_file,
                                    false /* exclusive */,
                                    true /* recursive */));
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
             ofu()->CreateDirectory(UnlimitedContext().get(),
                                    path_in_file_in_file,
                                    false /* exclusive */,
                                    true /* recursive */));
 }
 
-}  // namespace fileapi
+}  // namespace content