[WIP] Provided file system from NACL.

chrome/browser/chromeos/file_system_provider/file_system_plugin/provided_file_system_adapter.cc

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