Add ObfuscatedFileUtilMemoryDelegate.

|ObfuscatedFileUtilDelegate| and |ObfuscatedFileUtilMemoryDelegate|
are added to support in-memory file system for incognito mode and
|ObfuscatedFileUtil| is updated to choose the appropriate delegate
based on being incognito or not.

To avoid making the CL large, only the skeleton of the
|ObfuscatedFileUtilMemoryDelegate| is added in this CL and the actual
implementation will be added in a next one.

The change is part of the following design doc:
https://docs.google.com/document/d/17NV1cGSIEG2i5qm2QU4EzDMKRoyVEbNNq-Re-JhwSB0

Bug: 93417
Change-Id: I47353c656ab70ab6c98c8e06c9e0c3a03319d012
Reviewed-on: https://chromium-review.googlesource.com/c/1452176Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Commit-Queue: Ramin Halavati <rhalavati@chromium.org>
Cr-Commit-Position: refs/heads/master@{#630002}

storage/browser/BUILD.gn

@@ -131,8 +131,11 @@ jumbo_component("browser") {
     "fileapi/native_file_util.h",
     "fileapi/obfuscated_file_util.cc",
     "fileapi/obfuscated_file_util.h",
+    "fileapi/obfuscated_file_util_delegate.h",
     "fileapi/obfuscated_file_util_disk_delegate.cc",
     "fileapi/obfuscated_file_util_disk_delegate.h",
+    "fileapi/obfuscated_file_util_memory_delegate.cc",
+    "fileapi/obfuscated_file_util_memory_delegate.h",
     "fileapi/open_file_system_mode.h",
     "fileapi/plugin_private_file_system_backend.cc",
     "fileapi/plugin_private_file_system_backend.h",

storage/browser/fileapi/obfuscated_file_util.cc

@@ -25,6 +25,8 @@
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/obfuscated_file_util_disk_delegate.h"
+#include "storage/browser/fileapi/obfuscated_file_util_memory_delegate.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend.h"
 #include "storage/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "storage/browser/fileapi/sandbox_origin_database.h"
@@ -265,14 +267,16 @@ ObfuscatedFileUtil::ObfuscatedFileUtil(
       db_flush_delay_seconds_(10 * 60),  // 10 mins.
       get_type_string_for_url_(std::move(get_type_string_for_url)),
       known_type_strings_(known_type_strings),
-      sandbox_delegate_(sandbox_delegate),
-      delegate_(std::make_unique<ObfuscatedFileUtilDiskDelegate>()) {
-  // TODO(https://crbug.com/93417): |delegate_| to be initialized with an
-  // instance of |ObfuscatedFileUtilMemoryDelegate| if |is_incognito| is true.
+      sandbox_delegate_(sandbox_delegate) {
   DCHECK(!get_type_string_for_url_.is_null());
   DETACH_FROM_SEQUENCE(sequence_checker_);
   DCHECK(!is_incognito ||
          (env_override && leveldb_chrome::IsMemEnv(env_override)));
+
+  if (is_incognito)
+    delegate_ = std::make_unique<ObfuscatedFileUtilMemoryDelegate>();
+  else
+    delegate_ = std::make_unique<ObfuscatedFileUtilDiskDelegate>();
 }
 
 ObfuscatedFileUtil::~ObfuscatedFileUtil() {

storage/browser/fileapi/obfuscated_file_util.h

@@ -23,9 +23,7 @@
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_system_file_util.h"
 #include "storage/browser/fileapi/file_system_url.h"
-// TODO(https://crbug.com/93417): To be replaced with
-// obfuscated_file_util_delegate.h
-#include "storage/browser/fileapi/obfuscated_file_util_disk_delegate.h"
+#include "storage/browser/fileapi/obfuscated_file_util_delegate.h"
 #include "storage/browser/fileapi/sandbox_directory_database.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "storage/common/fileapi/file_system_types.h"
@@ -342,9 +340,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) ObfuscatedFileUtil
   // Not owned.
   SandboxFileSystemBackendDelegate* sandbox_delegate_;
 
-  // TODO(https://crbug.com/93417): To be replaced with
-  // ObfuscatedFileUtilDelegate.
-  std::unique_ptr<ObfuscatedFileUtilDiskDelegate> delegate_;
+  std::unique_ptr<ObfuscatedFileUtilDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
 };

storage/browser/fileapi/obfuscated_file_util_delegate.h

+// Copyright 2019 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 STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_DELEGATE_H_
+#define STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_DELEGATE_H_
+
+#include "base/component_export.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "storage/browser/fileapi/native_file_util.h"
+
+namespace storage {
+
+// This delegate performs all ObfuscatedFileUtil tasks that actually touch disk.
+
+class COMPONENT_EXPORT(STORAGE_BROWSER) ObfuscatedFileUtilDelegate {
+ public:
+  ObfuscatedFileUtilDelegate() = default;
+  virtual ~ObfuscatedFileUtilDelegate() = default;
+
+  virtual bool DirectoryExists(const base::FilePath& path) = 0;
+  virtual bool DeleteFileOrDirectory(const base::FilePath& path,
+                                     bool recursive) = 0;
+  virtual bool IsLink(const base::FilePath& file_path) = 0;
+  virtual bool PathExists(const base::FilePath& path) = 0;
+
+  virtual NativeFileUtil::CopyOrMoveMode CopyOrMoveModeForDestination(
+      const FileSystemURL& dest_url,
+      bool copy) = 0;
+  virtual base::File CreateOrOpen(const base::FilePath& path,
+                                  int file_flags) = 0;
+  virtual base::File::Error EnsureFileExists(const base::FilePath& path,
+                                             bool* created) = 0;
+  virtual base::File::Error CreateDirectory(const base::FilePath& path,
+                                            bool exclusive,
+                                            bool recursive) = 0;
+  virtual base::File::Error GetFileInfo(const base::FilePath& path,
+                                        base::File::Info* file_info) = 0;
+  virtual base::File::Error Touch(const base::FilePath& path,
+                                  const base::Time& last_access_time,
+                                  const base::Time& last_modified_time) = 0;
+  virtual base::File::Error Truncate(const base::FilePath& path,
+                                     int64_t length) = 0;
+  virtual base::File::Error CopyOrMoveFile(
+      const base::FilePath& src_path,
+      const base::FilePath& dest_path,
+      FileSystemOperation::CopyOrMoveOption option,
+      NativeFileUtil::CopyOrMoveMode mode) = 0;
+  virtual base::File::Error DeleteFile(const base::FilePath& path) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilDelegate);
+};
+
+}  // namespace storage
+
+#endif  // STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_DELEGATE_H_

storage/browser/fileapi/obfuscated_file_util_disk_delegate.cc

@@ -11,6 +11,8 @@ namespace storage {
 
 ObfuscatedFileUtilDiskDelegate::ObfuscatedFileUtilDiskDelegate() {}
 
+ObfuscatedFileUtilDiskDelegate::~ObfuscatedFileUtilDiskDelegate() {}
+
 bool ObfuscatedFileUtilDiskDelegate::DirectoryExists(
     const base::FilePath& path) {
   return base::DirectoryExists(path);

storage/browser/fileapi/obfuscated_file_util_disk_delegate.h

@@ -9,42 +9,46 @@
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "storage/browser/fileapi/native_file_util.h"
+#include "storage/browser/fileapi/obfuscated_file_util_delegate.h"
 
 namespace storage {
 
 // This delegate performs all ObfuscatedFileUtil tasks that actually touch disk.
 
-// TODO(https://crbug.com/93417): To be driven from abstract class
-// |ObfuscatedFileUtilDelegate|.
-class COMPONENT_EXPORT(STORAGE_BROWSER) ObfuscatedFileUtilDiskDelegate {
+class COMPONENT_EXPORT(STORAGE_BROWSER) ObfuscatedFileUtilDiskDelegate
+    : public ObfuscatedFileUtilDelegate {
  public:
   ObfuscatedFileUtilDiskDelegate();
-  ~ObfuscatedFileUtilDiskDelegate() = default;
+  ~ObfuscatedFileUtilDiskDelegate() override;
 
-  bool DirectoryExists(const base::FilePath& path);
-  bool DeleteFileOrDirectory(const base::FilePath& path, bool recursive);
-  bool IsLink(const base::FilePath& file_path);
-  bool PathExists(const base::FilePath& path);
+  bool DirectoryExists(const base::FilePath& path) override;
+  bool DeleteFileOrDirectory(const base::FilePath& path,
+                             bool recursive) override;
+  bool IsLink(const base::FilePath& file_path) override;
+  bool PathExists(const base::FilePath& path) override;
 
   NativeFileUtil::CopyOrMoveMode CopyOrMoveModeForDestination(
       const FileSystemURL& dest_url,
-      bool copy);
-  base::File CreateOrOpen(const base::FilePath& path, int file_flags);
-  base::File::Error EnsureFileExists(const base::FilePath& path, bool* created);
+      bool copy) override;
+  base::File CreateOrOpen(const base::FilePath& path, int file_flags) override;
+  base::File::Error EnsureFileExists(const base::FilePath& path,
+                                     bool* created) override;
   base::File::Error CreateDirectory(const base::FilePath& path,
                                     bool exclusive,
-                                    bool recursive);
+                                    bool recursive) override;
   base::File::Error GetFileInfo(const base::FilePath& path,
-                                base::File::Info* file_info);
+                                base::File::Info* file_info) override;
   base::File::Error Touch(const base::FilePath& path,
                           const base::Time& last_access_time,
-                          const base::Time& last_modified_time);
-  base::File::Error Truncate(const base::FilePath& path, int64_t length);
-  base::File::Error CopyOrMoveFile(const base::FilePath& src_path,
+                          const base::Time& last_modified_time) override;
+  base::File::Error Truncate(const base::FilePath& path,
+                             int64_t length) override;
+  base::File::Error CopyOrMoveFile(
+      const base::FilePath& src_path,
       const base::FilePath& dest_path,
       FileSystemOperation::CopyOrMoveOption option,
-                                   NativeFileUtil::CopyOrMoveMode mode);
-  base::File::Error DeleteFile(const base::FilePath& path);
+      NativeFileUtil::CopyOrMoveMode mode) override;
+  base::File::Error DeleteFile(const base::FilePath& path) override;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilDiskDelegate);
 };

storage/browser/fileapi/obfuscated_file_util_memory_delegate.cc

+// Copyright 2019 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 "storage/browser/fileapi/obfuscated_file_util_memory_delegate.h"
+
+namespace storage {
+
+ObfuscatedFileUtilMemoryDelegate::ObfuscatedFileUtilMemoryDelegate() {}
+ObfuscatedFileUtilMemoryDelegate::~ObfuscatedFileUtilMemoryDelegate() {}
+
+bool ObfuscatedFileUtilMemoryDelegate::DirectoryExists(
+    const base::FilePath& path) {
+  NOTIMPLEMENTED();
+  // return base::DirectoryExists(path);
+  return false;
+}
+
+bool ObfuscatedFileUtilMemoryDelegate::DeleteFileOrDirectory(
+    const base::FilePath& path,
+    bool recursive) {
+  NOTIMPLEMENTED();
+  // return base::DeleteFile(path, recursive);
+  return false;
+}
+
+bool ObfuscatedFileUtilMemoryDelegate::IsLink(const base::FilePath& file_path) {
+  NOTIMPLEMENTED();
+  // return base::IsLink(file_path);
+  return false;
+}
+
+bool ObfuscatedFileUtilMemoryDelegate::PathExists(const base::FilePath& path) {
+  NOTIMPLEMENTED();
+  // return base::PathExists(path);
+  return false;
+}
+
+NativeFileUtil::CopyOrMoveMode
+ObfuscatedFileUtilMemoryDelegate::CopyOrMoveModeForDestination(
+    const FileSystemURL& dest_url,
+    bool copy) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::CopyOrMoveModeForDestination(dest_url, copy);
+  return NativeFileUtil::CopyOrMoveMode::MOVE;
+}
+
+base::File ObfuscatedFileUtilMemoryDelegate::CreateOrOpen(
+    const base::FilePath& path,
+    int file_flags) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::CreateOrOpen(path, file_flags);
+  return base::File();
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::EnsureFileExists(
+    const base::FilePath& path,
+    bool* created) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::EnsureFileExists(path, created);
+  return base::File::FILE_ERROR_FAILED;
+}
+base::File::Error ObfuscatedFileUtilMemoryDelegate::CreateDirectory(
+    const base::FilePath& path,
+    bool exclusive,
+    bool recursive) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::CreateDirectory(path, exclusive, recursive);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::GetFileInfo(
+    const base::FilePath& path,
+    base::File::Info* file_info) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::GetFileInfo(path, file_info);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::Touch(
+    const base::FilePath& path,
+    const base::Time& last_access_time,
+    const base::Time& last_modified_time) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::Touch(path, last_access_time, last_modified_time);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::Truncate(
+    const base::FilePath& path,
+    int64_t length) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::Truncate(path, length);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::CopyOrMoveFile(
+    const base::FilePath& src_path,
+    const base::FilePath& dest_path,
+    FileSystemOperation::CopyOrMoveOption option,
+    NativeFileUtil::CopyOrMoveMode mode) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::CopyOrMoveFile(src_path, dest_path, option, mode);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+base::File::Error ObfuscatedFileUtilMemoryDelegate::DeleteFile(
+    const base::FilePath& path) {
+  NOTIMPLEMENTED();
+  // return NativeFileUtil::DeleteFile(path);
+  return base::File::FILE_ERROR_FAILED;
+}
+
+}  // namespace storage

