Clean up ARC file system unit tests.

components/arc/test/fake_file_system_instance.cc

 // Copyright 2016 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 "components/arc/test/fake_file_system_instance.h"
 
+#include <string.h>
+#include <unistd.h>
+
 #include "base/bind.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/optional.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "mojo/public/cpp/system/handle.h"
+#include "mojo/edk/embedder/embedder.h"
 
 namespace arc {
 
-FakeFileSystemInstance::FakeFileSystemInstance() = default;
+namespace {
 
-FakeFileSystemInstance::~FakeFileSystemInstance() = default;
+base::ScopedFD CreateRegularFileDescriptor(const char* content,
+                                           const base::FilePath& temp_dir) {
+  base::FilePath path;
+  bool create_success = base::CreateTemporaryFileInDir(temp_dir, &path);
+  DCHECK(create_success);
+  int written_size = base::WriteFile(path, content, strlen(content));
+  DCHECK_EQ(static_cast<int>(strlen(content)), written_size);
+  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  DCHECK(file.IsValid());
+  return base::ScopedFD(file.TakePlatformFile());
+}
 
-void FakeFileSystemInstance::GetChildDocuments(
-    const std::string& authority,
-    const std::string& document_id,
-    const GetChildDocumentsCallback& callback) {
+base::ScopedFD CreateStreamFileDescriptor(const char* content) {
+  int fds[2];
+  int ret = pipe(fds);
+  DCHECK_EQ(0, ret);
+  base::ScopedFD fd_read(fds[0]);
+  base::ScopedFD fd_write(fds[1]);
+  bool write_success =
+      base::WriteFileDescriptor(fd_write.get(), content, strlen(content));
+  DCHECK(write_success);
+  return fd_read;
+}
+
+mojom::DocumentPtr MakeDocument(
+    const FakeFileSystemInstance::DocumentSpec& spec) {
+  mojom::DocumentPtr document = mojom::Document::New();
+  document->document_id = spec.document_id;
+  document->display_name = spec.display_name;
+  document->mime_type = spec.mime_type;
+  document->size = spec.size;
+  document->last_modified = spec.last_modified;
+  return document;
+}
+
+}  // namespace
+
+FakeFileSystemInstance::FakeFileSystemInstance() {
+  DCHECK(thread_checker_.CalledOnValidThread());

[hidehiko, 2017/01/27 15:50:00]

This looks redundant, because |thread_checker_| is initialized in the ctor,
here, so it always succeeds.

[Shuhei Takahashi, 2017/01/30 02:27:35]

Done.

+  bool temp_dir_created = temp_dir_.CreateUniqueTempDir();
+  DCHECK(temp_dir_created);
+}
+
+FakeFileSystemInstance::~FakeFileSystemInstance() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void FakeFileSystemInstance::AddFile(const FileSpec& spec) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(0u, files_.count(std::string(spec.url)));
+  files_[std::string(spec.url)] = spec;
+}
+
+void FakeFileSystemInstance::AddDocument(const DocumentSpec& spec) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DocumentKey key(spec.authority, spec.document_id);
+  DCHECK_EQ(0u, documents_.count(key));
+  documents_[key] = spec;
+  child_documents_[key];  // Allocate a vector.
+  if (spec.parent_document_id) {
+    DocumentKey parent_key(spec.authority, spec.parent_document_id);
+    DCHECK_EQ(1u, documents_.count(parent_key));
+    child_documents_[parent_key].push_back(key);
+  }
+}
+
+void FakeFileSystemInstance::GetFileSize(const std::string& url,
+                                         const GetFileSizeCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto iter = files_.find(url);
+  if (iter == files_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  base::Bind(callback, -1));
+    return;
+  }
+  const FileSpec& spec = iter->second;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback, base::nullopt));
+      FROM_HERE, base::Bind(callback, strlen(spec.content)));
+}
+
+void FakeFileSystemInstance::OpenFileToRead(
+    const std::string& url,
+    const OpenFileToReadCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto iter = files_.find(url);
+  if (iter == files_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, base::Passed(mojo::ScopedHandle())));
+    return;
+  }
+  const FileSpec& spec = iter->second;
+  base::ScopedFD fd =
+      spec.seekable == FileSpec::SEEKABLE
+          ? CreateRegularFileDescriptor(spec.content, temp_dir_.GetPath())
+          : CreateStreamFileDescriptor(spec.content);
+  mojo::edk::ScopedPlatformHandle platform_handle(
+      mojo::edk::PlatformHandle(fd.release()));
+  MojoHandle wrapped_handle;
+  MojoResult result = mojo::edk::CreatePlatformHandleWrapper(
+      std::move(platform_handle), &wrapped_handle);
+  DCHECK_EQ(MOJO_RESULT_OK, result);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, base::Passed(mojo::ScopedHandle(
+                                          mojo::Handle(wrapped_handle)))));
 }
 
 void FakeFileSystemInstance::GetDocument(const std::string& authority,
                                          const std::string& document_id,
                                          const GetDocumentCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto iter = documents_.find(DocumentKey(authority, document_id));
+  if (iter == documents_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, base::Passed(mojom::DocumentPtr())));
+    return;
+  }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback, base::Passed(mojom::DocumentPtr())));
+      FROM_HERE,
+      base::Bind(callback, base::Passed(MakeDocument(iter->second))));
 }
 
-void FakeFileSystemInstance::GetFileSize(const std::string& url,
-                                         const GetFileSizeCallback& callback) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(callback, -1));
-}
-
-void FakeFileSystemInstance::OpenFileToRead(
-    const std::string& url,
-    const OpenFileToReadCallback& callback) {
+void FakeFileSystemInstance::GetChildDocuments(
+    const std::string& authority,
+    const std::string& parent_document_id,
+    const GetChildDocumentsCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto iter = child_documents_.find(DocumentKey(authority, parent_document_id));
+  if (iter == child_documents_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, base::nullopt));
+    return;
+  }
+  std::vector<mojom::DocumentPtr> children;
+  for (const auto& child_key : iter->second) {
+    children.emplace_back(MakeDocument(documents_[child_key]));
+  }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback, base::Passed(mojo::ScopedHandle())));
+      FROM_HERE,
+      base::Bind(callback,
+                 base::Passed(base::make_optional(std::move(children)))));
 }
 
 void FakeFileSystemInstance::RequestMediaScan(
     const std::vector<std::string>& paths) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   // Do nothing and pretend we scaned them.
 }
 
 }  // namespace arc