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_integration_service.h"
  12 #include "chrome/browser/chromeos/drive/file_errors.h"
  13 #include "chrome/browser/chromeos/drive/file_system_interface.h"
  14 #include "chrome/browser/chromeos/drive/file_system_util.h"
  15 #include "chrome/browser/chromeos/file_manager/app_id.h"
  16 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
  17 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
  18 #include "chrome/browser/chromeos/file_manager/path_util.h"
  19 #include "chrome/browser/chromeos/file_manager/snapshot_manager.h"
  20 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
  21 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/common/extensions/api/file_manager_private.h"
  24 #include "components/drive/drive.pb.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 VolumeToVolumeMetadata(
 168     Profile* profile,
 169     const Volume& volume,
 170     file_manager_private::VolumeMetadata* volume_metadata) {
 171   DCHECK(volume_metadata);
 172
 173   volume_metadata->volume_id = volume.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.source_path().empty()) {
 181     volume_metadata->source_path.reset(
 182         new std::string(volume.source_path().AsUTF8Unsafe()));
 183   }
 184
 185   switch (volume.source()) {
 186     case SOURCE_FILE:
 187       volume_metadata->source = file_manager_private::SOURCE_FILE;
 188       break;
 189     case SOURCE_DEVICE:
 190       volume_metadata->source = file_manager_private::SOURCE_DEVICE;
 191       break;
 192     case SOURCE_NETWORK:
 193       volume_metadata->source =
 194           extensions::api::file_manager_private::SOURCE_NETWORK;
 195       break;
 196     case SOURCE_SYSTEM:
 197       volume_metadata->source =
 198           extensions::api::file_manager_private::SOURCE_SYSTEM;
 199       break;
 200   }
 201
 202   volume_metadata->configurable = volume.configurable();
 203   volume_metadata->watchable = volume.watchable();
 204
 205   if (volume.type() == VOLUME_TYPE_PROVIDED) {
 206     volume_metadata->extension_id.reset(new std::string(volume.extension_id()));
 207     volume_metadata->file_system_id.reset(
 208         new std::string(volume.file_system_id()));
 209   }
 210
 211   volume_metadata->volume_label.reset(new std::string(volume.volume_label()));
 212
 213   switch (volume.type()) {
 214     case VOLUME_TYPE_GOOGLE_DRIVE:
 215       volume_metadata->volume_type =
 216           file_manager_private::VOLUME_TYPE_DRIVE;
 217       break;
 218     case VOLUME_TYPE_DOWNLOADS_DIRECTORY:
 219       volume_metadata->volume_type =
 220           file_manager_private::VOLUME_TYPE_DOWNLOADS;
 221       break;
 222     case VOLUME_TYPE_REMOVABLE_DISK_PARTITION:
 223       volume_metadata->volume_type =
 224           file_manager_private::VOLUME_TYPE_REMOVABLE;
 225       break;
 226     case VOLUME_TYPE_MOUNTED_ARCHIVE_FILE:
 227       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_ARCHIVE;
 228       break;
 229     case VOLUME_TYPE_PROVIDED:
 230       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_PROVIDED;
 231       break;
 232     case VOLUME_TYPE_MTP:
 233       volume_metadata->volume_type = file_manager_private::VOLUME_TYPE_MTP;
 234       break;
 235     case VOLUME_TYPE_TESTING:
 236       volume_metadata->volume_type =
 237           file_manager_private::VOLUME_TYPE_TESTING;
 238       break;
 239     case NUM_VOLUME_TYPE:
 240       NOTREACHED();
 241       break;
 242   }
 243
 244   // Fill device_type iff the volume is removable partition.
 245   if (volume.type() == VOLUME_TYPE_REMOVABLE_DISK_PARTITION) {
 246     switch (volume.device_type()) {
 247       case chromeos::DEVICE_TYPE_UNKNOWN:
 248         volume_metadata->device_type =
 249             file_manager_private::DEVICE_TYPE_UNKNOWN;
 250         break;
 251       case chromeos::DEVICE_TYPE_USB:
 252         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_USB;
 253         break;
 254       case chromeos::DEVICE_TYPE_SD:
 255         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_SD;
 256         break;
 257       case chromeos::DEVICE_TYPE_OPTICAL_DISC:
 258       case chromeos::DEVICE_TYPE_DVD:
 259         volume_metadata->device_type =
 260             file_manager_private::DEVICE_TYPE_OPTICAL;
 261         break;
 262       case chromeos::DEVICE_TYPE_MOBILE:
 263         volume_metadata->device_type = file_manager_private::DEVICE_TYPE_MOBILE;
 264         break;
 265     }
 266     volume_metadata->device_path.reset(
 267         new std::string(volume.system_path_prefix().AsUTF8Unsafe()));
 268     volume_metadata->is_parent_device.reset(new bool(volume.is_parent()));
 269   } else {
 270     volume_metadata->device_type =
 271         file_manager_private::DEVICE_TYPE_NONE;
 272   }
 273
 274   volume_metadata->is_read_only = volume.is_read_only();
 275   volume_metadata->has_media = volume.has_media();
 276
 277   switch (volume.mount_condition()) {
 278     case chromeos::disks::MOUNT_CONDITION_NONE:
 279       volume_metadata->mount_condition =
 280           file_manager_private::MOUNT_CONDITION_NONE;
 281       break;
 282     case chromeos::disks::MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
 283       volume_metadata->mount_condition =
 284           file_manager_private::MOUNT_CONDITION_UNKNOWN;
 285       break;
 286     case chromeos::disks::MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
 287       volume_metadata->mount_condition =
 288           file_manager_private::MOUNT_CONDITION_UNSUPPORTED;
 289       break;
 290   }
 291
 292   // If the context is known, then pass it.
 293   switch (volume.mount_context()) {
 294     case MOUNT_CONTEXT_USER:
 295       volume_metadata->mount_context = file_manager_private::MOUNT_CONTEXT_USER;
 296       break;
 297     case MOUNT_CONTEXT_AUTO:
 298       volume_metadata->mount_context = file_manager_private::MOUNT_CONTEXT_AUTO;
 299       break;
 300     case MOUNT_CONTEXT_UNKNOWN:
 301       break;
 302   }
 303 }
 304
 305 base::FilePath GetLocalPathFromURL(content::RenderFrameHost* render_frame_host,
 306                                    Profile* profile,
 307                                    const GURL& url) {
 308   DCHECK(render_frame_host);
 309   DCHECK(profile);
 310
 311   scoped_refptr<storage::FileSystemContext> file_system_context =
 312       util::GetFileSystemContextForRenderFrameHost(profile, render_frame_host);
 313
 314   const storage::FileSystemURL filesystem_url(
 315       file_system_context->CrackURL(url));
 316   base::FilePath path;
 317   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
 318     return base::FilePath();
 319   return filesystem_url.path();
 320 }
 321
 322 void GetSelectedFileInfo(content::RenderFrameHost* render_frame_host,
 323                          Profile* profile,
 324                          const std::vector<GURL>& file_urls,
 325                          GetSelectedFileInfoLocalPathOption local_path_option,
 326                          GetSelectedFileInfoCallback callback) {
 327   DCHECK(render_frame_host);
 328   DCHECK(profile);
 329
 330   scoped_ptr<GetSelectedFileInfoParams> params(new GetSelectedFileInfoParams);
 331   params->local_path_option = local_path_option;
 332   params->callback = callback;
 333
 334   for (size_t i = 0; i < file_urls.size(); ++i) {
 335     const GURL& file_url = file_urls[i];
 336     const base::FilePath path = GetLocalPathFromURL(
 337         render_frame_host, profile, file_url);
 338     if (!path.empty()) {
 339       DVLOG(1) << "Selected: file path: " << path.value();
 340       params->file_paths.push_back(path);
 341     }
 342   }
 343
 344   base::MessageLoop::current()->PostTask(
 345       FROM_HERE,
 346       base::Bind(&GetSelectedFileInfoInternal, profile, base::Passed(&params)));
 347 }
 348
 349 void SetupProfileFileAccessPermissions(int render_view_process_id,
 350                                        Profile* profile) {
 351   const base::FilePath paths[] = {
 352     drive::util::GetDriveMountPointPath(profile),
 353     util::GetDownloadsFolderForProfile(profile),
 354   };
 355   for (size_t i = 0; i < arraysize(paths); ++i) {
 356     content::ChildProcessSecurityPolicy::GetInstance(
 357         )->GrantCreateReadWriteFile(render_view_process_id, paths[i]);
 358   }
 359 }
 360
 361 drive::EventLogger* GetLogger(Profile* profile) {
 362   drive::DriveIntegrationService* service =
 363       drive::DriveIntegrationServiceFactory::FindForProfile(profile);
 364   return service ? service->event_logger() : NULL;
 365 }
 366
 367 }  // namespace util
 368 }  // namespace file_manager