src/chrome/browser/chromeos/extensions/file_manager/private_api_mount.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/extensions/file_manager/private_api_mount.h"
   6
   7 #include <string>
   8
   9 #include "base/format_macros.h"
  10 #include "chrome/browser/chromeos/drive/file_system_interface.h"
  11 #include "chrome/browser/chromeos/drive/file_system_util.h"
  12 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
  13 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
  14 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
  15 #include "chrome/browser/drive/event_logger.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/common/extensions/api/file_browser_private.h"
  18 #include "chromeos/disks/disk_mount_manager.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "ui/shell_dialogs/selected_file_info.h"
  21
  22 using chromeos::disks::DiskMountManager;
  23 using content::BrowserThread;
  24 namespace file_browser_private = extensions::api::file_browser_private;
  25
  26 namespace extensions {
  27
  28 bool FileBrowserPrivateAddMountFunction::RunAsync() {
  29   using file_browser_private::AddMount::Params;
  30   const scoped_ptr<Params> params(Params::Create(*args_));
  31   EXTENSION_FUNCTION_VALIDATE(params);
  32
  33   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
  34   if (logger) {
  35     logger->Log(logging::LOG_INFO,
  36                 "%s[%d] called. (source: '%s')",
  37                 name().c_str(),
  38                 request_id(),
  39                 params->source.empty() ? "(none)" : params->source.c_str());
  40   }
  41   set_log_on_completion(true);
  42
  43   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
  44       render_view_host(), GetProfile(), GURL(params->source));
  45
  46   if (path.empty())
  47     return false;
  48
  49   // Check if the source path is under Drive cache directory.
  50   if (drive::util::IsUnderDriveMountPoint(path)) {
  51     drive::FileSystemInterface* file_system =
  52         drive::util::GetFileSystemByProfile(GetProfile());
  53     if (!file_system)
  54       return false;
  55
  56     file_system->MarkCacheFileAsMounted(
  57         drive::util::ExtractDrivePath(path),
  58         base::Bind(
  59             &FileBrowserPrivateAddMountFunction::RunAfterMarkCacheFileAsMounted,
  60             this, path.BaseName()));
  61   } else {
  62     RunAfterMarkCacheFileAsMounted(
  63         path.BaseName(), drive::FILE_ERROR_OK, path);
  64   }
  65   return true;
  66 }
  67
  68 void FileBrowserPrivateAddMountFunction::RunAfterMarkCacheFileAsMounted(
  69     const base::FilePath& display_name,
  70     drive::FileError error,
  71     const base::FilePath& file_path) {
  72   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  73
  74   if (error != drive::FILE_ERROR_OK) {
  75     SendResponse(false);
  76     return;
  77   }
  78
  79   // Pass back the actual source path of the mount point.
  80   SetResult(new base::StringValue(file_path.AsUTF8Unsafe()));
  81   SendResponse(true);
  82
  83   // MountPath() takes a std::string.
  84   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
  85   disk_mount_manager->MountPath(
  86       file_path.AsUTF8Unsafe(),
  87       base::FilePath(display_name.Extension()).AsUTF8Unsafe(),
  88       display_name.AsUTF8Unsafe(),
  89       chromeos::MOUNT_TYPE_ARCHIVE);
  90 }
  91
  92 bool FileBrowserPrivateRemoveMountFunction::RunAsync() {
  93   using file_browser_private::RemoveMount::Params;
  94   const scoped_ptr<Params> params(Params::Create(*args_));
  95   EXTENSION_FUNCTION_VALIDATE(params);
  96
  97   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
  98   if (logger) {
  99     logger->Log(logging::LOG_INFO,
 100                 "%s[%d] called. (volume_id: '%s')",
 101                 name().c_str(),
 102                 request_id(),
 103                 params->volume_id.c_str());
 104   }
 105   set_log_on_completion(true);
 106
 107   using file_manager::VolumeManager;
 108   using file_manager::VolumeInfo;
 109   VolumeManager* volume_manager = VolumeManager::Get(GetProfile());
 110   DCHECK(volume_manager);
 111
 112   VolumeInfo volume_info;
 113   if (!volume_manager->FindVolumeInfoById(params->volume_id, &volume_info))
 114     return false;
 115
 116   // TODO(tbarzic): Send response when callback is received, it would make more
 117   // sense than remembering issued unmount requests in file manager and showing
 118   // errors for them when MountCompleted event is received.
 119   switch (volume_info.type) {
 120     case file_manager::VOLUME_TYPE_REMOVABLE_DISK_PARTITION:
 121     case file_manager::VOLUME_TYPE_MOUNTED_ARCHIVE_FILE: {
 122       DiskMountManager::GetInstance()->UnmountPath(
 123           volume_info.mount_path.value(),
 124           chromeos::UNMOUNT_OPTIONS_NONE,
 125           DiskMountManager::UnmountPathCallback());
 126       break;
 127     }
 128     case file_manager::VOLUME_TYPE_PROVIDED: {
 129       chromeos::file_system_provider::Service* service =
 130           chromeos::file_system_provider::Service::Get(GetProfile());
 131       DCHECK(service);
 132       // TODO(mtomasz): Pass a more detailed error than just a bool.
 133       if (!service->RequestUnmount(volume_info.file_system_id))
 134         return false;
 135       break;
 136     }
 137     default:
 138       // Requested unmounting a device which is not unmountable.
 139       return false;
 140   }
 141
 142   SendResponse(true);
 143   return true;
 144 }
 145
 146 bool FileBrowserPrivateGetVolumeMetadataListFunction::RunAsync() {
 147   if (args_->GetSize())
 148     return false;
 149
 150   const std::vector<file_manager::VolumeInfo>& volume_info_list =
 151       file_manager::VolumeManager::Get(GetProfile())->GetVolumeInfoList();
 152
 153   std::string log_string;
 154   std::vector<linked_ptr<file_browser_private::VolumeMetadata> > result;
 155   for (size_t i = 0; i < volume_info_list.size(); ++i) {
 156     linked_ptr<file_browser_private::VolumeMetadata> volume_metadata(
 157         new file_browser_private::VolumeMetadata);
 158     file_manager::util::VolumeInfoToVolumeMetadata(
 159         GetProfile(), volume_info_list[i], volume_metadata.get());
 160     result.push_back(volume_metadata);
 161     if (!log_string.empty())
 162       log_string += ", ";
 163     log_string += volume_info_list[i].mount_path.AsUTF8Unsafe();
 164   }
 165
 166   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
 167   if (logger) {
 168     logger->Log(logging::LOG_INFO,
 169                 "%s[%d] succeeded. (results: '[%s]', %" PRIuS " mount points)",
 170                 name().c_str(), request_id(), log_string.c_str(),
 171                 result.size());
 172   }
 173
 174   results_ =
 175       file_browser_private::GetVolumeMetadataList::Results::Create(result);
 176   SendResponse(true);
 177   return true;
 178 }
 179
 180 }  // namespace extensions