// Copyright 2013 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/extensions/file_manager/private_api_drive.h"
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string_view>
#include <utility>
#include "ash/constants/ash_features.h"
#include "base/base64.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/i18n/string_search.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/strcat.h"
#include "base/strings/string_split.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/thread_pool.h"
#include "chrome/browser/ash/arc/fileapi/arc_documents_provider_root.h"
#include "chrome/browser/ash/arc/fileapi/arc_documents_provider_root_map.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/extensions/file_manager/event_router.h"
#include "chrome/browser/ash/extensions/file_manager/event_router_factory.h"
#include "chrome/browser/ash/extensions/file_manager/private_api_util.h"
#include "chrome/browser/ash/file_manager/file_tasks.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/url_util.h"
#include "chrome/browser/ash/file_system_provider/mount_path_util.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "chrome/browser/ash/fileapi/external_file_url_util.h"
#include "chrome/browser/ash/fileapi/file_system_backend.h"
#include "chrome/browser/ash/fileapi/recent_drive_source.h"
#include "chrome/browser/ash/fusebox/fusebox_server.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chromeos/drivefs/drivefs_native_message_host.h"
#include "chrome/browser/chromeos/drivefs/drivefs_native_message_host_origins.h"
#include "chrome/browser/net/system_network_context_manager.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/signin/identity_manager_factory.h"
#include "chrome/browser/ui/webui/ash/manage_mirrorsync/manage_mirrorsync_dialog.h"
#include "chrome/common/extensions/api/file_manager_private.h"
#include "chrome/common/extensions/api/file_manager_private_internal.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chromeos/ash/components/drivefs/drivefs_pinning_manager.h"
#include "chromeos/ash/components/drivefs/drivefs_util.h"
#include "chromeos/ash/components/drivefs/mojom/drivefs.mojom.h"
#include "chromeos/ash/components/network/network_handler.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "components/drive/chromeos/search_metadata.h"
#include "components/drive/drive_pref_names.h"
#include "components/drive/event_logger.h"
#include "components/drive/file_errors.h"
#include "components/prefs/pref_service.h"
#include "components/signin/public/base/consent_level.h"
#include "components/signin/public/identity_manager/identity_manager.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/storage_partition.h"
#include "extensions/browser/extension_registry.h"
#include "google_apis/common/auth_service.h"
#include "google_apis/drive/drive_api_url_generator.h"
#include "google_apis/gaia/gaia_constants.h"
#include "mojo/public/cpp/bindings/callback_helpers.h"
#include "services/network/public/cpp/network_connection_tracker.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "storage/common/file_system/file_system_info.h"
#include "storage/common/file_system/file_system_util.h"
#include "url/gurl.h"
namespace extensions {
namespace {
using ash::file_system_provider::EntryMetadata;
using ash::file_system_provider::ProvidedFileSystemInterface;
using ash::file_system_provider::util::FileSystemURLParser;
using content::BrowserThread;
using drive::DriveIntegrationService;
using drive::util::GetIntegrationServiceByProfile;
using drivefs::pinning::PinningManager;
using extensions::api::file_manager_private::EntryProperties;
using extensions::api::file_manager_private::EntryPropertyName;
using file_manager::util::EntryDefinition;
using file_manager::util::EntryDefinitionCallback;
using file_manager::util::EntryDefinitionList;
using file_manager::util::EntryDefinitionListCallback;
using file_manager::util::FileDefinition;
using file_manager::util::FileDefinitionList;
using google_apis::DriveApiUrlGenerator;
constexpr char kAvailableOfflinePropertyName[] = "availableOffline";
// Thresholds for logging slow operations.
constexpr base::TimeDelta kDriveSlowOperationThreshold = base::Seconds(5);
constexpr base::TimeDelta kDriveVerySlowOperationThreshold = base::Minutes(1);
class SingleEntryPropertiesGetterForFileSystemProvider {
public:
typedef base::OnceCallback<void(std::unique_ptr<EntryProperties> properties,
base::File::Error error)>
ResultCallback;
// Creates an instance and starts the process.
static void Start(const storage::FileSystemURL file_system_url,
const std::set<EntryPropertyName>& names,
ResultCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
SingleEntryPropertiesGetterForFileSystemProvider* instance =
new SingleEntryPropertiesGetterForFileSystemProvider(
file_system_url, names, std::move(callback));
instance->StartProcess();
// The instance will be destroyed by itself.
}
virtual ~SingleEntryPropertiesGetterForFileSystemProvider() = default;
private:
SingleEntryPropertiesGetterForFileSystemProvider(
const storage::FileSystemURL& file_system_url,
const std::set<EntryPropertyName>& names,
ResultCallback callback)
: callback_(std::move(callback)),
file_system_url_(file_system_url),
names_(names),
properties_(new EntryProperties) {
DCHECK(!callback_.is_null());
}
void StartProcess() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
FileSystemURLParser parser(file_system_url_);
if (!parser.Parse()) {
CompleteGetEntryProperties(base::File::FILE_ERROR_NOT_FOUND);
return;
}
ProvidedFileSystemInterface::MetadataFieldMask field_mask =
ProvidedFileSystemInterface::METADATA_FIELD_NONE;
if (names_.find(api::file_manager_private::EntryPropertyName::kSize) !=
names_.end()) {
field_mask |= ProvidedFileSystemInterface::METADATA_FIELD_SIZE;
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kModificationTime) !=
names_.end()) {
field_mask |=
ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME;
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kContentMimeType) !=
names_.end()) {
field_mask |= ProvidedFileSystemInterface::METADATA_FIELD_MIME_TYPE;
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kThumbnailUrl) !=
names_.end()) {
field_mask |= ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL;
}
if (!field_mask) {
OnGetMetadataCompleted(nullptr, base::File::FILE_OK);
return;
}
parser.file_system()->GetMetadata(
parser.file_path(), field_mask,
base::BindOnce(&SingleEntryPropertiesGetterForFileSystemProvider::
OnGetMetadataCompleted,
weak_ptr_factory_.GetWeakPtr()));
}
void OnGetMetadataCompleted(std::unique_ptr<EntryMetadata> metadata,
base::File::Error result) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (result != base::File::FILE_OK) {
CompleteGetEntryProperties(result);
return;
}
if (names_.find(api::file_manager_private::EntryPropertyName::kSize) !=
names_.end()) {
properties_->size = *metadata->size;
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kModificationTime) !=
names_.end()) {
properties_->modification_time =
metadata->modification_time->InMillisecondsFSinceUnixEpoch();
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kContentMimeType) !=
names_.end() &&
metadata->mime_type.get()) {
properties_->content_mime_type = *metadata->mime_type;
}
if (names_.find(
api::file_manager_private::EntryPropertyName::kThumbnailUrl) !=
names_.end() &&
metadata->thumbnail.get()) {
properties_->thumbnail_url = *metadata->thumbnail;
}
CompleteGetEntryProperties(base::File::FILE_OK);
}
void CompleteGetEntryProperties(base::File::Error result) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(!callback_.is_null());
std::move(callback_).Run(std::move(properties_), result);
content::GetUIThreadTaskRunner({})->DeleteSoon(FROM_HERE, this);
}
// Given parameters.
ResultCallback callback_;
const storage::FileSystemURL file_system_url_;
const std::set<EntryPropertyName> names_;
// Values used in the process.
std::unique_ptr<EntryProperties> properties_;
base::WeakPtrFactory<SingleEntryPropertiesGetterForFileSystemProvider>
weak_ptr_factory_{this};
}; // class SingleEntryPropertiesGetterForFileSystemProvider
class SingleEntryPropertiesGetterForDocumentsProvider {
public:
typedef base::OnceCallback<void(std::unique_ptr<EntryProperties> properties,
base::File::Error error)>
ResultCallback;
// Creates an instance and starts the process.
static void Start(const storage::FileSystemURL file_system_url,
Profile* const profile,
ResultCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
SingleEntryPropertiesGetterForDocumentsProvider* instance =
new SingleEntryPropertiesGetterForDocumentsProvider(
file_system_url, profile, std::move(callback));
instance->StartProcess();
// The instance will be destroyed by itself.
}
private:
SingleEntryPropertiesGetterForDocumentsProvider(
const storage::FileSystemURL& file_system_url,
Profile* const profile,
ResultCallback callback)
: callback_(std::move(callback)),
file_system_url_(ResolveFuseBoxFSURL(profile, file_system_url)),
profile_(profile),
properties_(new EntryProperties) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(!callback_.is_null());
}
void StartProcess() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
auto* root_map =
arc::ArcDocumentsProviderRootMap::GetForBrowserContext(profile_);
if (!root_map) {
CompleteGetEntryProperties(base::File::FILE_ERROR_NOT_FOUND);
}
base::FilePath path;
auto* root = root_map->ParseAndLookup(file_system_url_, &path);
if (!root) {
CompleteGetEntryProperties(base::File::FILE_ERROR_NOT_FOUND);
return;
}
root->GetExtraFileMetadata(
path, base::BindOnce(&SingleEntryPropertiesGetterForDocumentsProvider::
OnGetExtraFileMetadata,
weak_ptr_factory_.GetWeakPtr()));
}
static storage::FileSystemURL ResolveFuseBoxFSURL(
Profile* profile,
const storage::FileSystemURL& file_system_url) {
if (!base::StartsWith(file_system_url.filesystem_id(),
file_manager::util::kFuseBoxMountNamePrefix)) {
return file_system_url;
}
fusebox::Server* fusebox_server = fusebox::Server::GetInstance();
if (!fusebox_server) {
return storage::FileSystemURL();
}
return fusebox_server->ResolveFilename(profile,
file_system_url.path().value());
}
void OnGetExtraFileMetadata(
base::File::Error error,
const arc::ArcDocumentsProviderRoot::ExtraFileMetadata& metadata) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (error != base::File::FILE_OK) {
CompleteGetEntryProperties(error);
return;
}
properties_->can_delete = metadata.supports_delete;
properties_->can_rename = metadata.supports_rename;
properties_->can_add_children = metadata.dir_supports_create;
if (!metadata.last_modified.is_null()) {
properties_->modification_time =
metadata.last_modified.InMillisecondsFSinceUnixEpochIgnoringNull();
}
properties_->size = metadata.size;
CompleteGetEntryProperties(base::File::FILE_OK);
}
void CompleteGetEntryProperties(base::File::Error error) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(callback_);
std::move(callback_).Run(std::move(properties_), error);
content::GetUIThreadTaskRunner({})->DeleteSoon(FROM_HERE, this);
}
// Given parameters.
ResultCallback callback_;
const storage::FileSystemURL file_system_url_;
const raw_ptr<Profile> profile_;
// Values used in the process.
std::unique_ptr<EntryProperties> properties_;
base::WeakPtrFactory<SingleEntryPropertiesGetterForDocumentsProvider>
weak_ptr_factory_{this};
}; // class SingleEntryPropertiesGetterForDocumentsProvider
void OnSearchDriveFs(
scoped_refptr<ExtensionFunction> function,
bool filter_dirs,
base::OnceCallback<void(std::optional<base::Value::List>)> callback,
drive::FileError error,
std::optional<std::vector<drivefs::mojom::QueryItemPtr>> items) {
Profile* const profile =
Profile::FromBrowserContext(function->browser_context());
DriveIntegrationService* const service =
GetIntegrationServiceByProfile(profile);
if (!service) {
LOG(ERROR) << "No drive service";
std::move(callback).Run(std::nullopt);
return;
}
if (error != drive::FILE_ERROR_OK || !items.has_value()) {
LOG_IF(ERROR, error != drive::FILE_ERROR_OK)
<< "Drive search failed: " << drive::FileErrorToString(error);
std::move(callback).Run(std::nullopt);
return;
}
GURL url;
file_manager::util::ConvertAbsoluteFilePathToFileSystemUrl(
profile, service->GetMountPointPath(), function->source_url(), &url);
const auto fs_root = base::StrCat({url.spec(), "/"});
const auto fs_name = service->GetMountPointPath().BaseName().value();
const base::FilePath root("/");
base::Value::List result;
for (const auto& item : *items) {
base::FilePath path;
if (!root.AppendRelativePath(item->path, &path)) {
path = item->path;
}
base::Value::Dict entry;
entry.Set("fileSystemName", fs_name);
entry.Set("fileSystemRoot", fs_root);
entry.Set("fileFullPath", item->path.AsUTF8Unsafe());
bool is_dir = drivefs::IsADirectory(item->metadata->type);
entry.Set("fileIsDirectory", is_dir);
entry.Set(kAvailableOfflinePropertyName, item->metadata->available_offline);
if (!filter_dirs || !is_dir) {
result.Append(std::move(entry));
}
}
std::move(callback).Run(std::move(result));
}
drivefs::mojom::QueryParameters::QuerySource SearchDriveFs(
scoped_refptr<ExtensionFunction> function,
drivefs::mojom::QueryParametersPtr query,
bool filter_dirs,
base::OnceCallback<void(std::optional<base::Value::List>)> callback) {
DriveIntegrationService* const service = GetIntegrationServiceByProfile(
Profile::FromBrowserContext(function->browser_context()));
auto on_response = base::BindOnce(&OnSearchDriveFs, std::move(function),
filter_dirs, std::move(callback));
return service->GetDriveFsHost()->PerformSearch(std::move(query),
std::move(on_response));
}
void UmaEmitSearchOutcome(
bool success,
bool remote,
FileManagerPrivateSearchDriveMetadataFunction::SearchType type,
const base::TimeTicks& time_started) {
const char* infix = nullptr;
switch (type) {
case FileManagerPrivateSearchDriveMetadataFunction::SearchType::kText:
infix = "TextSearchTime";
break;
case FileManagerPrivateSearchDriveMetadataFunction::SearchType::
kSharedWithMe:
infix = "SharedSearchTime";
break;
case FileManagerPrivateSearchDriveMetadataFunction::SearchType::kOffline:
infix = "OfflineSearchTime";
break;
}
if (remote) {
base::UmaHistogramMediumTimes(
base::StrCat({"DriveCommon.RemoteSearch.", infix,
success ? ".SuccessTime" : ".FailTime"}),
base::TimeTicks::Now() - time_started);
} else {
base::UmaHistogramMediumTimes(
base::StrCat({"DriveCommon.LocalSearch.", infix,
success ? ".SuccessTime" : ".FailTime"}),
base::TimeTicks::Now() - time_started);
}
}
} // namespace
FileManagerPrivateInternalGetEntryPropertiesFunction::
FileManagerPrivateInternalGetEntryPropertiesFunction()
: processed_count_(0) {
SetWarningThresholds(kDriveSlowOperationThreshold,
kDriveVerySlowOperationThreshold);
}
FileManagerPrivateInternalGetEntryPropertiesFunction::
~FileManagerPrivateInternalGetEntryPropertiesFunction() = default;
ExtensionFunction::ResponseAction
FileManagerPrivateInternalGetEntryPropertiesFunction::Run() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
using api::file_manager_private_internal::GetEntryProperties::Params;
const std::optional<Params> params = Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
Profile* const profile = Profile::FromBrowserContext(browser_context());
scoped_refptr<storage::FileSystemContext> file_system_context =
file_manager::util::GetFileSystemContextForRenderFrameHost(
profile, render_frame_host());
properties_list_.resize(params->urls.size());
const std::set<EntryPropertyName> names_as_set(params->names.begin(),
params->names.end());
for (size_t i = 0; i < params->urls.size(); i++) {
const GURL url = GURL(params->urls[i]);
const storage::FileSystemURL file_system_url =
file_system_context->CrackURLInFirstPartyContext(url);
storage::FileSystemType file_system_type = file_system_url.type();
if (file_system_type == storage::kFileSystemTypeFuseBox) {
std::string_view path(file_system_url.path().value());
if (base::StartsWith(path, file_manager::util::kFuseBoxMediaSlashPath)) {
path.remove_prefix(strlen(file_manager::util::kFuseBoxMediaSlashPath));
if (base::StartsWith(path,
file_manager::util::kFuseBoxSubdirPrefixADP)) {
file_system_type = storage::kFileSystemTypeArcDocumentsProvider;
} else if (base::StartsWith(
path, file_manager::util::kFuseBoxSubdirPrefixFSP)) {
file_system_type = storage::kFileSystemTypeProvided;
}
}
}
auto callback =
base::BindOnce(&FileManagerPrivateInternalGetEntryPropertiesFunction::
CompleteGetEntryProperties,
this, i, file_system_url);
switch (file_system_type) {
case storage::kFileSystemTypeProvided:
SingleEntryPropertiesGetterForFileSystemProvider::Start(
file_system_url, names_as_set, std::move(callback));
break;
case storage::kFileSystemTypeDriveFs:
file_manager::util::SingleEntryPropertiesGetterForDriveFs::Start(
file_system_url, profile, std::move(callback));
break;
case storage::kFileSystemTypeArcDocumentsProvider:
SingleEntryPropertiesGetterForDocumentsProvider::Start(
file_system_url, profile, std::move(callback));
break;
default:
// TODO(yawano) Change this to support other voluems (e.g. local) ,and
// integrate fileManagerPrivate.getMimeType to this method.
LOG(ERROR) << "Not supported file system type.";
CompleteGetEntryProperties(i, file_system_url,
base::WrapUnique(new EntryProperties),
base::File::FILE_ERROR_INVALID_OPERATION);
}
}
return RespondLater();
}
void FileManagerPrivateInternalGetEntryPropertiesFunction::
CompleteGetEntryProperties(size_t index,
const storage::FileSystemURL& url,
std::unique_ptr<EntryProperties> properties,
base::File::Error error) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(0 <= processed_count_ && processed_count_ < properties_list_.size());
if (error == base::File::FILE_OK) {
properties->external_file_url =
ash::FileSystemURLToExternalFileURL(url).spec();
}
properties_list_[index] = std::move(*properties);
processed_count_++;
if (processed_count_ < properties_list_.size()) {
return;
}
Respond(
ArgumentList(extensions::api::file_manager_private_internal::
GetEntryProperties::Results::Create(properties_list_)));
}
FileManagerPrivateInternalPinDriveFileFunction::
FileManagerPrivateInternalPinDriveFileFunction() {
SetWarningThresholds(kDriveSlowOperationThreshold,
kDriveVerySlowOperationThreshold);
}
ExtensionFunction::ResponseAction
FileManagerPrivateInternalPinDriveFileFunction::Run() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
using extensions::api::file_manager_private_internal::PinDriveFile::Params;
const std::optional<Params> params = Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
scoped_refptr<storage::FileSystemContext> file_system_context =
file_manager::util::GetFileSystemContextForRenderFrameHost(
Profile::FromBrowserContext(browser_context()), render_frame_host());
const GURL url = GURL(params->url);
const storage::FileSystemURL file_system_url =
file_system_context->CrackURLInFirstPartyContext(url);
switch (file_system_url.type()) {
case storage::kFileSystemTypeDriveFs:
return RunAsyncForDriveFs(file_system_url, params->pin);
default:
return RespondNow(Error("Invalid file system type"));
}
}
ExtensionFunction::ResponseAction
FileManagerPrivateInternalPinDriveFileFunction::RunAsyncForDriveFs(
const storage::FileSystemURL& file_system_url,
bool pin) {
DriveIntegrationService* const service =
drive::DriveIntegrationServiceFactory::FindForProfile(
Profile::FromBrowserContext(browser_context()));
base::FilePath path;
if (!service ||
!service->GetRelativeDrivePath(file_system_url.path(), &path)) {
return RespondNow(Error("Drive is disabled"));
}
drivefs::mojom::DriveFs* const drivefs = service->GetDriveFsInterface();
if (!drivefs) {
return RespondNow(Error("Drive is disabled"));
}
drivefs->SetPinned(
path, pin,
mojo::WrapCallbackWithDefaultInvokeIfNotRun(
base::BindOnce(
&FileManagerPrivateInternalPinDriveFileFunction::OnPinStateSet,
this),
drive::FILE_ERROR_SERVICE_UNAVAILABLE));
return RespondLater();
}
void FileManagerPrivateInternalPinDriveFileFunction::OnPinStateSet(
drive::FileError error) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (error == drive::FILE_ERROR_OK) {
Respond(NoArguments());
} else {
Respond(Error(drive::FileErrorToString(error)));
}
}
FileManagerPrivateSearchDriveFunction::FileManagerPrivateSearchDriveFunction() {
SetWarningThresholds(kDriveSlowOperationThreshold,
kDriveVerySlowOperationThreshold);
}
ExtensionFunction::ResponseAction FileManagerPrivateSearchDriveFunction::Run() {
using extensions::api::file_manager_private::SearchDrive::Params;
const std::optional<Params> params = Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
if (!GetIntegrationServiceByProfile(
Profile::FromBrowserContext(browser_context()))) {
// |integration_service| is NULL if Drive is disabled or not mounted.
return RespondNow(Error("Drive is disabled"));
}
operation_start_ = base::TimeTicks::Now();
is_offline_ = content::GetNetworkConnectionTracker()->IsOffline();
auto query = drivefs::mojom::QueryParameters::New();
query->text_content = params->search_params.query;
if (params->search_params.modified_timestamp.has_value()) {
query->modified_time = base::Time::FromMillisecondsSinceUnixEpoch(
*params->search_params.modified_timestamp);
query->modified_time_operator =
drivefs::mojom::QueryParameters::DateComparisonOperator::kGreaterThan;
}
ash::RecentSource::FileType file_type;
if (!file_manager::util::ToRecentSourceFileType(
params->search_params.category, &file_type)) {
return RespondNow(Error("Unable to convert file category"));
}
auto type_filters = ash::RecentDriveSource::CreateTypeFilters(file_type);
if (type_filters.size() == 1) {
query->mime_type = type_filters.front();
} else if (type_filters.size() > 1) {
query->mime_types = std::move(type_filters);
}
is_offline_ =
SearchDriveFs(
this, std::move(query), false,
base::BindOnce(
&FileManagerPrivateSearchDriveFunction::OnSearchDriveFs, this)) ==
drivefs::mojom::QueryParameters::QuerySource::kLocalOnly;
return RespondLater();
}
void FileManagerPrivateSearchDriveFunction::OnSearchDriveFs(
std::optional<base::Value::List> results) {
using api::file_manager_private::SearchDriveResponse;
if (!results) {
UmaEmitSearchOutcome(
false, !is_offline_,
FileManagerPrivateSearchDriveMetadataFunction::SearchType::kText,
operation_start_);
Respond(Error("No search results"));
return;
}
SearchDriveResponse response;
// Search queries are capped at 100 of items anyway and pagination is
// never actually used, so no need to fill this.
response.next_feed = "";
response.entries.reserve(results.value().size());
for (const auto& e : results.value()) {
auto entry = SearchDriveResponse::EntriesType::FromValue(e);
if (!entry) {
LOG(ERROR) << "Failed to convert entry: " << e.DebugString();
continue;
}
response.entries.push_back(std::move(entry.value()));
}
UmaEmitSearchOutcome(
true, !is_offline_,
FileManagerPrivateSearchDriveMetadataFunction::SearchType::kText,
operation_start_);
Respond(WithArguments(response.ToValue()));
}
FileManagerPrivateSearchDriveMetadataFunction::
FileManagerPrivateSearchDriveMetadataFunction() {
SetWarningThresholds(kDriveSlowOperationThreshold,
kDriveVerySlowOperationThreshold);
}
ExtensionFunction::ResponseAction
FileManagerPrivateSearchDriveMetadataFunction::Run() {
using api::file_manager_private::SearchDriveMetadata::Params;
const std::optional<Params> params = Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
Profile* const profile = Profile::FromBrowserContext(browser_context());
if (drive::EventLogger* logger = file_manager::util::GetLogger(profile)) {
logger->Log(
logging::LOGGING_INFO, "%s[%s] called. (types: '%s', maxResults: '%d')",
name(), request_uuid().AsLowercaseString().c_str(),
api::file_manager_private::ToString(params->search_params.types),
params->search_params.max_results);
}
set_log_on_completion(true);
if (!GetIntegrationServiceByProfile(profile)) {
// |integration_service| is NULL if Drive is disabled or not mounted.
return RespondNow(Error("Drive not available"));
}
operation_start_ = base::TimeTicks::Now();
is_offline_ = true; // Legacy search is assumed offline always.
auto query = drivefs::mojom::QueryParameters::New();
query->sort_field = drivefs::mojom::QueryParameters::SortField::kLastModified;
query->sort_direction =
drivefs::mojom::QueryParameters::SortDirection::kDescending;
if (!params->search_params.query.empty()) {
query->title = params->search_params.query;
query->query_source =
drivefs::mojom::QueryParameters::QuerySource::kLocalOnly;
}
if (params->search_params.modified_timestamp.has_value()) {
query->modified_time = base::Time::FromMillisecondsSinceUnixEpoch(
*params->search_params.modified_timestamp);
query->modified_time_operator =
drivefs::mojom::QueryParameters::DateComparisonOperator::kGreaterThan;
}
ash::RecentSource::FileType file_type;
if (!file_manager::util::ToRecentSourceFileType(
params->search_params.category, &file_type)) {
return RespondNow(Error("Unable to convert file category"));
}
auto type_filters = ash::RecentDriveSource::CreateTypeFilters(file_type);
if (type_filters.size() == 1) {
query->mime_type = type_filters.front();
} else if (type_filters.size() > 1) {
query->mime_types = std::move(type_filters);
}
query->page_size = params->search_params.max_results;
bool filter_dirs = false;
switch (params->search_params.types) {
case api::file_manager_private::SearchType::kExcludeDirectories:
filter_dirs = true;
search_type_ = SearchType::kText;
break;
case api::file_manager_private::SearchType::kSharedWithMe:
query->shared_with_me = true;
search_type_ = SearchType::kSharedWithMe;
break;
case api::file_manager_private::SearchType::kOffline:
query->available_offline = true;
query->query_source =
drivefs::mojom::QueryParameters::QuerySource::kLocalOnly;
search_type_ = SearchType::kOffline;
break;
case api::file_manager_private::SearchType::kAll:
search_type_ = SearchType::kText;
break;
default:
return RespondNow(Error("Invalid search type"));
}
is_offline_ =
SearchDriveFs(
this, std::move(query), filter_dirs,
base::BindOnce(
&FileManagerPrivateSearchDriveMetadataFunction::OnSearchDriveFs,
this, params->search_params.query)) ==
drivefs::mojom::QueryParameters::QuerySource::kLocalOnly;
return RespondLater();
}
void FileManagerPrivateSearchDriveMetadataFunction::OnSearchDriveFs(
const std::string& query_text,
std::optional<base::Value::List> results) {
if (!results) {
UmaEmitSearchOutcome(false, !is_offline_, search_type_, operation_start_);
Respond(Error("No search results"));
return;
}
std::vector<std::u16string> keywords =
base::SplitString(base::UTF8ToUTF16(query_text),
std::u16string_view(base::kWhitespaceUTF16),
base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
std::vector<std::unique_ptr<
base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>>
queries;
queries.reserve(keywords.size());
for (const auto& keyword : keywords) {
queries.push_back(
std::make_unique<
base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>(
keyword));
}
base::Value::List results_list;
for (auto& item : *results) {
base::Value::Dict& entry = item.GetDict();
base::Value::Dict dict;
std::string highlight;
std::string* value = entry.FindString("fileFullPath");
if (value) {
highlight = *value;
base::FilePath path(highlight);
if (!drive::internal::FindAndHighlight(path.BaseName().value(), queries,
&highlight)) {
highlight = path.BaseName().value();
}
}
if (auto availableOffline = entry.FindBool(kAvailableOfflinePropertyName)) {
dict.Set(kAvailableOfflinePropertyName, *availableOffline);
entry.Remove(kAvailableOfflinePropertyName);
}
dict.Set("entry", std::move(entry));
dict.Set("highlightedBaseName", highlight);
results_list.Append(std::move(dict));
}
UmaEmitSearchOutcome(true, !is_offline_, search_type_, operation_start_);
Respond(WithArguments(std::move(results_list)));
}
ExtensionFunction::ResponseAction
FileManagerPrivateGetDriveConnectionStateFunction::Run() {
api::file_manager_private::DriveConnectionState result;
using enum drive::util::ConnectionStatus;
switch (drive::util::GetDriveConnectionStatus(
Profile::FromBrowserContext(browser_context()))) {
case kNoService:
result.type =
api::file_manager_private::DriveConnectionStateType::kOffline;
result.reason = api::file_manager_private::DriveOfflineReason::kNoService;
break;
case kNoNetwork:
result.type =
api::file_manager_private::DriveConnectionStateType::kOffline;
result.reason = api::file_manager_private::DriveOfflineReason::kNoNetwork;
break;
case kNotReady:
result.type =
api::file_manager_private::DriveConnectionStateType::kOffline;
result.reason = api::file_manager_private::DriveOfflineReason::kNotReady;
break;
case kMetered:
result.type =
api::file_manager_private::DriveConnectionStateType::kMetered;
break;
case kConnected:
result.type =
api::file_manager_private::DriveConnectionStateType::kOnline;
break;
}
return RespondNow(ArgumentList(
api::file_manager_private::GetDriveConnectionState::Results::Create(
result)));
}
ExtensionFunction::ResponseAction
FileManagerPrivateNotifyDriveDialogResultFunction::Run() {
using api::file_manager_private::NotifyDriveDialogResult::Params;
const std::optional<Params> params = Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
file_manager::EventRouter* const event_router =
file_manager::EventRouterFactory::GetForProfile(
Profile::FromBrowserContext(browser_context()));
if (event_router) {
drivefs::mojom::DialogResult result;
switch (params->result) {
case api::file_manager_private::DriveDialogResult::kNone:
case api::file_manager_private::DriveDialogResult::kNotDisplayed:
result = drivefs::mojom::DialogResult::kNotDisplayed;
break;
case api::file_manager_private::DriveDialogResult::kAccept:
result = drivefs::mojom::DialogResult::kAccept;
break;
case api::file_manager_private::DriveDialogResult::kReject:
result = drivefs::mojom::DialogResult::kReject;
break;
case api::file_manager_private::DriveDialogResult::kDismiss:
result = drivefs::mojom::DialogResult::kDismiss;
break;
}
event_router->OnDriveDialogResult(result);
} else {
return RespondNow(Error("Could not find event router"));
}
return RespondNow(NoArguments());
}
ExtensionFunction::ResponseAction
FileManagerPrivatePollDriveHostedFilePinStatesFunction::Run() {
if (DriveIntegrationService* const service = GetIntegrationServiceByProfile(
Profile::FromBrowserContext(browser_context()))) {
service->PollHostedFilePinStates();
}
return RespondNow(NoArguments());
}
ExtensionFunction::ResponseAction
FileManagerPrivateGetBulkPinProgressFunction::Run() {
DriveIntegrationService* const service = GetIntegrationServiceByProfile(
Profile::FromBrowserContext(browser_context()));
if (!service) {
return RespondNow(Error("Drive not available"));
}
PinningManager* const p = service->GetPinningManager();
if (!p) {
return RespondNow(Error("Pin Manager not available"));
}
return RespondNow(ArgumentList(
api::file_manager_private::GetBulkPinProgress::Results::Create(
file_manager::util::BulkPinProgressToJs(p->GetProgress()))));
}
ExtensionFunction::ResponseAction
FileManagerPrivateOpenManageSyncSettingsFunction::Run() {
if (ash::features::IsDriveFsMirroringEnabled()) {
ash::ManageMirrorSyncDialog::Show(
Profile::FromBrowserContext(browser_context()));
}
return RespondNow(NoArguments());
}
ExtensionFunction::ResponseAction
FileManagerPrivateCalculateBulkPinRequiredSpaceFunction::Run() {
Profile* const profile = Profile::FromBrowserContext(browser_context());
DriveIntegrationService* const service =
GetIntegrationServiceByProfile(profile);
if (!service) {
return RespondNow(Error("Drive not available"));
}
PinningManager* const p = service->GetPinningManager();
if (!p) {
return RespondNow(Error("Pin Manager not available"));
}
if (!p->CalculateRequiredSpace()) {
return RespondNow(Error("Pin Manager is already pinning"));
}
return RespondNow(NoArguments());
}
} // namespace extensions
Codebase Browser
chromium