Index: chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.cc |
diff --git a/chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.cc b/chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..52bc567e974db3726919a6a6280b6e4db18e4bea |
--- /dev/null |
+++ b/chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.cc |
@@ -0,0 +1,292 @@ |
+// Copyright 2015 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.h" |
+ |
+using extensions::api::file_system_provider::ProviderError; |
+ |
+namespace chromeos { |
+namespace file_system_provider { |
+ |
+//static |
+RequestType |
+ProvidedFileSystemAdapter::OperationTypeFromExtensionEvent( |
+ const std::string& extension_operation) { |
+ using namespace extensions::api::file_system_provider; |
+ if (extension_operation==OnGetMetadataRequested::kEventName ) |
+ return GET_METADATA; |
+ else if (extension_operation==OnReadDirectoryRequested::kEventName ) |
+ return READ_DIRECTORY; |
+ else if (extension_operation==OnOpenFileRequested::kEventName) |
+ return OPEN_FILE; |
+ else if (extension_operation==OnReadFileRequested::kEventName) |
+ return READ_FILE; |
+ else if (extension_operation==OnWriteFileRequested::kEventName) |
+ return WRITE_FILE; |
+ else if (extension_operation==OnCloseFileRequested::kEventName) |
+ return CLOSE_FILE; |
+ else if (extension_operation==OnAbortRequested::kEventName) |
+ return ABORT; |
+ else if (extension_operation==OnAddWatcherRequested::kEventName) |
+ return ADD_WATCHER; |
+ else if (extension_operation==OnRemoveWatcherRequested::kEventName) |
+ return REMOVE_WATCHER; |
+ else if (extension_operation==OnConfigureRequested::kEventName) |
+ return CONFIGURE; |
+ else if (extension_operation==OnCopyEntryRequested::kEventName) |
+ return COPY_ENTRY; |
+ else if (extension_operation==OnMoveEntryRequested::kEventName) |
+ return MOVE_ENTRY; |
+ else if (extension_operation==OnCreateDirectoryRequested::kEventName) |
+ return CREATE_DIRECTORY; |
+ else if (extension_operation==OnCreateFileRequested::kEventName) |
+ return CREATE_FILE; |
+ else if (extension_operation==OnDeleteEntryRequested::kEventName) |
+ return DELETE_ENTRY; |
+ else if (extension_operation==OnUnmountRequested::kEventName) |
+ return REQUEST_UNMOUNT; |
+ else if (extension_operation==OnTruncateRequested::kEventName) |
+ return TRUNCATE; |
+ |
+ return ABORT; |
+ NOTREACHED(); |
+} |
+ |
+// Translate the error returned by the extensions decoders to base::File errors |
+base::File::Error PP_ProviderErrorToFileError( |
+ ProviderError error) { |
+ switch (error) { |
+ case ProviderError::PROVIDER_ERROR_OK: |
+ return base::File::FILE_OK; |
+ case ProviderError::PROVIDER_ERROR_FAILED: |
+ return base::File::FILE_ERROR_FAILED; |
+ case ProviderError::PROVIDER_ERROR_IN_USE: |
+ return base::File::FILE_ERROR_IN_USE; |
+ case ProviderError::PROVIDER_ERROR_EXISTS: |
+ return base::File::FILE_ERROR_EXISTS; |
+ case ProviderError::PROVIDER_ERROR_NOT_FOUND: |
+ return base::File::FILE_ERROR_NOT_FOUND; |
+ case ProviderError::PROVIDER_ERROR_ACCESS_DENIED: |
+ return base::File::FILE_ERROR_ACCESS_DENIED; |
+ case ProviderError::PROVIDER_ERROR_TOO_MANY_OPENED: |
+ return base::File::FILE_ERROR_TOO_MANY_OPENED; |
+ case ProviderError::PROVIDER_ERROR_NO_MEMORY: |
+ return base::File::FILE_ERROR_NO_MEMORY; |
+ case ProviderError::PROVIDER_ERROR_NO_SPACE: |
+ return base::File::FILE_ERROR_NO_SPACE; |
+ case ProviderError::PROVIDER_ERROR_NOT_A_DIRECTORY: |
+ return base::File::FILE_ERROR_NOT_A_DIRECTORY; |
+ case ProviderError::PROVIDER_ERROR_INVALID_OPERATION: |
+ return base::File::FILE_ERROR_INVALID_OPERATION; |
+ case ProviderError::PROVIDER_ERROR_SECURITY: |
+ return base::File::FILE_ERROR_SECURITY; |
+ case ProviderError::PROVIDER_ERROR_ABORT: |
+ return base::File::FILE_ERROR_ABORT; |
+ case ProviderError::PROVIDER_ERROR_NOT_A_FILE: |
+ return base::File::FILE_ERROR_NOT_A_FILE; |
+ case ProviderError::PROVIDER_ERROR_NOT_EMPTY: |
+ return base::File::FILE_ERROR_NOT_EMPTY; |
+ case ProviderError::PROVIDER_ERROR_INVALID_URL: |
+ return base::File::FILE_ERROR_INVALID_URL; |
+ case ProviderError::PROVIDER_ERROR_IO: |
+ return base::File::FILE_ERROR_IO; |
+ case ProviderError::PROVIDER_ERROR_NONE: |
+ NOTREACHED(); |
+ } |
+ return base::File::FILE_ERROR_FAILED; |
+} |
+ |
+bool ProvidedFileSystemAdapter::PushSuccessResponse( |
+ int32_t operation_type, |
+ scoped_ptr<base::ListValue> response) { |
+ switch(operation_type) { |
+ case READ_DIRECTORY: { |
+ using extensions::api:: |
+ file_system_provider_internal::ReadDirectoryRequestedSuccess:: |
+ Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if(!params.get()) |
+ return false; |
+ |
+ const bool has_more = params->has_more; |
+ const int32_t request_id = params->request_id; |
+ if ( base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->FulfillRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForReadDirectorySuccess(params.Pass()), |
+ has_more) |
+ ) |
+ return false; |
+ } |
+ break; |
+ case GET_METADATA: { |
+ using extensions::api::file_system_provider_internal:: |
+ GetMetadataRequestedSuccess::Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if(!params.get()) |
+ return false; |
+ |
+ const int32_t request_id =params->request_id; |
+ if (base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->FulfillRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForGetMetadataSuccess(params.Pass()), |
+ false) |
+ ) |
+ return false; |
+ } |
+ break; |
+ case READ_FILE: { |
+ using extensions::api::file_system_provider_internal:: |
+ ReadFileRequestedSuccess::Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if (!params.get()) |
+ return false; |
+ |
+ const bool has_more = params->has_more; |
+ const int32_t request_id = params->request_id; |
+ if (base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->FulfillRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForReadFileSuccess(params.Pass()), |
+ has_more) ) |
+ return false; |
+ } |
+ break; |
+ case REQUEST_UNMOUNT: { |
+ using extensions::api::file_system_provider_internal:: |
+ UnmountRequestedSuccess::Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if(!params.get()) |
+ return false; |
+ const int32_t request_id = params->request_id; |
+ if (base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->FulfillRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForUnmountSuccess( params.Pass()), |
+ false) |
+ ) |
+ return false; |
+ } |
+ break; |
+ default: { |
+ using extensions::api::file_system_provider_internal:: |
+ OperationRequestedSuccess::Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if(!params.get()) |
+ return false; |
+ |
+ const int32_t request_id = params->request_id; |
+ if (base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->FulfillRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForOperationSuccess(params.Pass()), |
+ false) |
+ ) |
+ return false; |
+ } |
+ break; |
+ } |
+ return true; |
+} |
+ |
+bool ProvidedFileSystemAdapter::PushErrorResponse( |
+ scoped_ptr<base::ListValue> reponse) { |
+ |
+ using extensions::api::file_system_provider_internal:: |
+ OperationRequestedError::Params; |
+ |
+ scoped_ptr<Params> params(Params::Create(*reponse)); |
+ if(!params.get()) |
+ return false; |
+ |
+ const base::File::Error error = PP_ProviderErrorToFileError(params->error); |
+ |
+ const int32_t request_id = params->request_id; |
+ if( base::File::FILE_OK!= |
+ provided_file_system_impl_->GetRequestManager()->RejectRequest( |
+ request_id, |
+ chromeos::file_system_provider::RequestValue:: |
+ CreateForOperationError(params.Pass()), |
+ error) |
+ ) |
+ return false; |
+ return true; |
+} |
+ |
+storage::WatcherManager::ChangeType ParseChangeType( |
+ const extensions::api::file_system_provider::ChangeType& change_type) { |
+ switch (change_type) { |
+ case extensions::api::file_system_provider::CHANGE_TYPE_CHANGED: |
+ return storage::WatcherManager::CHANGED; |
+ case extensions::api::file_system_provider::CHANGE_TYPE_DELETED: |
+ return storage::WatcherManager::DELETED; |
+ default: |
+ break; |
+ } |
+ NOTREACHED(); |
+ return storage::WatcherManager::CHANGED; |
+} |
+ |
+// Convert the change from the IDL type to a native type. The reason IDL types |
+// are not used is since they are imperfect, eg. paths are stored as strings. |
+ProvidedFileSystemObserver::Change ParseChange( |
+ const extensions::api::file_system_provider::Change& change) { |
+ ProvidedFileSystemObserver::Change result; |
+ result.entry_path = base::FilePath::FromUTF8Unsafe(change.entry_path); |
+ result.change_type = ParseChangeType(change.change_type); |
+ return result; |
+} |
+ |
+// Converts a list of child changes from the IDL type to a native type. |
+scoped_ptr<ProvidedFileSystemObserver::Changes> ParseChanges( |
+ const std::vector< |
+ linked_ptr<extensions::api::file_system_provider::Change>>& changes) { |
+ scoped_ptr<ProvidedFileSystemObserver::Changes> results( |
+ new ProvidedFileSystemObserver::Changes); |
+ for (const auto& change : changes) { |
+ results->push_back(ParseChange(*change)); |
+ } |
+ return results; |
+} |
+ |
+bool ProvidedFileSystemAdapter::PushChangeNotificationResponse( |
+ scoped_ptr<base::ListValue> response, |
+ StatusCallback callback) { |
+ using extensions::api::file_system_provider::Notify::Params; |
+ scoped_ptr<Params> params(Params::Create(*response)); |
+ if (!params.get()) |
+ return false; |
+ |
+ provided_file_system_impl_->Notify( |
+ base::FilePath::FromUTF8Unsafe(params->options.observed_path), |
+ params->options.recursive, ParseChangeType(params->options.change_type), |
+ params->options.changes.get() |
+ ? ParseChanges(*params->options.changes.get()) |
+ : make_scoped_ptr(new ProvidedFileSystemObserver::Changes), |
+ params->options.tag.get() ? *params->options.tag.get() : "", |
+ callback ); |
+ return true; |
+} |
+ |
+ProvidedFileSystemInterface* |
+ProvidedFileSystemAdapter::GetProvidedFileSystem() { |
+ return provided_file_system_impl_.get(); |
+} |
+ |
+ProvidedFileSystemAdapter::ProvidedFileSystemAdapter( |
+ scoped_ptr<ProvidedFileSystemInterface> file_system) |
+ : provided_file_system_impl_(file_system.Pass()) { |
+ |
+} |
+ |
+ProvidedFileSystemAdapter::~ProvidedFileSystemAdapter() {} |
+ |
+} // namespace file_system_provider |
+} // namespace chromeos |