[WIP] Provided file system from NACL.

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 15 matching lines @@
 #include "storage/common/fileapi/file_system_mount_option.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 // Maximum number of file systems to be mounted in the same time, per profile.
 const size_t kMaxFileSystems = 16;
 
 // Default factory for provided file systems. |profile| must not be NULL.
+template <int source = Source_Type::extension>
 ProvidedFileSystemInterface* CreateProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info) {
   DCHECK(profile);
-  return new ThrottledFileSystem(
-      make_scoped_ptr(new ProvidedFileSystem(profile, file_system_info)));
+  return new ThrottledFileSystem(make_scoped_ptr(
+      new ProvidedFileSystem<source>(profile, file_system_info)));
 }
 
 }  // namespace
 
 ProvidingExtensionInfo::ProvidingExtensionInfo()
     : can_configure(false), can_add(false) {
 }
 
 ProvidingExtensionInfo::~ProvidingExtensionInfo() {
 }
 
 Service::Service(Profile* profile,
                  extensions::ExtensionRegistry* extension_registry)
     : profile_(profile),
       extension_registry_(extension_registry),
-      file_system_factory_(base::Bind(&CreateProvidedFileSystem)),
+      file_system_factory_(
+          base::Bind(&CreateProvidedFileSystem<Source_Type::extension>)),
       registry_(new Registry(profile)),
       weak_ptr_factory_(this) {
   extension_registry_->AddObserver(this);
 }
 
 Service::~Service() {
   extension_registry_->RemoveObserver(this);
 
   // Provided file systems should be already unmounted because of receiving
   // 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();
+    const std::string source_id =
+        it->second->GetFileSystemInfo().source_id();
     ++it;
     const base::File::Error unmount_result = UnmountFileSystem(
-        extension_id, file_system_id, UNMOUNT_REASON_SHUTDOWN);
+        source_id, file_system_id, UNMOUNT_REASON_SHUTDOWN);
     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 13 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());
 }
 
-base::File::Error Service::MountFileSystem(const std::string& extension_id,
-                                           const MountOptions& options) {
-  return MountFileSystemInternal(extension_id, options, MOUNT_CONTEXT_USER);
+base::File::Error Service::MountFileSystem(const std::string& source_id,
+                                           const MountOptions& options,
+                                           Source_Type source_type) {
+  switch (source_type) {
+    case Source_Type::extension:
+    case Source_Type::plugin:
+      return MountFileSystemInternal(source_id, options, MOUNT_CONTEXT_USER,
+                                     source_type);
+    default:
+      return base::File::Error::FILE_ERROR_INVALID_OPERATION;
+  }
 }
 
-base::File::Error Service::MountFileSystemInternal(
-    const std::string& extension_id,
-    const MountOptions& options,
-    MountContext context) {
+base::File::Error Service::MountFileSystemInternal(const std::string& source_id,
+                                                   const MountOptions& options,
+                                                   MountContext context,
+                                                   Source_Type source_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If already exists a file system provided by the same extension with this
+  // If already exists a file system provided by the same source with this
   // id, then abort.
-  if (GetProvidedFileSystem(extension_id, options.file_system_id)) {
+  if (GetProvidedFileSystem(source_id, options.file_system_id)) {
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
                                   base::File::FILE_ERROR_EXISTS));
     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(), context,
                                   base::File::FILE_ERROR_TOO_MANY_OPENED));
     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);
+      util::GetMountPath(profile_, source_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(
               storage::FlushPolicy::FLUSH_ON_COMPLETION),
           mount_path)) {
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
                                   base::File::FILE_ERROR_INVALID_OPERATION));
     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);
+  ProvidedFileSystemInfo file_system_info(source_id, options, mount_path,
+                                          source_type);
 
-  ProvidedFileSystemInterface* file_system =
-      file_system_factory_.Run(profile_, file_system_info);
+  ProvidedFileSystemInterface* file_system = NULL;
+  switch (source_type) {
+    case Source_Type::extension:  // file_system from extension
+      file_system = file_system_factory_.Run(profile_, file_system_info);
+      break;
+    case Source_Type::plugin:  // file_system from plugin
+      file_system = CreateProvidedFileSystem<Source_Type::plugin>(
+          profile_, file_system_info);
+      break;
+  }
   DCHECK(file_system);
-  file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
+  file_system_map_[FileSystemKey(source_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());
+      FileSystemKey(source_id, options.file_system_id);
+
+  if (source_type == Source_Type::extension)
+    registry_->RememberFileSystem(file_system_info,
+                                  *file_system->GetWatchers());
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnProvidedFileSystemMount(file_system_info, context,
                                               base::File::FILE_OK));
 
   return base::File::FILE_OK;
 }
 
-base::File::Error Service::UnmountFileSystem(const std::string& extension_id,
+base::File::Error Service::UnmountFileSystem(const std::string& source_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));
+      file_system_map_.find(FileSystemKey(source_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 base::File::FILE_ERROR_NOT_FOUND;
   }
 
@@ skipping 15 matching lines @@
     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(),
+  if (reason == UNMOUNT_REASON_USER &&
+      file_system_info.source_type()!=Source_Type::plugin) {
+    registry_->ForgetFileSystem(file_system_info.source_id(),
                                 file_system_info.file_system_id());
   }
 
   delete file_system_it->second;
   file_system_map_.erase(file_system_it);
 
   return base::File::FILE_OK;
 }
 
 bool Service::RequestUnmount(const std::string& extension_id,
@@ skipping 193 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