ash / components / arc / test / fake_file_system_instance.h [blame]

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ASH_COMPONENTS_ARC_TEST_FAKE_FILE_SYSTEM_INSTANCE_H_
#define ASH_COMPONENTS_ARC_TEST_FAKE_FILE_SYSTEM_INSTANCE_H_

#include <stdint.h>

#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "ash/components/arc/mojom/file_system.mojom.h"
#include "base/files/scoped_temp_dir.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "storage/browser/file_system/watcher_manager.h"
#include "url/gurl.h"

namespace arc {

// Fake implementation to operate on documents in memory.
//
// ArcFileSystemOperationRunner provides two types of methods: content URL
// based and documents provider based. According to backend type, you need
// to setup the fake with different functions.
//
// Content URL based functions are:
// - GetFileSize()
// - GetMimeType()
// - CloseFileSession()
// - OpenFileSessionToWrite()
// - OpenFileSessionToRead()
// Fake files for those functions can be set up by AddFile().
//
// Documents provider based functions are:
// - GetDocument()
// - GetChildDocuments()
// - GetRecentDocuments()
// - GetRoots()
// - GetRootSize()
// - DeleteDocument()
// - RenameDocument()
// - CreateDocument()
// - CopyDocument()
// - MoveDocument()
// Fake documents for those functions can be set up by AddDocument() and fake
// roots for those functions can be set up by AddRoot().
//
// Notes:
// - GetChildDocuments() returns child documents in the same order as they were
//   added with AddDocument().
// - GetRecentDocuments() returns recent documents in the same order as they
//   were added with AddRecentDocument().
// - OpenFileSessionToRead(), OpenFileSessionToWrite() will fail unless
//   AddFile() for the file to open is called beforehand.
// - Callbacks are never invoked synchronously.
// - All member functions must be called on the same thread.
class FakeFileSystemInstance : public mojom::FileSystemInstance {
 public:
  // Specification of a fake file available to content URL based methods.
  using GetLastChangeTimeCallback =
      base::RepeatingCallback<base::Time(const base::FilePath& path)>;

  // TODO(risan): Consider if this is really needed, and whether we should just
  // use the simpler option by using the original directory as is.
  // The path for the top level directory considered in MediaStore.
  static constexpr base::FilePath::CharType kFakeAndroidPath[] =
      FILE_PATH_LITERAL("/android/path");

  // Expected size in OpenThumbnail calls.
  static constexpr gfx::Size kDefaultThumbnailSize = gfx::Size(360, 360);

  struct File {
    enum class Seekable {
      NO,
      YES,
    };

    // Content URL of a file.
    std::string url;

    // The content of a file, which can be read by OpenFileSessionToRead().
    // When Seekable.NO is specified and OpenFileSessionToWrite() is called,
    // this |content| will be ignored and bytes written to FD from
    // OpenFileSessionToWrite() will be read by OpenFileSessionToRead().
    std::string content;

    // The MIME type of a file.
    std::string mime_type;

    // Whether this file is seekable or not.
    Seekable seekable;

    // The thumbnail of a file, which can be read by OpenThumbnail().
    std::string thumbnail_content;

    File(const std::string& url,
         const std::string& content,
         const std::string& mime_type,
         Seekable seekable);
    File(const File& that);
    ~File();

    size_t size() const { return content.size(); }
  };

  // Specification of a fake document available to documents provider based
  // methods.
  struct Document {
    // Authority.
    std::string authority;

    // ID of this document.
    std::string document_id;

    // ID of the parent document. Can be empty if this is a root.
    std::string parent_document_id;

    // File name displayed to users.
    std::string display_name;

    // MIME type.
    std::string mime_type;

    // File size in bytes. Set to -1 if size is not available.
    int64_t size;

    // Last modified time in milliseconds from the UNIX epoch.
    // TODO(crbug.com/40497368): Use base::Time once the corresponding field
    // in file_system.mojom stops using uint64.
    uint64_t last_modified;

    // Flag indicating that a document is deletable.
    bool supports_delete;

    // Flag indicating that a document can be renamed.
    bool supports_rename;

    // Flag indicating that a document is a directory that supports creation of
    // new files within it.
    bool dir_supports_create;

    // Flag indicating that a document supports openDocumentThumbnail() call.
    bool supports_thumbnail;

    Document(const std::string& authority,
             const std::string& document_id,
             const std::string& parent_document_id,
             const std::string& display_name,
             const std::string& mime_type,
             int64_t size,
             uint64_t last_modified);
    Document(const std::string& authority,
             const std::string& document_id,
             const std::string& parent_document_id,
             const std::string& display_name,
             const std::string& mime_type,
             int64_t size,
             uint64_t last_modified,
             bool supports_delete,
             bool supports_rename,
             bool dir_supports_create,
             bool supports_thumbnail);
    Document(const Document& that);
    ~Document();
  };

  // Specification of a fake root available to documents provider based methods.
  struct Root {
    // Authority.
    std::string authority;

