mediaview: Mount ARC documents provider file system volumes.

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/chromeos/arc/arc_session_manager.h"
+#include "chrome/browser/chromeos/arc/fileapi/arc_documents_provider_util.h"
+#include "chrome/browser/chromeos/arc/fileapi/arc_file_system_service.h"
+#include "chrome/browser/chromeos/arc/fileapi/arc_media_view_util.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/file_manager/snapshot_manager.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_info.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/disks/disk_mount_manager.h"
+#include "components/arc/arc_service_manager.h"
 #include "components/drive/chromeos/file_system_interface.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 namespace file_manager {
@@ skipping 62 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_PROVIDED:
       return "provided";
     case VOLUME_TYPE_MTP:
       return "mtp";
+    case VOLUME_TYPE_MEDIA_VIEW:
+      return "media_view";
     case VOLUME_TYPE_TESTING:
       return "testing";
     case NUM_VOLUME_TYPE:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 // Generates a unique volume ID for the given volume info.
@@ skipping 140 matching lines @@
   volume->is_read_only_ = read_only;
   volume->volume_id_ = kMtpVolumeIdPrefix + label;
   volume->volume_label_ = label;
   volume->source_path_ = mount_path;
   volume->source_ = SOURCE_DEVICE;
   volume->device_type_ = chromeos::DEVICE_TYPE_MOBILE;
   return volume;
 }
 
 // static
+Volume* Volume::CreateForMediaView(const std::string& root_document_id) {
+  Volume* const volume = new Volume;
+  volume->type_ = VOLUME_TYPE_MEDIA_VIEW;
+  volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
+  volume->source_ = SOURCE_SYSTEM;
+  volume->mount_path_ = arc::GetDocumentsProviderMountPath(
+      arc::kMediaDocumentsProviderAuthority, root_document_id);
+  volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
+  volume->volume_label_ = root_document_id;
+  volume->is_read_only_ = true;
+  volume->watchable_ = false;
+  volume->volume_id_ = arc::GetMediaViewVolumeId(root_document_id);
+  return volume;
+}
+
+// static
 Volume* Volume::CreateForTesting(const base::FilePath& path,
                                  VolumeType volume_type,
                                  chromeos::DeviceType device_type,
                                  bool read_only) {
   Volume* const volume = new Volume;
   volume->type_ = volume_type;
   volume->device_type_ = device_type;
   // Keep source_path empty.
   volume->source_ = SOURCE_DEVICE;
   volume->mount_path_ = path;
@@ skipping 91 matching lines @@
       prefs::kExternalStorageReadOnly,
       base::Bind(&VolumeManager::OnExternalStorageReadOnlyChanged,
                  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()));
   }
+
+  // Subscribe to ARC file system events.
+  if (base::FeatureList::IsEnabled(arc::kMediaViewFeature) &&
+      arc::ArcSessionManager::IsAllowedForProfile(profile_)) {
+    arc::ArcServiceManager::GetGlobalService<arc::ArcFileSystemService>()
+        ->AddObserver(this);
+  }
 }
 
 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);
+
+  // Unsubscribe from ARC file system events.
+  if (base::FeatureList::IsEnabled(arc::kMediaViewFeature) &&
+      arc::ArcSessionManager::IsAllowedForProfile(profile_)) {
+    arc::ArcFileSystemService* file_system_service =
+        arc::ArcServiceManager::GetGlobalService<arc::ArcFileSystemService>();
+    // TODO(crbug.com/672829): We need nullptr check here because
+    // ArcServiceManager may or may not be alive at this point.
+    if (file_system_service)
+      file_system_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 284 matching lines @@
   // Repeat until unmount all paths
   const std::string& mount_path =
       disk_mount_manager_->mount_points().begin()->second.mount_path;
   disk_mount_manager_->UnmountPath(
       mount_path, chromeos::UNMOUNT_OPTIONS_NONE,
       base::Bind(
           &VolumeManager::OnExternalStorageDisabledChangedUnmountCallback,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
+void VolumeManager::OnFileSystemsReady() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(base::FeatureList::IsEnabled(arc::kMediaViewFeature));
+  DCHECK(arc::ArcSessionManager::IsAllowedForProfile(profile_));
+
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE,
+               linked_ptr<Volume>(
+                   Volume::CreateForMediaView(arc::kImagesRootDocumentId)));
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE,
+               linked_ptr<Volume>(
+                   Volume::CreateForMediaView(arc::kVideosRootDocumentId)));
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE,
+               linked_ptr<Volume>(
+                   Volume::CreateForMediaView(arc::kAudioRootDocumentId)));
+}
+
+void VolumeManager::OnFileSystemsClosed() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(base::FeatureList::IsEnabled(arc::kMediaViewFeature));
+  DCHECK(arc::ArcSessionManager::IsAllowedForProfile(profile_));
+
+  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
+                 linked_ptr<Volume>(
+                     Volume::CreateForMediaView(arc::kImagesRootDocumentId)));
+  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
+                 linked_ptr<Volume>(
+                     Volume::CreateForMediaView(arc::kVideosRootDocumentId)));
+  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
+                 linked_ptr<Volume>(
+                     Volume::CreateForMediaView(arc::kAudioRootDocumentId)));
+}
+
 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 their 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?
     if (disk_mount_manager_->mount_points().empty())
       return;
@@ skipping 198 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 (auto& observer : observers_)
     observer.OnVolumeUnmounted(error_code, *volume.get());
 }
 
 }  // namespace file_manager