| // 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 |