    // ID of this root.
    std::string root_id;

    // ID of the document which is a directory that represents the top
    // directory of this root.
    std::string document_id;

    // Title of this root.
    std::string title;

    // Available bytes in this root.
    int64_t available_bytes;

    // Capacity bytes in this root.
    int64_t capacity_bytes;

    Root(const std::string& authority,
         const std::string& root_id,
         const std::string& document_id,
         const std::string& title,
         int64_t available_bytes,
         int64_t capacity_bytes);
    Root(const Root& that);
    ~Root();
  };

  FakeFileSystemInstance();

  FakeFileSystemInstance(const FakeFileSystemInstance&) = delete;
  FakeFileSystemInstance& operator=(const FakeFileSystemInstance&) = delete;

  ~FakeFileSystemInstance() override;

  // Returns true if Init() has been called.
  bool InitCalled();

  // Adds a file accessible by content URL based methods.
  void AddFile(const File& file);

  // Adds a document accessible by document provider based methods.
  void AddDocument(const Document& document);

  // Adds a recent document accessible by document provider based methods.
  void AddRecentDocument(const std::string& root_id, const Document& document);

  // Removes a recent document accessible by document provider based methods.
  void RemoveRecentDocument(const Document& document);

  // Adds a root accessible by document provider based methods.
  void AddRoot(const Root& root);

  // Add a file descriptor accessible by a URL ID.
  void AddOpenSession(const std::string& url_id, const int fd);

  // Fake the GetLastChangedTime implementation.
  void SetGetLastChangeTimeCallback(GetLastChangeTimeCallback ctime_callback);

  // Sets the path for the top level cros directory considered in MediaStore.
  // TODO(risan): Consider to not use this (if we go without different android
  // path approach). Another possibility to consider is probably to bind mount
  // the directory in the caller test and do android_path conversion for the
  // caller? In any case, this we don't want cros to be exposed to this instance
  // that lives under Android.
  void SetCrosDir(const base::FilePath& cros_dir);

  // Sets the initial media store content.
  void SetMediaStore(const std::map<base::FilePath, base::Time>& media_store);

  // Triggers watchers installed to a document.
  void TriggerWatchers(const std::string& authority,
                       const std::string& document_id,
                       storage::WatcherManager::ChangeType type);

  // Returns how many times GetChildDocuments() was called.
  int get_child_documents_count() const { return get_child_documents_count_; }

  // Returns true if there is a document with the given authority and
  // document_id.
  bool DocumentExists(const std::string& authority,
                      const std::string& document_id);

  // Returns true if there is a document with the given authority,
  // root's document_id, and file path from the root.
  bool DocumentExists(const std::string& authority,
                      const std::string& root_document_id,
                      const base::FilePath& path);

  // Returns true if there is a root with the given authority and root_id.
  bool RootExists(const std::string& authority, const std::string& root_id);

  // Returns a document with the given authority and document_id.
  Document GetDocument(const std::string& authority,
                       const std::string& document_id);

  // Returns a document with the given authority, root's document_id, and file
  // path from the root.
  Document GetDocument(const std::string& authority,
                       const std::string& document_id,
                       const base::FilePath& path);

  // Returns the content written to the FD returned by OpenFileSessionToWrite().
  std::string GetFileContent(const std::string& url);

  // Returns the content written to the FD returned by OpenFileSessionToWrite(),
  // up to |bytes| bytes.
  std::string GetFileContent(const std::string& url, size_t bytes);

  // For clearing the list of handled requests
  void clear_handled_requests() { handled_url_requests_.clear(); }

  // For validating the url requests in testing.
  const std::vector<mojom::OpenUrlsRequestPtr>& handledUrlRequests() const {
    return handled_url_requests_;
  }

  // Returns the content of the fake media store index.
  const std::map<base::FilePath, base::Time>& GetMediaStore() const {
    return media_store_;
  }

