// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/file_system_provider/operations/get_metadata.h"
#include <stdint.h>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include "base/ranges/algorithm.h"
#include "base/time/time.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "chrome/common/extensions/api/file_system_provider.h"
#include "chrome/common/extensions/api/file_system_provider_internal.h"
namespace ash::file_system_provider::operations {
namespace {
// Convert |value| into |output|. If parsing fails, then returns false.
bool ConvertRequestValueToFileInfo(const RequestValue& value,
int fields,
bool root_entry,
EntryMetadata* output) {
using extensions::api::file_system_provider::EntryMetadata;
using extensions::api::file_system_provider_internal::
GetMetadataRequestedSuccess::Params;
const Params* params = value.get_metadata_success_params();
if (!params)
return false;
if (!ValidateIDLEntryMetadata(params->metadata, fields, root_entry))
return false;
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_NAME)
output->name = std::make_unique<std::string>(*params->metadata.name);
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_IS_DIRECTORY)
output->is_directory =
std::make_unique<bool>(*params->metadata.is_directory);
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_SIZE)
output->size =
std::make_unique<int64_t>(static_cast<int64_t>(*params->metadata.size));
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME) {
const std::string* input_modification_time =
params->metadata.modification_time->additional_properties.FindString(
"value");
if (input_modification_time) {
// Allow to pass invalid modification time, since there is no way to
// verify it easily on any earlier stage.
base::Time output_modification_time;
std::ignore = base::Time::FromString(input_modification_time->c_str(),
&output_modification_time);
output->modification_time =
std::make_unique<base::Time>(output_modification_time);
}
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MIME_TYPE &&
params->metadata.mime_type) {
output->mime_type =
std::make_unique<std::string>(*params->metadata.mime_type);
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL &&
params->metadata.thumbnail) {
output->thumbnail =
std::make_unique<std::string>(*params->metadata.thumbnail);
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_IDENTIFIER &&
params->metadata.cloud_identifier) {
output->cloud_identifier = std::make_unique<CloudIdentifier>(
params->metadata.cloud_identifier->provider_name,
params->metadata.cloud_identifier->id);
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_FILE_INFO &&
params->metadata.cloud_file_info &&
params->metadata.cloud_file_info->version_tag.has_value()) {
output->cloud_file_info = std::make_unique<CloudFileInfo>(
params->metadata.cloud_file_info->version_tag.value());
}
return true;
}
} // namespace
bool ValidateIDLEntryMetadata(
const extensions::api::file_system_provider::EntryMetadata& metadata,
int fields,
bool root_entry) {
using extensions::api::file_system_provider::EntryMetadata;
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_IS_DIRECTORY &&
!metadata.is_directory) {
return false;
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_NAME &&
(!metadata.name || !ValidateName(*metadata.name, root_entry))) {
return false;
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_SIZE &&
!metadata.size) {
return false;
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME) {
if (!metadata.modification_time)
return false;
const std::string* input_modification_time =
metadata.modification_time->additional_properties.FindString("value");
if (!input_modification_time) {
return false;
}
}
// Empty MIME type is not allowed, but for backward compability it's
// accepted. Note, that there is a warning in custom bindings for it.
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL &&
metadata.thumbnail) {
// Sanity check for the thumbnail format. Note, that another, more
// granural check is done in custom bindings. Note, this is an extra check
// only for the security reasons.
const std::string expected_prefix = "data:";
std::string thumbnail_prefix =
metadata.thumbnail->substr(0, expected_prefix.size());
base::ranges::transform(thumbnail_prefix, thumbnail_prefix.begin(),
::tolower);
if (expected_prefix != thumbnail_prefix)
return false;
}
if (fields & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_IDENTIFIER &&
(!metadata.cloud_identifier ||
!ValidateCloudIdentifier(*metadata.cloud_identifier))) {
return false;
}
return true;
}
bool ValidateName(const std::string& name, bool root_entry) {
if (root_entry)
return name.empty();
return !name.empty() && name.find('/') == std::string::npos;
}
bool ValidateCloudIdentifier(
const extensions::api::file_system_provider::CloudIdentifier&
cloud_identifier) {
return !cloud_identifier.provider_name.empty() &&
!cloud_identifier.id.empty();
}
GetMetadata::GetMetadata(
RequestDispatcher* dispatcher,
const ProvidedFileSystemInfo& file_system_info,
const base::FilePath& entry_path,
ProvidedFileSystemInterface::MetadataFieldMask fields,
ProvidedFileSystemInterface::GetMetadataCallback callback)
: Operation(dispatcher, file_system_info),
entry_path_(entry_path),
fields_(fields),
callback_(std::move(callback)) {
DCHECK_NE(0, fields_);
}
GetMetadata::~GetMetadata() = default;
bool GetMetadata::Execute(int request_id) {
using extensions::api::file_system_provider::GetMetadataRequestedOptions;
GetMetadataRequestedOptions options;
options.file_system_id = file_system_info_.file_system_id();
options.request_id = request_id;
options.entry_path = entry_path_.AsUTF8Unsafe();
options.is_directory =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_IS_DIRECTORY;
options.name = fields_ & ProvidedFileSystemInterface::METADATA_FIELD_NAME;
options.size = fields_ & ProvidedFileSystemInterface::METADATA_FIELD_SIZE;
options.modification_time =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME;
options.mime_type =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_MIME_TYPE;
options.thumbnail =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL;
options.cloud_identifier =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_IDENTIFIER;
options.cloud_file_info =
fields_ & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_FILE_INFO;
return SendEvent(
request_id,
extensions::events::FILE_SYSTEM_PROVIDER_ON_GET_METADATA_REQUESTED,
extensions::api::file_system_provider::OnGetMetadataRequested::kEventName,
extensions::api::file_system_provider::OnGetMetadataRequested::Create(
options));
}
void GetMetadata::OnSuccess(/*request_id=*/int,
const RequestValue& result,
bool has_more) {
DCHECK(callback_);
std::unique_ptr<EntryMetadata> metadata(new EntryMetadata);
const bool convert_result = ConvertRequestValueToFileInfo(
result, fields_, entry_path_.AsUTF8Unsafe() == FILE_PATH_LITERAL("/"),
metadata.get());
if (!convert_result) {
LOG(ERROR) << "Failed to parse a response for the get metadata operation.";
std::move(callback_).Run(nullptr, base::File::FILE_ERROR_IO);
return;
}
std::move(callback_).Run(std::move(metadata), base::File::FILE_OK);
}
void GetMetadata::OnError(/*request_id=*/int,
/*result=*/const RequestValue&,
base::File::Error error) {
DCHECK(callback_);
std::move(callback_).Run(nullptr, error);
}
} // namespace ash::file_system_provider::operations
Codebase Browser
chromium