Clean up ARC file system unit tests.

chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc

Index: chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc
diff --git a/chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc b/chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc
index 0b5362f3f9374b0e825142694f54c1a5f3753544..5ac6432c8edf1b0870cdac802d6be108f51b972c 100644
--- a/chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc
+++ b/chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader_unittest.cc
@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <string.h>
+
 #include <memory>
 #include <string>
 #include <utility>
 
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/arc/fileapi/arc_content_file_system_file_stream_reader.h"
+#include "chrome/browser/chromeos/arc/fileapi/arc_file_system_operation_runner.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
-#include "components/arc/file_system/test/fake_arc_file_system_operation_runner.h"
+#include "components/arc/test/fake_file_system_instance.h"
 #include "content/public/test/test_browser_thread_bundle.h"
-#include "mojo/edk/embedder/embedder.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -53,85 +53,6 @@ bool ReadData(ArcContentFileSystemFileStreamReader* reader,
   return true;
 }
 
-// TODO(crbug.com/683049): Use a generic FakeArcFileSystemOperationRunner.
-class ArcFileSystemOperationRunnerForTest
-    : public FakeArcFileSystemOperationRunner {
- public:
-  ArcFileSystemOperationRunnerForTest(ArcBridgeService* bridge_service,
-                                      const base::FilePath& file_path)
-      : FakeArcFileSystemOperationRunner(bridge_service),
-        file_path_(file_path) {}
-  ~ArcFileSystemOperationRunnerForTest() override = default;
-
-  void GetFileSize(const GURL& url,
-                   const GetFileSizeCallback& callback) override {
-    EXPECT_EQ(kArcUrlFile, url.spec());
-    base::File::Info info;
-    EXPECT_TRUE(base::GetFileInfo(file_path_, &info));
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, info.size));
-  }
-
-  void OpenFileToRead(const GURL& url,
-                      const OpenFileToReadCallback& callback) override {
-    base::ScopedFD fd;
-    if (url.spec() == kArcUrlFile) {
-      fd = OpenRegularFileToRead();
-    } else if (url.spec() == kArcUrlPipe) {
-      fd = OpenPipeToRead();
-    } else {
-      LOG(ERROR) << "Unknown URL: " << url.spec();
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(callback, base::Passed(mojo::ScopedHandle())));
-      return;
-    }
-    mojo::edk::ScopedPlatformHandle platform_handle(
-        mojo::edk::PlatformHandle(fd.release()));
-    MojoHandle wrapped_handle;
-    EXPECT_EQ(MOJO_RESULT_OK, mojo::edk::CreatePlatformHandleWrapper(
-                                  std::move(platform_handle), &wrapped_handle));
-
-    mojo::ScopedHandle scoped_handle{mojo::Handle(wrapped_handle)};
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, base::Passed(std::move(scoped_handle))));
-  }
-
- private:
-  // Returns a ScopedFD to read |file_path_|.
-  base::ScopedFD OpenRegularFileToRead() {
-    base::File file(file_path_, base::File::FLAG_OPEN | base::File::FLAG_READ);
-    EXPECT_TRUE(file.IsValid());
-    return base::ScopedFD(file.TakePlatformFile());
-  }
-
-  // Returns a pipe's read end with |file_path_|'s contents written.
-  base::ScopedFD OpenPipeToRead() {
-    // Create a new pipe.
-    int fds[2];
-    if (pipe(fds) != 0) {
-      LOG(ERROR) << "pipe() failed.";
-      return base::ScopedFD();
-    }
-    base::ScopedFD fd_read(fds[0]);
-    base::ScopedFD fd_write(fds[1]);
-    // Put the file's contents to the pipe.
-    std::string contents;
-    if (!base::ReadFileToString(file_path_, &contents) ||
-        !base::WriteFileDescriptor(fd_write.get(), contents.data(),
-                                   contents.length())) {
-      LOG(ERROR) << "Failed to write the file contents to the pipe";
-      return base::ScopedFD();
-    }
-    // Return the read end.
-    return fd_read;
-  }
-
-  base::FilePath file_path_;
-
-  DISALLOW_COPY_AND_ASSIGN(ArcFileSystemOperationRunnerForTest);
-};
-
 class ArcContentFileSystemFileStreamReaderTest : public testing::Test {
  public:
   ArcContentFileSystemFileStreamReaderTest() = default;
@@ -139,20 +60,22 @@ class ArcContentFileSystemFileStreamReaderTest : public testing::Test {
   ~ArcContentFileSystemFileStreamReaderTest() override = default;
 
   void SetUp() override {
-    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-
-    base::FilePath path = temp_dir_.GetPath().AppendASCII("bar");
-    ASSERT_TRUE(base::WriteFile(path, kData, arraysize(kData)));
+    fake_file_system_.AddFile(FakeFileSystemInstance::FileSpec(
+        kArcUrlFile, kData, false /* stream */));
+    fake_file_system_.AddFile(FakeFileSystemInstance::FileSpec(
+        kArcUrlPipe, kData, true /* stream */));
 
     arc_service_manager_ = base::MakeUnique<ArcServiceManager>(nullptr);
     arc_service_manager_->AddService(
-        base::MakeUnique<ArcFileSystemOperationRunnerForTest>(
-            arc_service_manager_->arc_bridge_service(), path));
+        base::WrapUnique(ArcFileSystemOperationRunner::CreateForTesting(
+            arc_service_manager_->arc_bridge_service())));
+    arc_service_manager_->arc_bridge_service()->file_system()->SetInstance(
+        &fake_file_system_);
   }
 
  private:
-  base::ScopedTempDir temp_dir_;
   content::TestBrowserThreadBundle thread_bundle_;
+  FakeFileSystemInstance fake_file_system_;
   std::unique_ptr<ArcServiceManager> arc_service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcContentFileSystemFileStreamReaderTest);
