chrome/browser/chromeos/extensions/file_manager/private_api_util.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_util.h"
   6
   7 #include <string>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "chrome/browser/chromeos/drive/drive.pb.h"
  12 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
  13 #include "chrome/browser/chromeos/drive/file_errors.h"
  14 #include "chrome/browser/chromeos/drive/file_system_interface.h"
  15 #include "chrome/browser/chromeos/drive/file_system_util.h"
  16 #include "chrome/browser/chromeos/file_manager/app_id.h"
  17 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
  18 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
  19 #include "chrome/browser/chromeos/file_manager/path_util.h"
  20 #include "chrome/browser/chromeos/file_manager/snapshot_manager.h"
  21 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
  22 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
  23 #include "chrome/browser/profiles/profile.h"
  24 #include "chrome/common/extensions/api/file_manager_private.h"
  25 #include "content/public/browser/child_process_security_policy.h"
  26 #include "storage/browser/fileapi/file_system_context.h"
  27 #include "storage/browser/fileapi/file_system_url.h"
  28 #include "ui/shell_dialogs/selected_file_info.h"
  29
  30 namespace file_manager_private = extensions::api::file_manager_private;
  31
  32 namespace file_manager {
  33 namespace util {
  34 namespace {
  35
  36 // The struct is used for GetSelectedFileInfo().
  37 struct GetSelectedFileInfoParams {
  38   GetSelectedFileInfoLocalPathOption local_path_option;
  39   GetSelectedFileInfoCallback callback;
  40   std::vector<base::FilePath> file_paths;
  41   std::vector<ui::SelectedFileInfo> selected_files;
  42 };
  43
  44 // The callback type for GetFileNativeLocalPathFor{Opening,Saving}. It receives
  45 // the resolved local path when successful, and receives empty path for failure.
  46 typedef base::Callback<void(const base::FilePath&)> LocalPathCallback;
  47
  48 // Converts a callback from Drive file system to LocalPathCallback.
  49 void OnDriveGetFile(const base::FilePath& path,
  50                     const LocalPathCallback& callback,
  51                     drive::FileError error,
  52                     const base::FilePath& local_file_path,
  53                     scoped_ptr<drive::ResourceEntry> entry) {
  54   if (error != drive::FILE_ERROR_OK)
  55     DLOG(ERROR) << "Failed to get " << path.value() << " with: " << error;
  56   callback.Run(local_file_path);
  57 }
  58
  59 // Gets a resolved local file path of a non native |path| for file opening.
  60 void GetFileNativeLocalPathForOpening(Profile* profile,
  61                                       const base::FilePath& path,
  62                                       const LocalPathCallback& callback) {
  63   if (drive::util::IsUnderDriveMountPoint(path)) {
  64     drive::FileSystemInterface* file_system =
  65         drive::util::GetFileSystemByProfile(profile);
  66     if (!file_system) {
  67       DLOG(ERROR) << "Drive file selected while disabled: " << path.value();
  68       callback.Run(base::FilePath());
  69       return;
  70     }
  71     file_system->GetFile(drive::util::ExtractDrivePath(path),
  72                          base::Bind(&OnDriveGetFile, path, callback));
  73     return;
  74   }
  75
  76   VolumeManager::Get(profile)->snapshot_manager()->CreateManagedSnapshot(
  77       path, callback);
  78 }
  79
  80 // Gets a resolved local file path of a non native |path| for file saving.
  81 void GetFileNativeLocalPathForSaving(Profile* profile,
  82                                      const base::FilePath& path,
  83                                      const LocalPathCallback& callback) {
  84   if (drive::util::IsUnderDriveMountPoint(path)) {
  85     drive::FileSystemInterface* file_system =
  86         drive::util::GetFileSystemByProfile(profile);
  87     if (!file_system) {
  88       DLOG(ERROR) << "Drive file selected while disabled: " << path.value();
  89       callback.Run(base::FilePath());
  90       return;
  91     }
  92     file_system->GetFileForSaving(drive::util::ExtractDrivePath(path),
  93                                   base::Bind(&OnDriveGetFile, path, callback));
  94     return;
  95   }
  96
  97   // TODO(kinaba): For now, the only writable non-local volume is Drive.
  98   NOTREACHED();
  99   callback.Run(base::FilePath());
 100 }
 101
 102 // Forward declarations of helper functions for GetSelectedFileInfo().
 103 void ContinueGetSelectedFileInfo(Profile* profile,
 104                                  scoped_ptr<GetSelectedFileInfoParams> params,
 105                                  const base::FilePath& local_file_path);
 106
 107 // Part of GetSelectedFileInfo().
 108 void GetSelectedFileInfoInternal(Profile* profile,
 109                                  scoped_ptr<GetSelectedFileInfoParams> params) {
 110   DCHECK(profile);
 111
 112   for (size_t i = params->selected_files.size();
 113        i < params->file_paths.size(); ++i) {
 114     const base::FilePath& file_path = params->file_paths[i];
 115
 116     if (file_manager::util::IsUnderNonNativeLocalPath(profile, file_path)) {
 117       // When the caller of the select file dialog wants local file paths, and
 118       // the selected path does not point to a native local path (e.g., Drive,
 119       // MTP, or provided file system), we should resolve the path.
 120       switch (params->local_path_option) {
 121         case NO_LOCAL_PATH_RESOLUTION:
 122           // Pass empty local path.
 123           params->selected_files.push_back(
 124               ui::SelectedFileInfo(file_path, base::FilePath()));
 125           break;
 126         case NEED_LOCAL_PATH_FOR_OPENING:
 127           GetFileNativeLocalPathForOpening(
 128               profile,
 129               file_path,
 130               base::Bind(&ContinueGetSelectedFileInfo,
 131                          profile,
 132                          base::Passed(&params)));
 133           return;  // Remaining work is done in ContinueGetSelectedFileInfo.
 134         case NEED_LOCAL_PATH_FOR_SAVING:
 135           GetFileNativeLocalPathForSaving(
 136               profile,
 137               file_path,
 138               base::Bind(&ContinueGetSelectedFileInfo,
 139                          profile,
 140                          base::Passed(&params)));
 141           return;  // Remaining work is done in ContinueGetSelectedFileInfo.
 142       }
 143     } else {
 144       params->selected_files.push_back(
 145           ui::SelectedFileInfo(file_path, file_path));
 146     }
 147   }
 148   params->callback.Run(params->selected_files);
 149 }
 150
 151 // Part of GetSelectedFileInfo().
 152 void ContinueGetSelectedFileInfo(Profile* profile,
 153                                  scoped_ptr<GetSelectedFileInfoParams> params,
 154                                  const base::FilePath& local_path) {
 155   if (local_path.empty()) {
 156     params->callback.Run(std::vector<ui::SelectedFileInfo>());
 157     return;
 158   }
 159   const int index = params->selected_files.size();
 160   const base::FilePath& file_path = params->file_paths[index];
 161   params->selected_files.push_back(ui::SelectedFileInfo(file_path, local_path));
 162   GetSelectedFileInfoInternal(profile, params.Pass());
 163 }
 164
 165 }  // namespace
 166
 167 void VolumeInfoToVolumeMetadata(
 168     Profile* profile,
 169     const VolumeInfo& volume_info,
 170     file_manager_private::VolumeMetadata* volume_metadata) {
 171   DCHECK(volume_metadata);
 172
 173   volume_metadata->volume_id = volume_info.volume_id;
 174
 175   // TODO(kinaba): fill appropriate information once multi-profile support is
 176   // implemented.
 177   volume_metadata->profile.display_name = profile->GetProfileUserName();
 178   volume_metadata->profile.is_current_profile = true;
 179
 180   if (!volume_info.source_path.empty()) {
 181     volume_metadata->source_path.reset(
 182         new std::string(volume_info.source_path.AsUTF8Unsafe()));
 183   }
 184
 185   if (volume_info.type == VOLUME_TYPE_PROVIDED) {
 186     volume_metadata->extension_id.reset(
 187         new std::string(volume_info.extension_id));
 188
 189     volume_metadata->file_system_id.reset(
 190         new std::string(volume_info.file_system_id));
 191   }
 192
 193   volume_metadata->volume_label.reset(
 194       new std::string(volume_info.volume_label));
 195
 196   switch (volume_info.type) {
 197     case VOLUME_TYPE_GOOGLE_DRIVE:
 198       volume_metadata->volume_type =
 199           file_manager_private::VOLUME_TYPE_DRIVE;
 200       break;
 201     case VOLUME_TYPE_DOWNLOADS_DIRECTORY:
 202       volume_metadata->volume_type =
 203           file_manager_private::VOLUME_TYPE_DOWNLOADS;
 204       break;
 205     case VOLUME_TYPE_REMOVABLE_DISK_PARTITION:
 206       volume_metadata->volume_type =
 207           file_manager_private::VOLUME_TYPE_REMOVABLE;
 208       break;
 209     case VOLUME_TYPE_MOUNTED_ARCHIVE_FILE:
 210       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_ARCHIVE;
 211       break;
 212     case VOLUME_TYPE_CLOUD_DEVICE:
 213       volume_metadata->volume_type =
 214           file_manager_private::VOLUME_TYPE_CLOUD_DEVICE;
 215       break;
 216     case VOLUME_TYPE_PROVIDED:
 217       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_PROVIDED;
 218       break;
 219     case VOLUME_TYPE_MTP:
 220       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_MTP;
 221       break;
 222     case VOLUME_TYPE_TESTING:
 223       volume_metadata->volume_type =
 224           file_manager_private::VOLUME_TYPE_TESTING;
 225       break;
 226     case NUM_VOLUME_TYPE:
 227       NOTREACHED();
 228       break;
 229   }
 230
 231   // Fill device_type iff the volume is removable partition.
 232   if (volume_info.type == VOLUME_TYPE_REMOVABLE_DISK_PARTITION) {
 233     switch (volume_info.device_type) {
 234       case chromeos::DEVICE_TYPE_UNKNOWN:
 235         volume_metadata->device_type =
 236             file_manager_private::DEVICE_TYPE_UNKNOWN;
 237         break;
 238       case chromeos::DEVICE_TYPE_USB:
 239         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_USB;
 240         break;
 241       case chromeos::DEVICE_TYPE_SD:
 242         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_SD;
 243         break;
 244       case chromeos::DEVICE_TYPE_OPTICAL_DISC:
 245       case chromeos::DEVICE_TYPE_DVD:
 246         volume_metadata->device_type =
 247             file_manager_private::DEVICE_TYPE_OPTICAL;
 248         break;
 249       case chromeos::DEVICE_TYPE_MOBILE:
 250         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_MOBILE;
 251         break;
 252     }
 253     volume_metadata->device_path.reset(
 254         new std::string(volume_info.system_path_prefix.AsUTF8Unsafe()));
 255     volume_metadata->is_parent_device.reset(
 256         new bool(volume_info.is_parent));
 257   } else {
 258     volume_metadata->device_type =
 259         file_manager_private::DEVICE_TYPE_NONE;
 260   }
 261
 262   volume_metadata->is_read_only = volume_info.is_read_only;
 263   volume_metadata->has_media = volume_info.has_media;
 264
 265   switch (volume_info.mount_condition) {
 266     case chromeos::disks::MOUNT_CONDITION_NONE:
 267       volume_metadata->mount_condition =
 268           file_manager_private::MOUNT_CONDITION_NONE;
 269       break;
 270     case chromeos::disks::MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
 271       volume_metadata->mount_condition =
 272           file_manager_private::MOUNT_CONDITION_UNKNOWN;
 273       break;
 274     case chromeos::disks::MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
 275       volume_metadata->mount_condition =
 276           file_manager_private::MOUNT_CONDITION_UNSUPPORTED;
 277       break;
 278   }
 279
 280   // If the context is known, then pass it.
 281   switch (volume_info.mount_context) {
 282     case MOUNT_CONTEXT_USER:
 283       volume_metadata->mount_context = file_manager_private::MOUNT_CONTEXT_USER;
 284       break;
 285     case MOUNT_CONTEXT_AUTO:
 286       volume_metadata->mount_context = file_manager_private::MOUNT_CONTEXT_AUTO;
 287       break;
 288     case MOUNT_CONTEXT_UNKNOWN:
 289       break;
 290   }
 291 }
 292
 293 base::FilePath GetLocalPathFromURL(content::RenderViewHost* render_view_host,
 294                                    Profile* profile,
 295                                    const GURL& url) {
 296   DCHECK(render_view_host);
 297   DCHECK(profile);
 298
 299   scoped_refptr<storage::FileSystemContext> file_system_context =
 300       util::GetFileSystemContextForRenderViewHost(profile, render_view_host);
 301
 302   const storage::FileSystemURL filesystem_url(
 303       file_system_context->CrackURL(url));
 304   base::FilePath path;
 305   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
 306     return base::FilePath();
 307   return filesystem_url.path();
 308 }
 309
 310 void GetSelectedFileInfo(content::RenderViewHost* render_view_host,
 311                          Profile* profile,
 312                          const std::vector<GURL>& file_urls,
 313                          GetSelectedFileInfoLocalPathOption local_path_option,
 314                          GetSelectedFileInfoCallback callback) {
 315   DCHECK(render_view_host);
 316   DCHECK(profile);
 317
 318   scoped_ptr<GetSelectedFileInfoParams> params(new GetSelectedFileInfoParams);
 319   params->local_path_option = local_path_option;
 320   params->callback = callback;
 321
 322   for (size_t i = 0; i < file_urls.size(); ++i) {
 323     const GURL& file_url = file_urls[i];
 324     const base::FilePath path = GetLocalPathFromURL(
 325         render_view_host, profile, file_url);
 326     if (!path.empty()) {
 327       DVLOG(1) << "Selected: file path: " << path.value();
 328       params->file_paths.push_back(path);
 329     }
 330   }
 331
 332   base::MessageLoop::current()->PostTask(
 333       FROM_HERE,
 334       base::Bind(&GetSelectedFileInfoInternal, profile, base::Passed(&params)));
 335 }
 336
 337 void SetupProfileFileAccessPermissions(int render_view_process_id,
 338                                        Profile* profile) {
 339   const base::FilePath paths[] = {
 340     drive::util::GetDriveMountPointPath(profile),
 341     util::GetDownloadsFolderForProfile(profile),
 342   };
 343   for (size_t i = 0; i < arraysize(paths); ++i) {
 344     content::ChildProcessSecurityPolicy::GetInstance(
 345         )->GrantCreateReadWriteFile(render_view_process_id, paths[i]);
 346   }
 347 }
 348
 349 drive::EventLogger* GetLogger(Profile* profile) {
 350   drive::DriveIntegrationService* service =
 351       drive::DriveIntegrationServiceFactory::FindForProfile(profile);
 352   return service ? service->event_logger() : NULL;
 353 }
 354
 355 }  // namespace util
 356 }  // namespace file_manager