[fsp] Introduce file_system_provider::Service class for the FileSystemProvider API.

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/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_errors.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/mounted_disk_monitor.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager_factory.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager_observer.h"
+#include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/local_discovery/storage/privet_filesystem_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
@@ skipping 63 matching lines @@
     case VOLUME_TYPE_DOWNLOADS_DIRECTORY:
       return "downloads";
     case VOLUME_TYPE_REMOVABLE_DISK_PARTITION:
       return "removable";
     case VOLUME_TYPE_MOUNTED_ARCHIVE_FILE:
       return "archive";
     case VOLUME_TYPE_CLOUD_DEVICE:
       return "cloud_device";
     case VOLUME_TYPE_TESTING:
       return "testing";
+    case VOLUME_TYPE_PROVIDED:
+      return "provided";
   }
   NOTREACHED();
   return "";
 }
 
 // Generates a unique volume ID for the given volume info.
 std::string GenerateVolumeId(const VolumeInfo& volume_info) {
   // For the same volume type, base names are unique, as mount points are
   // flat for the same volume type.
   return (VolumeTypeToString(volume_info.type) + ":" +
@@ skipping 76 matching lines @@
   VolumeInfo volume_info;
   volume_info.type = VOLUME_TYPE_CLOUD_DEVICE;
   volume_info.mount_path = privet_volume_info.volume_path;
   volume_info.mount_condition = chromeos::disks::MOUNT_CONDITION_NONE;
   volume_info.is_parent = true;
   volume_info.is_read_only = true;
   volume_info.volume_id = GenerateVolumeId(volume_info);
   return volume_info;
 }
 
+VolumeInfo CreateProvidedFileSystemVolumeInfo(
+    const chromeos::file_system_provider::ProvidedFileSystem& file_system) {
+  VolumeInfo volume_info;
+  volume_info.type = VOLUME_TYPE_PROVIDED;
+  volume_info.mount_path = file_system.mount_path();
+  volume_info.mount_condition = chromeos::disks::MOUNT_CONDITION_NONE;
+  volume_info.is_parent = true;
+  volume_info.is_read_only = true;
+  volume_info.volume_id = GenerateVolumeId(volume_info);
+  return volume_info;
+}
+
 }  // namespace
 
 VolumeInfo::VolumeInfo() {
 }
 
 VolumeInfo::~VolumeInfo() {
 }
 
 VolumeManager::VolumeManager(
     Profile* profile,
     drive::DriveIntegrationService* drive_integration_service,
     chromeos::PowerManagerClient* power_manager_client,
-    chromeos::disks::DiskMountManager* disk_mount_manager)
+    chromeos::disks::DiskMountManager* disk_mount_manager,
+    chromeos::file_system_provider::Service* file_system_provider_service)
     : profile_(profile),
       drive_integration_service_(drive_integration_service),
       disk_mount_manager_(disk_mount_manager),
       mounted_disk_monitor_(
-          new MountedDiskMonitor(power_manager_client, disk_mount_manager)) {
+          new MountedDiskMonitor(power_manager_client, disk_mount_manager)),
+      file_system_provider_service_(file_system_provider_service) {
   DCHECK(disk_mount_manager);
 }
 
 VolumeManager::~VolumeManager() {
 }
 
 VolumeManager* VolumeManager::Get(content::BrowserContext* context) {
   return VolumeManagerFactory::Get(context);
 }
 
@@ skipping 35 matching lines @@
     if (drive_integration_service_->IsMounted()) {
       DoMountEvent(chromeos::MOUNT_ERROR_NONE,
                    CreateDriveVolumeInfo(profile_),
                    kNotRemounting);
     }
   }
 
   // Subscribe to DiskMountManager.
   disk_mount_manager_->AddObserver(this);
 
+  // Subscribe to FileSystemProviderService and register currently mounted
+  // volumes for the profile.
+  if (file_system_provider_service_) {
+    using chromeos::file_system_provider::ProvidedFileSystem;
+    file_system_provider_service_->AddObserver(this);
+
+    std::vector<ProvidedFileSystem> provided_file_systems =
+        file_system_provider_service_->GetRegisteredFileSystems();
+    for (size_t i = 0; i < provided_file_systems.size(); ++i) {
+      VolumeInfo volume_info =
+          CreateProvidedFileSystemVolumeInfo(provided_file_systems[i]);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, kNotRemounting);
+    }
+  }
+
   std::vector<VolumeInfo> archives;
 
   const chromeos::disks::DiskMountManager::MountPointMap& mount_points =
       disk_mount_manager_->mount_points();
   for (chromeos::disks::DiskMountManager::MountPointMap::const_iterator it =
            mount_points.begin();
        it != mount_points.end();
        ++it) {
     if (it->second.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
       // Archives are mounted after other type of volumes. See below.
@@ skipping 50 matching lines @@
     privet_volume_lister_->Start();
   }
 }
 
 void VolumeManager::Shutdown() {
   pref_change_registrar_.RemoveAll();
   disk_mount_manager_->RemoveObserver(this);
 
   if (drive_integration_service_)
     drive_integration_service_->RemoveObserver(this);
+
+  if (file_system_provider_service_)
+    file_system_provider_service_->RemoveObserver(this);
 }
 
 void VolumeManager::AddObserver(VolumeManagerObserver* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void VolumeManager::RemoveObserver(VolumeManagerObserver* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 222 matching lines @@
       FOR_EACH_OBSERVER(
           VolumeManagerObserver, observers_,
           OnFormatCompleted(device_path,
                             error_code == chromeos::FORMAT_ERROR_NONE));
 
       return;
   }
   NOTREACHED();
 }
 
+void VolumeManager::OnProvidedFileSystemRegistered(
+    const chromeos::file_system_provider::ProvidedFileSystem& file_system) {
+  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, false /* remounting */);
+}
+
+void VolumeManager::OnProvidedFileSystemUnregistered(
+    const chromeos::file_system_provider::ProvidedFileSystem& file_system) {
+  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system);
+  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
+}
+
 void VolumeManager::OnExternalStorageDisabledChanged() {
   // If the policy just got disabled we have to unmount every device currently
   // mounted. The opposite is fine - we can let the user re-plug her device to
   // make it available.
   if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     // We do not iterate on mount_points directly, because mount_points can
     // be changed by UnmountPath().
     // TODO(hidehiko): Is it necessary to unmount mounted archives, too, here?
     while (!disk_mount_manager_->mount_points().empty()) {
       std::string mount_path =
@@ skipping 57 matching lines @@
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     mounted_volumes_.erase(volume_info.volume_id);
 
   FOR_EACH_OBSERVER(VolumeManagerObserver,
                     observers_,
                     OnVolumeUnmounted(error_code, volume_info));
 }
 
 }  // namespace file_manager