[fsp] Decouple file_service_provider::Service.

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/file_system_provider/provided_file_system_info.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 55 matching lines @@
     case VOLUME_TYPE_GOOGLE_DRIVE:
       return "drive";
     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";
     case VOLUME_TYPE_MTP:
       return "mtp";
+    case VOLUME_TYPE_TESTING:
+      return "testing";
   }
   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 77 matching lines @@
   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) {
+    const chromeos::file_system_provider::ProvidedFileSystemInfo&
+        file_system_info) {
   VolumeInfo volume_info;
   volume_info.type = VOLUME_TYPE_PROVIDED;
-  volume_info.mount_path = file_system.mount_path();
+  volume_info.mount_path = file_system_info.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);
-  volume_info.file_system_id = file_system.file_system_id();
+  volume_info.file_system_id = file_system_info.file_system_id();
   return volume_info;
 }
 
 }  // namespace
 
 VolumeInfo::VolumeInfo()
     : file_system_id(0),
       type(VOLUME_TYPE_GOOGLE_DRIVE),
       mount_condition(chromeos::disks::MOUNT_CONDITION_NONE),
       is_parent(false),
@@ skipping 65 matching lines @@
                    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;
+    using chromeos::file_system_provider::ProvidedFileSystemInfo;
     file_system_provider_service_->AddObserver(this);
 
-    std::vector<ProvidedFileSystem> provided_file_systems =
-        file_system_provider_service_->GetMountedFileSystems();
-    for (size_t i = 0; i < provided_file_systems.size(); ++i) {
+    std::vector<ProvidedFileSystemInfo> file_system_info_list =
+        file_system_provider_service_->GetProvidedFileSystemInfoList();
+    for (size_t i = 0; i < file_system_info_list.size(); ++i) {
       VolumeInfo volume_info =
-          CreateProvidedFileSystemVolumeInfo(provided_file_systems[i]);
+          CreateProvidedFileSystemVolumeInfo(file_system_info_list[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();
@@ skipping 300 matching lines @@
           VolumeManagerObserver, observers_,
           OnFormatCompleted(device_path,
                             error_code == chromeos::FORMAT_ERROR_NONE));
 
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnProvidedFileSystemMount(
-    const chromeos::file_system_provider::ProvidedFileSystem& file_system,
+    const chromeos::file_system_provider::ProvidedFileSystemInfo&
+        file_system_info,
     base::File::Error error) {
-  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system);
+  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system_info);
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   const chromeos::MountError mount_error = error == base::File::FILE_OK
                                                ? chromeos::MOUNT_ERROR_NONE
                                                : chromeos::MOUNT_ERROR_UNKNOWN;
   DoMountEvent(mount_error, volume_info, false /* remounting */);
 }
 
 void VolumeManager::OnProvidedFileSystemUnmount(
-    const chromeos::file_system_provider::ProvidedFileSystem& file_system,
+    const chromeos::file_system_provider::ProvidedFileSystemInfo&
+        file_system_info,
     base::File::Error error) {
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   const chromeos::MountError mount_error = error == base::File::FILE_OK
                                                ? chromeos::MOUNT_ERROR_NONE
                                                : chromeos::MOUNT_ERROR_UNKNOWN;
-  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system);
+  VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system_info);
   DoUnmountEvent(mount_error, 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().
@@ skipping 60 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