storage/browser/fileapi/obfuscated_file_util_memory_delegate.h

+// Copyright 2019 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 STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_MEMORY_DELEGATE_H_
+#define STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_MEMORY_DELEGATE_H_
+
+#include "base/component_export.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "storage/browser/fileapi/native_file_util.h"
+#include "storage/browser/fileapi/obfuscated_file_util_delegate.h"
+
+namespace storage {
+
+// This delegate performs all ObfuscatedFileUtil tasks that require touching
+// disk and peforms them in memory.
+
+class COMPONENT_EXPORT(STORAGE_BROWSER) ObfuscatedFileUtilMemoryDelegate
+    : public ObfuscatedFileUtilDelegate {
+ public:
+  ObfuscatedFileUtilMemoryDelegate();
+  ~ObfuscatedFileUtilMemoryDelegate() override;
+
+  bool DirectoryExists(const base::FilePath& path) override;
+  bool DeleteFileOrDirectory(const base::FilePath& path,
+                             bool recursive) override;
+  bool IsLink(const base::FilePath& file_path) override;
+  bool PathExists(const base::FilePath& path) override;
+
+  NativeFileUtil::CopyOrMoveMode CopyOrMoveModeForDestination(
+      const FileSystemURL& dest_url,
+      bool copy) override;
+  base::File CreateOrOpen(const base::FilePath& path, int file_flags) override;
+  base::File::Error EnsureFileExists(const base::FilePath& path,
+                                     bool* created) override;
+  base::File::Error CreateDirectory(const base::FilePath& path,
+                                    bool exclusive,
+                                    bool recursive) override;
+  base::File::Error GetFileInfo(const base::FilePath& path,
+                                base::File::Info* file_info) override;
+  base::File::Error Touch(const base::FilePath& path,
+                          const base::Time& last_access_time,
+                          const base::Time& last_modified_time) override;
+  base::File::Error Truncate(const base::FilePath& path,
+                             int64_t length) override;
+  base::File::Error CopyOrMoveFile(
+      const base::FilePath& src_path,
+      const base::FilePath& dest_path,
+      FileSystemOperation::CopyOrMoveOption option,
+      NativeFileUtil::CopyOrMoveMode mode) override;
+  base::File::Error DeleteFile(const base::FilePath& path) override;
+
+  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilMemoryDelegate);
+};
+
+}  // namespace storage
+
+#endif  // STORAGE_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_MEMORY_DELEGATE_H_

