[WIP] Provided file system from NACL.

chrome/browser/chromeos/file_manager/volume_manager.cc

 // Copyright 2013 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_manager/volume_manager.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 92 matching lines @@
     case VOLUME_TYPE_REMOVABLE_DISK_PARTITION:
       return "removable";
     case VOLUME_TYPE_MOUNTED_ARCHIVE_FILE:
       return "archive";
     case VOLUME_TYPE_PROVIDED:
       return "provided";
     case VOLUME_TYPE_MTP:
       return "mtp";
     case VOLUME_TYPE_TESTING:
       return "testing";
+    case VOLUME_TYPE_PLUGIN_PROVIDED:
+      return "plugin_provided";
     case NUM_VOLUME_TYPE:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 // Generates a unique volume ID for the given volume info.
 std::string GenerateVolumeId(const Volume& volume) {
   // For the same volume type, base names are unique, as mount points are
@@ skipping 94 matching lines @@
     case extensions::SOURCE_FILE:
       volume->source_ = SOURCE_FILE;
       break;
     case extensions::SOURCE_DEVICE:
       volume->source_ = SOURCE_DEVICE;
       break;
     case extensions::SOURCE_NETWORK:
       volume->source_ = SOURCE_NETWORK;
       break;
   }
+  using chromeos::file_system_provider::Source_Type;
   volume->volume_label_ = file_system_info.display_name();
-  volume->type_ = VOLUME_TYPE_PROVIDED;
+  volume->type_ = file_system_info.source_type() == Source_Type::plugin ?
+                  VOLUME_TYPE_PLUGIN_PROVIDED : VOLUME_TYPE_PROVIDED;
   volume->mount_path_ = file_system_info.mount_path();
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->mount_context_ = mount_context;
   volume->is_parent_ = true;
   volume->is_read_only_ = !file_system_info.writable();
   volume->configurable_ = file_system_info.configurable();
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
@@ skipping 34 matching lines @@
 
 // static
 Volume* Volume::CreateForTesting(const base::FilePath& device_path,
                                  const base::FilePath& mount_path) {
   Volume* const volume = new Volume;
   volume->system_path_prefix_ = device_path;
   volume->mount_path_ = mount_path;
   return volume;
 }
 
-VolumeManager::VolumeManager(
-    Profile* profile,
+VolumeManager::VolumeManager(Profile* profile,
     drive::DriveIntegrationService* drive_integration_service,
     chromeos::PowerManagerClient* power_manager_client,
     chromeos::disks::DiskMountManager* disk_mount_manager,
     chromeos::file_system_provider::Service* file_system_provider_service,
+    chromeos::file_system_provider::PluginService*
+                             file_system_plugin_provided_service,
     GetMtpStorageInfoCallback get_mtp_storage_info_callback)
     : profile_(profile),
       drive_integration_service_(drive_integration_service),
       disk_mount_manager_(disk_mount_manager),
       file_system_provider_service_(file_system_provider_service),
+      file_system_plugin_provided_service_(file_system_plugin_provided_service),
       get_mtp_storage_info_callback_(get_mtp_storage_info_callback),
       snapshot_manager_(new SnapshotManager(profile_)),
       weak_ptr_factory_(this) {
   DCHECK(disk_mount_manager);
 }
 
 VolumeManager::~VolumeManager() {
 }
 
 VolumeManager* VolumeManager::Get(content::BrowserContext* context) {
@@ skipping 36 matching lines @@
     file_system_provider_service_->AddObserver(this);
 
     std::vector<ProvidedFileSystemInfo> file_system_info_list =
         file_system_provider_service_->GetProvidedFileSystemInfoList();
     for (size_t i = 0; i < file_system_info_list.size(); ++i) {
       linked_ptr<Volume> volume(Volume::CreateForProvidedFileSystem(
           file_system_info_list[i], MOUNT_CONTEXT_AUTO));
       DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
     }
   }
-
+  // Subscribe to PluginService
+  if (file_system_plugin_provided_service_)
+    file_system_plugin_provided_service_->AddObserver(this);
   // Subscribe to Profile Preference change.
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kExternalStorageDisabled,
       base::Bind(&VolumeManager::OnExternalStorageDisabledChanged,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Subscribe to storage monitor for MTP notifications.
   if (storage_monitor::StorageMonitor::GetInstance()) {
     storage_monitor::StorageMonitor::GetInstance()->EnsureInitialized(
         base::Bind(&VolumeManager::OnStorageMonitorInitialized,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void VolumeManager::Shutdown() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   snapshot_manager_.reset();
   pref_change_registrar_.RemoveAll();
   disk_mount_manager_->RemoveObserver(this);
   if (storage_monitor::StorageMonitor::GetInstance())
     storage_monitor::StorageMonitor::GetInstance()->RemoveObserver(this);
 
   if (drive_integration_service_)
     drive_integration_service_->RemoveObserver(this);
 
   if (file_system_provider_service_)
     file_system_provider_service_->RemoveObserver(this);
+  if (file_system_plugin_provided_service_)
+    file_system_plugin_provided_service_->RemoveObserver(this);
 }
 
 void VolumeManager::AddObserver(VolumeManagerObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void VolumeManager::RemoveObserver(VolumeManagerObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 476 matching lines @@
   if (mounted_volumes_.find(volume->volume_id()) == mounted_volumes_.end())
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     mounted_volumes_.erase(volume->volume_id());
 
   FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                     OnVolumeUnmounted(error_code, *volume.get()));
 }
 
 }  // namespace file_manager