src/chrome/browser/chromeos/extensions/file_system_provider/provider_function.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/extensions/file_system_provider/file_system_provider_api.h"
   6
   7 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
   8 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
   9 #include "chrome/browser/chromeos/file_system_provider/request_value.h"
  10 #include "chrome/browser/chromeos/file_system_provider/service.h"
  11 #include "chrome/common/extensions/api/file_system_provider_internal.h"
  12
  13 using chromeos::file_system_provider::ProvidedFileSystemInterface;
  14 using chromeos::file_system_provider::RequestManager;
  15 using chromeos::file_system_provider::RequestValue;
  16 using chromeos::file_system_provider::Service;
  17
  18 namespace extensions {
  19
  20 const char kNotFoundErrorName[] = "NotFoundError";
  21 const char kSecurityErrorName[] = "SecurityError";
  22
  23 const char kEmptyNameErrorMessage[] = "Empty display name is not allowed.";
  24 const char kMountFailedErrorMessage[] = "Mounting the file system failed.";
  25 const char kUnmountFailedErrorMessage[] = "Unmounting the file system failed.";
  26 const char kResponseFailedErrorMessage[] =
  27     "Sending a response for the request failed.";
  28
  29 base::DictionaryValue* CreateError(const std::string& name,
  30                                    const std::string& message) {
  31   base::DictionaryValue* error = new base::DictionaryValue();
  32   error->SetString("name", name);
  33   error->SetString("message", message);
  34   return error;
  35 }
  36
  37 base::File::Error ProviderErrorToFileError(
  38     api::file_system_provider::ProviderError error) {
  39   switch (error) {
  40     case api::file_system_provider::PROVIDER_ERROR_OK:
  41       return base::File::FILE_OK;
  42     case api::file_system_provider::PROVIDER_ERROR_FAILED:
  43       return base::File::FILE_ERROR_FAILED;
  44     case api::file_system_provider::PROVIDER_ERROR_IN_USE:
  45       return base::File::FILE_ERROR_IN_USE;
  46     case api::file_system_provider::PROVIDER_ERROR_EXISTS:
  47       return base::File::FILE_ERROR_EXISTS;
  48     case api::file_system_provider::PROVIDER_ERROR_NOT_FOUND:
  49       return base::File::FILE_ERROR_NOT_FOUND;
  50     case api::file_system_provider::PROVIDER_ERROR_ACCESS_DENIED:
  51       return base::File::FILE_ERROR_ACCESS_DENIED;
  52     case api::file_system_provider::PROVIDER_ERROR_TOO_MANY_OPENED:
  53       return base::File::FILE_ERROR_TOO_MANY_OPENED;
  54     case api::file_system_provider::PROVIDER_ERROR_NO_MEMORY:
  55       return base::File::FILE_ERROR_NO_MEMORY;
  56     case api::file_system_provider::PROVIDER_ERROR_NO_SPACE:
  57       return base::File::FILE_ERROR_NO_SPACE;
  58     case api::file_system_provider::PROVIDER_ERROR_NOT_A_DIRECTORY:
  59       return base::File::FILE_ERROR_NOT_A_DIRECTORY;
  60     case api::file_system_provider::PROVIDER_ERROR_INVALID_OPERATION:
  61       return base::File::FILE_ERROR_INVALID_OPERATION;
  62     case api::file_system_provider::PROVIDER_ERROR_SECURITY:
  63       return base::File::FILE_ERROR_SECURITY;
  64     case api::file_system_provider::PROVIDER_ERROR_ABORT:
  65       return base::File::FILE_ERROR_ABORT;
  66     case api::file_system_provider::PROVIDER_ERROR_NOT_A_FILE:
  67       return base::File::FILE_ERROR_NOT_A_FILE;
  68     case api::file_system_provider::PROVIDER_ERROR_NOT_EMPTY:
  69       return base::File::FILE_ERROR_NOT_EMPTY;
  70     case api::file_system_provider::PROVIDER_ERROR_INVALID_URL:
  71       return base::File::FILE_ERROR_INVALID_URL;
  72     case api::file_system_provider::PROVIDER_ERROR_IO:
  73       return base::File::FILE_ERROR_IO;
  74     case api::file_system_provider::PROVIDER_ERROR_NONE:
  75       NOTREACHED();
  76   }
  77   return base::File::FILE_ERROR_FAILED;
  78 }
  79
  80 FileSystemProviderInternalFunction::FileSystemProviderInternalFunction()
  81     : request_id_(0), request_manager_(NULL) {
  82 }
  83
  84 void FileSystemProviderInternalFunction::RejectRequest(
  85     base::File::Error error) {
  86   if (!request_manager_->RejectRequest(request_id_, error))
  87     SetErrorResponse(kSecurityErrorName, kResponseFailedErrorMessage);
  88 }
  89
  90 void FileSystemProviderInternalFunction::FulfillRequest(
  91     scoped_ptr<RequestValue> value,
  92     bool has_next) {
  93   if (!request_manager_->FulfillRequest(request_id_, value.Pass(), has_next))
  94     SetErrorResponse(kSecurityErrorName, kResponseFailedErrorMessage);
  95 }
  96
  97 bool FileSystemProviderInternalFunction::RunSync() {
  98   DCHECK(args_);
  99   if (!Parse())
 100     return true;
 101
 102   SendResponse(RunWhenValid());
 103   return true;
 104 }
 105
 106 bool FileSystemProviderInternalFunction::Parse() {
 107   int file_system_id = 0;
 108
 109   if (!args_->GetInteger(0, &file_system_id) ||
 110       !args_->GetInteger(1, &request_id_)) {
 111     bad_message_ = true;
 112     SendResponse(false);
 113     return false;
 114   }
 115
 116   Service* service = Service::Get(GetProfile());
 117   if (!service) {
 118     SendResponse(false);
 119     return false;
 120   }
 121
 122   ProvidedFileSystemInterface* file_system =
 123       service->GetProvidedFileSystem(extension_id(), file_system_id);
 124   if (!file_system) {
 125     SetErrorResponse(kNotFoundErrorName, kResponseFailedErrorMessage);
 126     SendResponse(true);
 127     return false;
 128   }
 129
 130   request_manager_ = file_system->GetRequestManager();
 131   return true;
 132 }
 133
 134 void FileSystemProviderInternalFunction::SetErrorResponse(
 135     const std::string& name,
 136     const std::string& message) {
 137   base::ListValue* result = new base::ListValue();
 138   result->Append(CreateError(name, message));
 139   SetResult(result);
 140 }
 141
 142 }  // namespace extensions