  // mojom::FileSystemInstance:
  void AddWatcher(const std::string& authority,
                  const std::string& document_id,
                  AddWatcherCallback callback) override;
  void GetChildDocuments(const std::string& authority,
                         const std::string& document_id,
                         GetChildDocumentsCallback callback) override;
  void GetDocument(const std::string& authority,
                   const std::string& document_id,
                   GetDocumentCallback callback) override;
  void GetFileSize(const std::string& url,
                   GetFileSizeCallback callback) override;
  void GetMimeType(const std::string& url,
                   GetMimeTypeCallback callback) override;
  void GetRecentDocuments(const std::string& authority,
                          const std::string& root_id,
                          GetRecentDocumentsCallback callback) override;
  void GetRoots(GetRootsCallback callback) override;
  void GetRootSize(const std::string& authority,
                   const std::string& root_id,
                   GetRootSizeCallback callback) override;
  void DeleteDocument(const std::string& authority,
                      const std::string& document_id,
                      DeleteDocumentCallback callback) override;
  void RenameDocument(const std::string& authority,
                      const std::string& document_id,
                      const std::string& display_name,
                      RenameDocumentCallback callback) override;
  void CreateDocument(const std::string& authority,
                      const std::string& parent_document_id,
                      const std::string& mime_type,
                      const std::string& display_name,
                      CreateDocumentCallback callback) override;
  void CopyDocument(const std::string& authority,
                    const std::string& source_document_id,
                    const std::string& target_parent_document_id,
                    CopyDocumentCallback callback) override;
  void MoveDocument(const std::string& authority,
                    const std::string& source_document_id,
                    const std::string& source_parent_document_id,
                    const std::string& target_parent_document_id,
                    MoveDocumentCallback callback) override;
  void Init(mojo::PendingRemote<mojom::FileSystemHost> host,
            InitCallback callback) override;
  void CloseFileSession(const std::string& url_id,
                        const std::string& error_message) override;
  void OpenFileSessionToWrite(const GURL& url,
                              OpenFileSessionToWriteCallback callback) override;
  void OpenFileSessionToRead(const GURL& url,
                             OpenFileSessionToReadCallback callback) override;
  void OpenThumbnail(const std::string& url,
                     const gfx::Size& size_hint,
                     OpenThumbnailCallback callback) override;
  void RemoveWatcher(int64_t watcher_id,
                     RemoveWatcherCallback callback) override;
  void RequestMediaScan(const std::vector<std::string>& paths) override;
  void RequestFileRemovalScan(
      const std::vector<std::string>& directory_paths) override;
  void ReindexDirectory(const std::string& directory_path) override;
  void OpenUrlsWithPermissionAndWindowInfo(
      mojom::OpenUrlsRequestPtr request,
      mojom::WindowInfoPtr window_info,
      OpenUrlsWithPermissionAndWindowInfoCallback callback) override;

 private:
  // A pair of an authority and a document ID which identifies the location
  // of a document in documents providers.
  using DocumentKey = std::pair<std::string, std::string>;

  // A pair of an authority and a root ID which identifies a root in
  // documents providers.
  using RootKey = std::pair<std::string, std::string>;

  // Finds a document inside a document with parent_document_id by following
  // given path components.
  std::string FindChildDocumentId(const std::string& authority,
                                  const std::string& parent_document_id,
                                  const std::vector<std::string>& components);

  // Creates a regular file with the given flags and returns its fd.
  base::ScopedFD CreateRegularFileDescriptor(const File& file, uint32_t flags);

  // Returns a FD to non-seekable file to read. |content| content will be
  // returned when reading the FD.
  base::ScopedFD CreateStreamFileDescriptorToRead(const std::string& content);

  // Returns a FD to non-seekable file to write. Bytes written to the FD can be
  // read by calling GetFileContent() with the passed |url|.
  base::ScopedFD CreateStreamFileDescriptorToWrite(const std::string& url);

  // Returns the cros file path for |android_path|.
  base::FilePath GetCrosPath(const base::FilePath& android_path) const;

  THREAD_CHECKER(thread_checker_);

  base::ScopedTempDir temp_dir_;

  mojo::Remote<mojom::FileSystemHost> host_remote_;

  // Mapping from a content URL to a file.
  std::map<std::string, File> files_;

  // Mapping from a content URL to a file path of a created regular file.
  std::map<std::string, base::FilePath> regular_file_paths_;

  // Mapping from a content URL to a read end of a pipe.
  // The corresponding write end should have been returned from
  // OpenFileSessionToWrite() on non-seekable file entry.
  std::map<std::string, base::ScopedFD> pipe_read_ends_;

  // Mapping from a document key to a document.
  std::map<DocumentKey, Document> documents_;

  // Mapping from a document key to its child documents.
  std::map<DocumentKey, std::vector<DocumentKey>> child_documents_;

  // Mapping from a root key to its recent documents.
  std::map<RootKey, std::vector<Document>> recent_documents_;

  // Mapping from a root key to a root.
  std::map<RootKey, Root> roots_;

  // Mapping from a document key to its watchers.
  std::map<DocumentKey, std::set<int64_t>> document_to_watchers_;

  // Mapping from a watcher ID to a document key.
  std::map<int64_t, DocumentKey> watcher_to_document_;

  // Mapping of open URL ID to a file descriptor.
  std::map<std::string, int> open_urls_;

  // List of all OpenUrlsRequests made to the fake_file_system_instance
  std::vector<mojom::OpenUrlsRequestPtr> handled_url_requests_;

  // List of roots added by AddRoot().
  std::vector<Root> roots_list_;

  // Fake MediaStore database index.
  std::map<base::FilePath, base::Time> media_store_;

  // Fake GetLastChangedTime function callback.
  GetLastChangeTimeCallback ctime_callback_;

  // The path for the top level cros directory considered in MediaStore.
  base::FilePath cros_dir_;

  int64_t next_watcher_id_ = 1;
  int get_child_documents_count_ = 0;
};

}  // namespace arc

#endif  // ASH_COMPONENTS_ARC_TEST_FAKE_FILE_SYSTEM_INSTANCE_H_