Files.app: filter out zip archives mounted in other profiles.

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"
@@ skipping 194 matching lines @@
 }
 
 VolumeManager::~VolumeManager() {
 }
 
 VolumeManager* VolumeManager::Get(content::BrowserContext* context) {
   return VolumeManagerFactory::Get(context);
 }
 
 void VolumeManager::Initialize() {
+  const bool kNotRemounting = false;
+
   // Path to mount user folders have changed several times. We need to migrate
   // the old preferences on paths to the new format when needed. For the detail,
   // see the comments in file_manager::util::MigratePathFromOldFormat,
   // Note: Preferences related to downloads are handled in download_prefs.cc.
   // TODO(kinaba): Remove this after several rounds of releases.
   const base::FilePath old_path =
       profile_->GetPrefs()->GetFilePath(prefs::kSelectFileLastDirectory);
   base::FilePath new_path;
   if (!old_path.empty() &&
       file_manager::util::MigratePathFromOldFormat(profile_,
                                                    old_path, &new_path)) {
     profile_->GetPrefs()->SetFilePath(prefs::kSelectFileLastDirectory,
                                       new_path);
   }
 
   // Register 'Downloads' folder for the profile to the file system.
   if (!chromeos::ProfileHelper::IsSigninProfile(profile_)) {
     const base::FilePath downloads =
         file_manager::util::GetDownloadsFolderForProfile(profile_);
     const bool success = RegisterDownloadsMountPoint(profile_, downloads);
     DCHECK(success);
 
     DoMountEvent(chromeos::MOUNT_ERROR_NONE,
                  CreateDownloadsVolumeInfo(downloads),
-                 false /* is_remounting */);
+                 kNotRemounting);
   }
 
   // Subscribe to DriveIntegrationService.
   if (drive_integration_service_) {
     drive_integration_service_->AddObserver(this);
     if (drive_integration_service_->IsMounted()) {
-      DoMountEvent(
-          chromeos::MOUNT_ERROR_NONE, CreateDriveVolumeInfo(profile_), false);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE,
+                   CreateDriveVolumeInfo(profile_),
+                   kNotRemounting);
     }
   }
 
   // Subscribe to DiskMountManager.
   disk_mount_manager_->AddObserver(this);
 
+  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.
+      archives.push_back(CreateVolumeInfoFromMountPointInfo(it->second, NULL));
+      continue;
+    }
     DoMountEvent(
         chromeos::MOUNT_ERROR_NONE,
         CreateVolumeInfoFromMountPointInfo(
             it->second,
             disk_mount_manager_->FindDiskBySourcePath(it->second.source_path)),
-        false /* is_remounting */);
+            kNotRemounting);
+  }
+
+  // We mount archives only if they are opened from currently mounted volumes.
+  // To check the condition correctly in DoMountEvent, we care the order.
+  std::vector<bool> done(archives.size(), false);
+  for (size_t i = 0; i < archives.size(); ++i) {
+    if (!done[i]) {
+      std::vector<VolumeInfo> chain;
+      done[i] = true;
+      chain.push_back(archives[i]);
+
+      // If archives[i]'s source_path is in another archive, mount it first.
+      for (size_t parent = 0; parent < archives.size(); ++parent) {
+        if (!done[parent] &&
+            archives[parent].mount_path.IsParent(chain.back().source_path)) {
+          done[parent] = true;
+          chain.push_back(archives[parent]);
+          parent = 0;  // Search archives[parent]'s parent from the beginning.
+        }
+      }
+
+      // Mount from the tail of chain.
+      for (size_t i = chain.size(); i > 0; --i)
+        DoMountEvent(chromeos::MOUNT_ERROR_NONE, chain[i - 1], kNotRemounting);
+    }
   }
 
   disk_mount_manager_->RequestMountInfoRefresh();
 
   // Subscribe to Profile Preference change.
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kExternalStorageDisabled,
       base::Bind(&VolumeManager::OnExternalStorageDisabledChanged,
                  base::Unretained(this)));
@@ skipping 273 matching lines @@
   for (local_discovery::PrivetVolumeLister::VolumeList::const_iterator i =
            volumes.begin(); i != volumes.end(); i++) {
     VolumeInfo volume_info = CreatePrivetVolumeInfo(*i);
     DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, false);
   }
 }
 
 void VolumeManager::DoMountEvent(chromeos::MountError error_code,
                                  const VolumeInfo& volume_info,
                                  bool is_remounting) {
-  // TODO(kinaba): filter zip.
+  // Archive files are mounted globally in system. We however don't want to show
+  // archives from profile-specific folders (Drive/Downloads) of other users in
+  // multi-profile session. To this end, we filter out archives not on the
+  // volumes already mounted on this VolumeManager instance.
+  if (volume_info.type == VOLUME_TYPE_MOUNTED_ARCHIVE_FILE) {
+    // Source may be in Drive cache folder under the current profile directory.
+    bool from_current_profile =
+        profile_->GetPath().IsParent(volume_info.source_path);
+    for (std::map<std::string, VolumeInfo>::const_iterator iter =
+             mounted_volumes_.begin();
+         !from_current_profile && iter != mounted_volumes_.end();
+         ++iter) {
+      if (iter->second.mount_path.IsParent(volume_info.source_path))
+        from_current_profile = true;
+    }
+    if (!from_current_profile)
+      return;
+  }
 
   if (error_code == chromeos::MOUNT_ERROR_NONE || volume_info.mount_condition)
     mounted_volumes_[volume_info.volume_id] = volume_info;
 
   FOR_EACH_OBSERVER(VolumeManagerObserver,
                     observers_,
                     OnVolumeMounted(error_code, volume_info, is_remounting));
 }
 
 void VolumeManager::DoUnmountEvent(chromeos::MountError error_code,
                                    const VolumeInfo& volume_info) {
   if (mounted_volumes_.find(volume_info.volume_id) == mounted_volumes_.end())
     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