storage/browser/fileapi/obfuscated_file_util_unittest.cc

@@ -43,6 +43,7 @@
 #include "storage/browser/test/test_file_system_context.h"
 #include "storage/common/database/database_identifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/leveldatabase/leveldb_chrome.h"
 
 using content::AsyncFileTestHelper;
 using storage::FileSystemContext;
@@ -151,11 +152,14 @@ bool HasFileSystemType(ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
 // 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 {
+class ObfuscatedFileUtilTest : public testing::Test,
+                               public ::testing::WithParamInterface<bool> {
  public:
   ObfuscatedFileUtilTest()
-      : scoped_task_environment_(
+      : is_incognito_(GetParam()),
+        scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::IO),
+
         origin_(GURL("http://www.example.com")),
         type_(storage::kFileSystemTypeTemporary),
         sandbox_file_system_(origin_, type_),
@@ -169,7 +173,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
     storage_policy_ = new MockSpecialStoragePolicy();
 
     quota_manager_ = new storage::QuotaManager(
-        false /* is_incognito */, data_dir_.GetPath(),
+        is_incognito_, data_dir_.GetPath(),
         base::ThreadTaskRunnerHandle::Get().get(), storage_policy_.get(),
         storage::GetQuotaSettingsFunc());
     storage::QuotaSettings settings;
@@ -190,6 +194,9 @@ class ObfuscatedFileUtilTest : public testing::Test {
 
     change_observers_ =
         storage::MockFileChangeObserver::CreateList(&change_observer_);
+
+    if (is_incognito_)
+      incognito_leveldb_environment_ = leveldb_chrome::NewMemEnv("FileSystem");
   }
 
   void TearDown() override {
@@ -247,11 +254,11 @@ class ObfuscatedFileUtilTest : public testing::Test {
 
   std::unique_ptr<ObfuscatedFileUtil> CreateObfuscatedFileUtil(
       storage::SpecialStoragePolicy* storage_policy) {
-    // TODO(https://crbug.com/93417): Add support for incognito tests.
     return std::unique_ptr<ObfuscatedFileUtil>(
-        ObfuscatedFileUtil::CreateForTesting(storage_policy, data_dir_path(),
-                                             /*env_override=*/nullptr,
-                                             /*is_incognito=*/false));
+        ObfuscatedFileUtil::CreateForTesting(
+            storage_policy, data_dir_path(),
+            is_incognito_ ? incognito_leveldb_environment_.get() : nullptr,
+            is_incognito_));
   }
 
   ObfuscatedFileUtil* ofu() {
@@ -680,6 +687,10 @@ class ObfuscatedFileUtilTest : public testing::Test {
   }
 
   void MaybeDropDatabasesAliveCaseTestBody() {
+    // TODO(https://crbug.com/43417): Enable test after finishing incognito
+    // implementation.
+    if (is_incognito_)
+      return;
     std::unique_ptr<ObfuscatedFileUtil> file_util =
         CreateObfuscatedFileUtil(nullptr);
     file_util->InitOriginDatabase(GURL(), true /*create*/);
@@ -710,6 +721,10 @@ class ObfuscatedFileUtilTest : public testing::Test {
   }
 
   void DestroyDirectoryDatabase_IsolatedTestBody() {
+    // TODO(https://crbug.com/43417): Enable test after finishing incognito
+    // implementation.
+    if (is_incognito_)
+      return;
     storage_policy_->AddIsolated(origin_);
     std::unique_ptr<ObfuscatedFileUtil> file_util =
         CreateObfuscatedFileUtil(storage_policy_.get());
@@ -729,6 +744,10 @@ class ObfuscatedFileUtilTest : public testing::Test {
   }
 
   void GetDirectoryDatabase_IsolatedTestBody() {
+    // TODO(https://crbug.com/43417): Enable test after finishing incognito
+    // implementation.
+    if (is_incognito_)
+      return;
     storage_policy_->AddIsolated(origin_);
     std::unique_ptr<ObfuscatedFileUtil> file_util =
         CreateObfuscatedFileUtil(storage_policy_.get());
@@ -763,6 +782,8 @@ class ObfuscatedFileUtilTest : public testing::Test {
   const base::FilePath& data_dir_path() const { return data_dir_.GetPath(); }
 
  protected:
+  bool is_incognito_;
+  std::unique_ptr<leveldb::Env> incognito_leveldb_environment_;
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::ScopedTempDir data_dir_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
@@ -781,7 +802,9 @@ class ObfuscatedFileUtilTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
-TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
+INSTANTIATE_TEST_CASE_P(, ObfuscatedFileUtilTest, ::testing::Bool());
+
+TEST_P(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   FileSystemURL url = CreateURLFromUTF8("fake/file");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   int file_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE;
@@ -866,7 +889,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestTruncate) {
+TEST_P(ObfuscatedFileUtilTest, TestTruncate) {
   bool created = false;
   FileSystemURL url = CreateURLFromUTF8("file");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
@@ -903,7 +926,7 @@ TEST_F(ObfuscatedFileUtilTest, TestTruncate) {
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestQuotaOnTruncation) {
+TEST_P(ObfuscatedFileUtilTest, TestQuotaOnTruncation) {
   bool created = false;
   FileSystemURL url = CreateURLFromUTF8("file");
 
@@ -958,7 +981,7 @@ TEST_F(ObfuscatedFileUtilTest, TestQuotaOnTruncation) {
   ASSERT_EQ(0, ComputeTotalFileSize());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) {
+TEST_P(ObfuscatedFileUtilTest, TestEnsureFileExists) {
   FileSystemURL url = CreateURLFromUTF8("fake/file");
   bool created = false;
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
@@ -1013,7 +1036,7 @@ TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) {
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) {
+TEST_P(ObfuscatedFileUtilTest, TestDirectoryOps) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
 
   bool exclusive = false;
@@ -1155,7 +1178,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) {
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) {
+TEST_P(ObfuscatedFileUtilTest, TestReadDirectory) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   bool exclusive = true;
   bool recursive = true;
@@ -1165,15 +1188,15 @@ TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) {
   TestReadDirectoryHelper(url);
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestReadRootWithSlash) {
+TEST_P(ObfuscatedFileUtilTest, TestReadRootWithSlash) {
   TestReadDirectoryHelper(CreateURLFromUTF8(std::string()));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestReadRootWithEmptyString) {
+TEST_P(ObfuscatedFileUtilTest, TestReadRootWithEmptyString) {
   TestReadDirectoryHelper(CreateURLFromUTF8("/"));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
+TEST_P(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   FileSystemURL url = CreateURLFromUTF8("file");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
 
@@ -1190,7 +1213,7 @@ TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestTouch) {
+TEST_P(ObfuscatedFileUtilTest, TestTouch) {
   FileSystemURL url = CreateURLFromUTF8("file");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
 
@@ -1220,7 +1243,7 @@ TEST_F(ObfuscatedFileUtilTest, TestTouch) {
   TestTouchHelper(url, false);
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) {
+TEST_P(ObfuscatedFileUtilTest, TestPathQuotas) {
   FileSystemURL url = CreateURLFromUTF8("fake/file");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
 
@@ -1255,7 +1278,7 @@ TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) {
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) {
+TEST_P(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) {
   FileSystemURL source_url = CreateURLFromUTF8("path0.txt");
   FileSystemURL dest_url = CreateURLFromUTF8("path1.txt");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
@@ -1297,7 +1320,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) {
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) {
+TEST_P(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) {
   const int64_t kSourceLength = 5;
   const int64_t kDestLength = 50;
 
@@ -1386,7 +1409,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) {
   }
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) {
+TEST_P(ObfuscatedFileUtilTest, TestCopyPathQuotas) {
   FileSystemURL src_url = CreateURLFromUTF8("src path");
   FileSystemURL dest_url = CreateURLFromUTF8("destination path");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
@@ -1416,7 +1439,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) {
                                   FileSystemOperation::OPTION_NONE, is_copy));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) {
+TEST_P(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) {
   FileSystemURL src_url = CreateURLFromUTF8("src path");
   FileSystemURL dest_url = CreateURLFromUTF8("destination path");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
@@ -1453,7 +1476,7 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) {
                                   FileSystemOperation::OPTION_NONE, is_copy));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) {
+TEST_P(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) {
   FileSystemURL src_url = CreateURLFromUTF8("src path");
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   bool created = false;
@@ -1496,12 +1519,12 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) {
       context->allowed_bytes_growth());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestCopyInForeignFile) {
+TEST_P(ObfuscatedFileUtilTest, TestCopyInForeignFile) {
   TestCopyInForeignFileHelper(false /* overwrite */);
   TestCopyInForeignFileHelper(true /* overwrite */);
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestEnumerator) {
+TEST_P(ObfuscatedFileUtilTest, TestEnumerator) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   FileSystemURL src_url = CreateURLFromUTF8("source dir");
   bool exclusive = true;
@@ -1531,7 +1554,7 @@ TEST_F(ObfuscatedFileUtilTest, TestEnumerator) {
   EXPECT_FALSE(DirectoryExists(dest_url));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
+TEST_P(ObfuscatedFileUtilTest, TestOriginEnumerator) {
   std::unique_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enumerator(
       ofu()->CreateOriginEnumerator());
   // The test helper starts out with a single filesystem.
@@ -1617,7 +1640,7 @@ TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
   EXPECT_TRUE(diff.empty());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
+TEST_P(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
 
   int64_t expected_quota = 0;
@@ -1663,7 +1686,7 @@ TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   EXPECT_EQ(expected_quota, usage());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestInconsistency) {
+TEST_P(ObfuscatedFileUtilTest, TestInconsistency) {
   const FileSystemURL kPath1 = CreateURLFromUTF8("hoge");
   const FileSystemURL kPath2 = CreateURLFromUTF8("fuga");
 
@@ -1738,7 +1761,7 @@ TEST_F(ObfuscatedFileUtilTest, TestInconsistency) {
   EXPECT_EQ(0, file_info.size);
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
+TEST_P(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
   const FileSystemURL kPath[] = {
     CreateURLFromUTF8("foo"),
     CreateURLFromUTF8("bar"),
@@ -1773,7 +1796,7 @@ TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
   EXPECT_EQ(base::size(kPath) - 1, entries.size());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) {
+TEST_P(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   const FileSystemURL dir_url = CreateURLFromUTF8("foo_dir");
 
@@ -1898,7 +1921,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) {
   EXPECT_NE(base::Time(), GetModifiedTime(dir_url));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) {
+TEST_P(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) {
   std::unique_ptr<FileSystemOperationContext> context(NewContext(nullptr));
   const FileSystemURL dir_url = CreateURLFromUTF8("foo_dir");
 
@@ -1957,7 +1980,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) {
   EXPECT_NE(base::Time(), GetModifiedTime(dir_url));
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCopyAndMove) {
+TEST_P(ObfuscatedFileUtilTest, TestDirectoryTimestampForCopyAndMove) {
   TestDirectoryTimestampHelper(
       CreateURLFromUTF8("copy overwrite"), true, true);
   TestDirectoryTimestampHelper(
@@ -1968,7 +1991,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCopyAndMove) {
       CreateURLFromUTF8("move non-overwrite"), false, false);
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestFileEnumeratorTimestamp) {
+TEST_P(ObfuscatedFileUtilTest, TestFileEnumeratorTimestamp) {
   FileSystemURL dir = CreateURLFromUTF8("foo");
   FileSystemURL url1 = FileSystemURLAppendUTF8(dir, "bar");
   FileSystemURL url2 = FileSystemURLAppendUTF8(dir, "baz");
@@ -2030,7 +2053,7 @@ TEST_F(ObfuscatedFileUtilTest, TestFileEnumeratorTimestamp) {
 #else
 #define MAYBE_TestQuotaOnCopyFile TestQuotaOnCopyFile
 #endif
-TEST_F(ObfuscatedFileUtilTest, MAYBE_TestQuotaOnCopyFile) {
+TEST_P(ObfuscatedFileUtilTest, MAYBE_TestQuotaOnCopyFile) {
   FileSystemURL from_file(CreateURLFromUTF8("fromfile"));
   FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile"));
   FileSystemURL to_file1(CreateURLFromUTF8("tofile1"));
@@ -2128,7 +2151,7 @@ TEST_F(ObfuscatedFileUtilTest, MAYBE_TestQuotaOnCopyFile) {
   }
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestQuotaOnMoveFile) {
+TEST_P(ObfuscatedFileUtilTest, TestQuotaOnMoveFile) {
   FileSystemURL from_file(CreateURLFromUTF8("fromfile"));
   FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile"));
   FileSystemURL to_file(CreateURLFromUTF8("tofile"));
@@ -2234,7 +2257,7 @@ TEST_F(ObfuscatedFileUtilTest, TestQuotaOnMoveFile) {
   context.reset();
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestQuotaOnRemove) {
+TEST_P(ObfuscatedFileUtilTest, TestQuotaOnRemove) {
   FileSystemURL dir(CreateURLFromUTF8("dir"));
   FileSystemURL file(CreateURLFromUTF8("file"));
   FileSystemURL dfile1(CreateURLFromUTF8("dir/dfile1"));
@@ -2298,7 +2321,7 @@ TEST_F(ObfuscatedFileUtilTest, TestQuotaOnRemove) {
   ASSERT_EQ(0, ComputeTotalFileSize());
 }
 
-TEST_F(ObfuscatedFileUtilTest, TestQuotaOnOpen) {
+TEST_P(ObfuscatedFileUtilTest, TestQuotaOnOpen) {
   FileSystemURL url(CreateURLFromUTF8("file"));
 
   bool created;
@@ -2347,23 +2370,23 @@ TEST_F(ObfuscatedFileUtilTest, TestQuotaOnOpen) {
   file.Close();
 }
 
-TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAliveCase) {
+TEST_P(ObfuscatedFileUtilTest, MaybeDropDatabasesAliveCase) {
   MaybeDropDatabasesAliveCaseTestBody();
 }
 
-TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAlreadyDeletedCase) {
+TEST_P(ObfuscatedFileUtilTest, MaybeDropDatabasesAlreadyDeletedCase) {
   MaybeDropDatabasesAlreadyDeletedCaseTestBody();
 }
 
-TEST_F(ObfuscatedFileUtilTest, DestroyDirectoryDatabase_Isolated) {
+TEST_P(ObfuscatedFileUtilTest, DestroyDirectoryDatabase_Isolated) {
   DestroyDirectoryDatabase_IsolatedTestBody();
 }
 
-TEST_F(ObfuscatedFileUtilTest, GetDirectoryDatabase_Isolated) {
+TEST_P(ObfuscatedFileUtilTest, GetDirectoryDatabase_Isolated) {
   GetDirectoryDatabase_IsolatedTestBody();
 }
 
-TEST_F(ObfuscatedFileUtilTest, OpenPathInNonDirectory) {
+TEST_P(ObfuscatedFileUtilTest, OpenPathInNonDirectory) {
   FileSystemURL url(CreateURLFromUTF8("file"));
   FileSystemURL path_in_file(CreateURLFromUTF8("file/file"));
   bool created;
@@ -2385,7 +2408,7 @@ TEST_F(ObfuscatedFileUtilTest, OpenPathInNonDirectory) {
                                    false /* recursive */));
 }
 
-TEST_F(ObfuscatedFileUtilTest, CreateDirectory_NotADirectoryInRecursive) {
+TEST_P(ObfuscatedFileUtilTest, CreateDirectory_NotADirectoryInRecursive) {
   FileSystemURL file(CreateURLFromUTF8("file"));
   FileSystemURL path_in_file(CreateURLFromUTF8("file/child"));
   FileSystemURL path_in_file_in_file(
@@ -2408,7 +2431,7 @@ TEST_F(ObfuscatedFileUtilTest, CreateDirectory_NotADirectoryInRecursive) {
                                    true /* recursive */));
 }
 
-TEST_F(ObfuscatedFileUtilTest, DeleteDirectoryForOriginAndType) {
+TEST_P(ObfuscatedFileUtilTest, DeleteDirectoryForOriginAndType) {
   const GURL origin1("http://www.example.com:12");
   const GURL origin2("http://www.example.com:1234");
   const GURL origin3("http://nope.example.com");
@@ -2486,7 +2509,7 @@ TEST_F(ObfuscatedFileUtilTest, DeleteDirectoryForOriginAndType) {
       origin3, GetTypeString(kFileSystemTypePersistent)));
 }
 
-TEST_F(ObfuscatedFileUtilTest, DeleteDirectoryForOriginAndType_DeleteAll) {
+TEST_P(ObfuscatedFileUtilTest, DeleteDirectoryForOriginAndType_DeleteAll) {
   const GURL origin1("http://www.example.com:12");
   const GURL origin2("http://www.example.com:1234");