@@ -162,9 +85,9 @@ class ArcContentFileSystemFileStreamReaderTest : public testing::Test {
 
 TEST_F(ArcContentFileSystemFileStreamReaderTest, ReadRegularFile) {
   ArcContentFileSystemFileStreamReader reader(GURL(kArcUrlFile), 0);
-  auto buffer = make_scoped_refptr(new net::IOBufferWithSize(arraysize(kData)));
+  auto buffer = make_scoped_refptr(new net::IOBufferWithSize(strlen(kData)));
   EXPECT_TRUE(ReadData(&reader, buffer.get()));
-  EXPECT_EQ(base::StringPiece(kData, arraysize(kData)),
+  EXPECT_EQ(base::StringPiece(kData, strlen(kData)),
             base::StringPiece(buffer->data(), buffer->size()));
 }
 
@@ -172,17 +95,17 @@ TEST_F(ArcContentFileSystemFileStreamReaderTest, ReadRegularFileWithOffset) {
   constexpr size_t kOffset = 10;
   ArcContentFileSystemFileStreamReader reader(GURL(kArcUrlFile), kOffset);
   auto buffer =
-      make_scoped_refptr(new net::IOBufferWithSize(arraysize(kData) - kOffset));
+      make_scoped_refptr(new net::IOBufferWithSize(strlen(kData) - kOffset));
   EXPECT_TRUE(ReadData(&reader, buffer.get()));
-  EXPECT_EQ(base::StringPiece(kData + kOffset, arraysize(kData) - kOffset),
+  EXPECT_EQ(base::StringPiece(kData + kOffset, strlen(kData) - kOffset),
             base::StringPiece(buffer->data(), buffer->size()));
 }
 
 TEST_F(ArcContentFileSystemFileStreamReaderTest, ReadPipe) {
   ArcContentFileSystemFileStreamReader reader(GURL(kArcUrlPipe), 0);
-  auto buffer = make_scoped_refptr(new net::IOBufferWithSize(arraysize(kData)));
+  auto buffer = make_scoped_refptr(new net::IOBufferWithSize(strlen(kData)));
   EXPECT_TRUE(ReadData(&reader, buffer.get()));
-  EXPECT_EQ(base::StringPiece(kData, arraysize(kData)),
+  EXPECT_EQ(base::StringPiece(kData, strlen(kData)),
             base::StringPiece(buffer->data(), buffer->size()));
 }
 
@@ -190,9 +113,9 @@ TEST_F(ArcContentFileSystemFileStreamReaderTest, ReadPipeWithOffset) {
   constexpr size_t kOffset = 10;
   ArcContentFileSystemFileStreamReader reader(GURL(kArcUrlPipe), kOffset);
   auto buffer =
-      make_scoped_refptr(new net::IOBufferWithSize(arraysize(kData) - kOffset));
+      make_scoped_refptr(new net::IOBufferWithSize(strlen(kData) - kOffset));
   EXPECT_TRUE(ReadData(&reader, buffer.get()));
-  EXPECT_EQ(base::StringPiece(kData + kOffset, arraysize(kData) - kOffset),
+  EXPECT_EQ(base::StringPiece(kData + kOffset, strlen(kData) - kOffset),
             base::StringPiece(buffer->data(), buffer->size()));
 }
 
@@ -200,7 +123,7 @@ TEST_F(ArcContentFileSystemFileStreamReaderTest, GetLength) {
   ArcContentFileSystemFileStreamReader reader(GURL(kArcUrlFile), 0);
 
   net::TestInt64CompletionCallback callback;
-  EXPECT_EQ(static_cast<int64_t>(arraysize(kData)),
+  EXPECT_EQ(static_cast<int64_t>(strlen(kData)),
             callback.GetResult(reader.GetLength(callback.callback())));
 }