[fsp] Pass more detailed errors to the providing extension.

chrome/browser/chromeos/file_system_provider/service.cc

 // Copyright 2014 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/service.h"
 
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
@@ skipping 42 matching lines @@
   // OnExtensionUnload calls for each installed extension. However, for tests
   // we may still have mounted extensions.
   // TODO(mtomasz): Create a TestingService class and remove this code.
   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
   while (it != file_system_map_.end()) {
     const std::string file_system_id =
         it->second->GetFileSystemInfo().file_system_id();
     const std::string extension_id =
         it->second->GetFileSystemInfo().extension_id();
     ++it;
-    const bool unmount_result = UnmountFileSystem(
+    const base::File::Error unmount_result = UnmountFileSystem(
         extension_id, file_system_id, UNMOUNT_REASON_SHUTDOWN);
-    DCHECK(unmount_result);
+    DCHECK_EQ(base::File::FILE_OK, unmount_result);
   }
 
   DCHECK_EQ(0u, file_system_map_.size());
   STLDeleteValues(&file_system_map_);
 }
 
 // static
 Service* Service::Get(content::BrowserContext* context) {
   return ServiceFactory::Get(context);
 }
@@ skipping 12 matching lines @@
     const FileSystemFactoryCallback& factory_callback) {
   DCHECK(!factory_callback.is_null());
   file_system_factory_ = factory_callback;
 }
 
 void Service::SetRegistryForTesting(scoped_ptr<RegistryInterface> registry) {
   DCHECK(registry);
   registry_.reset(registry.release());
 }
 
-bool Service::MountFileSystem(const std::string& extension_id,
-                              const MountOptions& options) {
+base::File::Error Service::MountFileSystem(const std::string& extension_id,
+                                           const MountOptions& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If already exists a file system provided by the same extension with this
   // id, then abort.
   if (GetProvidedFileSystem(extension_id, options.file_system_id)) {
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                                 base::File::FILE_ERROR_EXISTS));
-    return false;
+    return base::File::FILE_ERROR_EXISTS;
   }
 
   // Restrict number of file systems to prevent system abusing.
   if (file_system_map_.size() + 1 > kMaxFileSystems) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                   base::File::FILE_ERROR_TOO_MANY_OPENED));
-    return false;
+    return base::File::FILE_ERROR_TOO_MANY_OPENED;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   // The mount point path and name are unique per system, since they are system
   // wide. This is necessary for copying between profiles.
   const base::FilePath& mount_path =
       util::GetMountPath(profile_, extension_id, options.file_system_id);
   const std::string mount_point_name = mount_path.BaseName().AsUTF8Unsafe();
 
   if (!mount_points->RegisterFileSystem(mount_point_name,
                                         storage::kFileSystemTypeProvided,
                                         storage::FileSystemMountOption(),
                                         mount_path)) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                   base::File::FILE_ERROR_INVALID_OPERATION));
-    return false;
+    return base::File::FILE_ERROR_INVALID_OPERATION;
   }
 
   // Store the file system descriptor. Use the mount point name as the file
   // system provider file system id.
   // Examples:
   //   file_system_id = hello_world
   //   mount_point_name =  b33f1337-hello_world-5aa5
   //   writable = false
   //   supports_notify_tag = false
   //   mount_path = /provided/b33f1337-hello_world-5aa5
   ProvidedFileSystemInfo file_system_info(extension_id, options, mount_path);
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
   file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
       file_system;
   mount_point_name_to_key_map_[mount_point_name] =
       FileSystemKey(extension_id, options.file_system_id);
   registry_->RememberFileSystem(file_system_info, *file_system->GetWatchers());
 
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       OnProvidedFileSystemMount(file_system_info, base::File::FILE_OK));
 
-  return true;
+  return base::File::FILE_OK;
 }
 
