app_file_handler_util.cc | Explore in Territory

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

#include "extensions/browser/api/file_handlers/app_file_handler_util.h"

#include <set>
#include <vector>

#include "base/containers/contains.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "components/file_access/scoped_file_access_delegate.h"
#include "components/services/app_service/public/cpp/file_handler.h"
#include "components/services/app_service/public/cpp/file_handler_info.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/child_process_security_policy.h"
#include "extensions/browser/api/extensions_api_client.h"
#include "extensions/browser/entry_info.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/granted_file_entry.h"
#include "extensions/common/permissions/permissions_data.h"
#include "net/base/mime_util.h"
#include "storage/browser/file_system/isolated_context.h"
#include "storage/common/file_system/file_system_mount_option.h"
#include "storage/common/file_system/file_system_types.h"

#if BUILDFLAG(IS_CHROMEOS_ASH)
#include "extensions/browser/api/file_handlers/non_native_file_system_delegate.h"
#endif

namespace extensions {

namespace app_file_handler_util {

const char kFallbackMimeType[] = …;
const char kInvalidParameters[] = …;
const char kSecurityError[] = …;

namespace {

bool FileHandlerCanHandleFileWithExtension(const apps::FileHandlerInfo& handler,
                                           const base::FilePath& path) { … }

bool FileHandlerCanHandleFileWithMimeType(const apps::FileHandlerInfo& handler,
                                          const std::string& mime_type) { … }

bool WebAppFileHandlerCanHandleFileWithExtension(
    const apps::FileHandler& file_handler,
    const base::FilePath& path) { … }

bool WebAppFileHandlerCanHandleFileWithMimeType(
    const apps::FileHandler& file_handler,
    const std::string& mime_type) { … }

bool PrepareNativeLocalFileForWritableApp(const base::FilePath& path,
                                          bool is_directory) { … }

// Checks whether a list of paths are all OK for writing and calls a provided
// on_success or on_failure callback when done. A path is OK for writing if it
// is not a symlink, is not in a blocklisted path and can be opened for writing.
// Creates files if they do not exist, but fails for non-existent directory
// paths. On Chrome OS, also fails for non-local files that don't already exist.
class WritableFileChecker
    : public base::RefCountedThreadSafe<WritableFileChecker> { … };

WritableFileChecker::WritableFileChecker(
    const std::vector<base::FilePath>& paths,
    content::BrowserContext* context,
    const std::set<base::FilePath>& directory_paths,
    base::OnceClosure on_success,
    base::OnceCallback<void(const base::FilePath&)> on_failure)
    : … { … }

void WritableFileChecker::Check() { … }

WritableFileChecker::~WritableFileChecker() = default;

void WritableFileChecker::TaskDone() { … }

// Reports an error in completing a work item. This may be called more than
// once, but only the last message will be retained.
void WritableFileChecker::Error(const base::FilePath& error_path) { … }

void WritableFileChecker::OnPrepareFileDone(const base::FilePath& path,
                                            bool success) { … }

}  // namespace

WebAppFileHandlerMatch::WebAppFileHandlerMatch(
    const apps::FileHandler* file_handler)
    : … { … }
WebAppFileHandlerMatch::~WebAppFileHandlerMatch() = default;

const apps::FileHandler& WebAppFileHandlerMatch::file_handler() const { … }

bool WebAppFileHandlerMatch::matched_mime_type() const { … }

bool WebAppFileHandlerMatch::matched_file_extension() const { … }

bool WebAppFileHandlerMatch::DoMatch(const EntryInfo& entry) { … }

const apps::FileHandlerInfo* FileHandlerForId(const Extension& app,
                                              const std::string& handler_id) { … }

std::vector<FileHandlerMatch> FindFileHandlerMatchesForEntries(
    const Extension& app,
    const std::vector<EntryInfo>& entries) { … }

std::vector<FileHandlerMatch> MatchesFromFileHandlersForEntries(
    const FileHandlersInfo& file_handlers,
    const std::vector<EntryInfo>& entries) { … }

std::vector<WebAppFileHandlerMatch> MatchesFromWebAppFileHandlersForEntries(
    const apps::FileHandlers& file_handlers,
    const std::vector<EntryInfo>& entries) { … }

bool FileHandlerCanHandleEntry(const apps::FileHandlerInfo& handler,
                               const EntryInfo& entry) { … }

bool WebAppFileHandlerCanHandleEntry(const apps::FileHandler& handler,
                                     const EntryInfo& entry) { … }

GrantedFileEntry CreateFileEntryWithPermissions(int renderer_id,
                                                const base::FilePath& path,
                                                bool can_write,
                                                bool can_create,
                                                bool can_delete) { … }

GrantedFileEntry CreateFileEntry(content::BrowserContext* /* context */,
                                 const Extension* extension,
                                 int renderer_id,
                                 const base::FilePath& path,
                                 bool is_directory) { … }

void PrepareFilesForWritableApp(
    const std::vector<base::FilePath>& paths,
    content::BrowserContext* context,
    const std::set<base::FilePath>& directory_paths,
    base::OnceClosure on_success,
    base::OnceCallback<void(const base::FilePath&)> on_failure) { … }

bool HasFileSystemWritePermission(const Extension* extension) { … }

bool ValidateFileEntryAndGetPath(const std::string& filesystem_name,
                                 const std::string& filesystem_path,
                                 int render_process_id,
                                 base::FilePath* file_path,
                                 std::string* error) { … }

std::vector<extensions::EntryInfo> CreateEntryInfos(
    const std::vector<base::FilePath>& entry_paths,
    const std::vector<std::string>& mime_types,
    const std::set<base::FilePath>& directory_paths) { … }

}  // namespace app_file_handler_util

}  // namespace extensions
chromium/extensions/browser/api/file_handlers/app_file_handler_util.cc