-bool Service::UnmountFileSystem(const std::string& extension_id,
-                                const std::string& file_system_id,
-                                UnmountReason reason) {
+base::File::Error Service::UnmountFileSystem(const std::string& extension_id,
+                                             const std::string& file_system_id,
+                                             UnmountReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const ProvidedFileSystemMap::iterator file_system_it =
       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
   if (file_system_it == file_system_map_.end()) {
     const ProvidedFileSystemInfo empty_file_system_info;
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemUnmount(empty_file_system_info,
                                     base::File::FILE_ERROR_NOT_FOUND));
-    return false;
+    return base::File::FILE_ERROR_NOT_FOUND;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   const ProvidedFileSystemInfo& file_system_info =
       file_system_it->second->GetFileSystemInfo();
 
   const std::string mount_point_name =
       file_system_info.mount_path().BaseName().value();
   if (!mount_points->RevokeFileSystem(mount_point_name)) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemUnmount(file_system_info,
                                     base::File::FILE_ERROR_INVALID_OPERATION));
-    return false;
+    return base::File::FILE_ERROR_INVALID_OPERATION;
   }
 
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       OnProvidedFileSystemUnmount(file_system_info, base::File::FILE_OK));
 
   mount_point_name_to_key_map_.erase(mount_point_name);
 
   if (reason == UNMOUNT_REASON_USER) {
     registry_->ForgetFileSystem(file_system_info.extension_id(),
                                 file_system_info.file_system_id());
   }
 
   delete file_system_it->second;
   file_system_map_.erase(file_system_it);
 
-  return true;
+  return base::File::FILE_OK;
 }
 
 bool Service::RequestUnmount(const std::string& extension_id,
                              const std::string& file_system_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ProvidedFileSystemMap::iterator file_system_it =
       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
   if (file_system_it == file_system_map_.end())
     return false;
@@ skipping 36 matching lines @@
     extensions::UnloadedExtensionInfo::Reason reason) {
   // Unmount all of the provided file systems associated with this extension.
   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
   while (it != file_system_map_.end()) {
     const ProvidedFileSystemInfo& file_system_info =
         it->second->GetFileSystemInfo();
     // Advance the iterator beforehand, otherwise it will become invalidated
     // by the UnmountFileSystem() call.
     ++it;
     if (file_system_info.extension_id() == extension->id()) {
-      const bool unmount_result = UnmountFileSystem(
-          file_system_info.extension_id(),
-          file_system_info.file_system_id(),
+      const base::File::Error unmount_result = UnmountFileSystem(
+          file_system_info.extension_id(), file_system_info.file_system_id(),
           reason == extensions::UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN
               ? UNMOUNT_REASON_SHUTDOWN
               : UNMOUNT_REASON_USER);
-      DCHECK(unmount_result);
+      DCHECK_EQ(base::File::FILE_OK, unmount_result);
     }
   }
 }
 
 void Service::OnExtensionLoaded(content::BrowserContext* browser_context,
                                 const extensions::Extension* extension) {
   scoped_ptr<RegistryInterface::RestoredFileSystems> restored_file_systems =
       registry_->RestoreFileSystems(extension->id());
 
   for (const auto& restored_file_system : *restored_file_systems) {
-    const bool result = MountFileSystem(restored_file_system.extension_id,
-                                        restored_file_system.options);
-    if (!result) {
+    const base::File::Error result = MountFileSystem(
+        restored_file_system.extension_id, restored_file_system.options);
+    if (result != base::File::FILE_OK) {
       LOG(ERROR) << "Failed to restore a provided file system from "
                  << "registry: " << restored_file_system.extension_id << ", "
                  << restored_file_system.options.file_system_id << ", "
                  << restored_file_system.options.display_name << ".";
       // Since remounting of the file system failed, then remove it from
       // preferences to avoid remounting it over and over again with a failure.
       registry_->ForgetFileSystem(restored_file_system.extension_id,
                                   restored_file_system.options.file_system_id);
       continue;
     }
@@ skipping 55 matching lines @@
 }
 
 void Service::OnWatcherListChanged(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   registry_->RememberFileSystem(file_system_info, watchers);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos