chrome/browser/chromeos/file_manager/fileapi_util.h

   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 // This file provides File API related utilities.
   6
   7 #ifndef CHROME_BROWSER_CHROMEOS_FILE_MANAGER_FILEAPI_UTIL_H_
   8 #define CHROME_BROWSER_CHROMEOS_FILE_MANAGER_FILEAPI_UTIL_H_
   9
  10 #include <string>
  11
  12 #include "base/callback_forward.h"
  13 #include "base/files/file.h"
  14 #include "base/files/file_path.h"
  15 #include "storage/browser/fileapi/file_system_operation_runner.h"
  16 #include "url/gurl.h"
  17
  18 class Profile;
  19
  20 namespace content {
  21 struct FileChooserFileInfo;
  22 class RenderViewHost;
  23 }
  24
  25 namespace storage {
  26 class FileSystemContext;
  27 }
  28
  29 namespace ui {
  30 struct SelectedFileInfo;
  31 }
  32
  33 namespace file_manager {
  34 namespace util {
  35
  36 // Structure information necessary to create a EntryDefinition, and therefore
  37 // an Entry object on the JavaScript side.
  38 struct FileDefinition {
  39   base::FilePath virtual_path;
  40   base::FilePath absolute_path;
  41   bool is_directory;
  42 };
  43
  44 // Contains all information needed to create an Entry object in custom bindings.
  45 struct EntryDefinition {
  46   EntryDefinition();
  47   ~EntryDefinition();
  48
  49   std::string file_system_root_url;  // Used to create DOMFileSystem.
  50   std::string file_system_name;      // Value of DOMFileSystem.name.
  51   base::FilePath full_path;    // Value of Entry.fullPath.
  52   // Whether to create FileEntry or DirectoryEntry when the corresponding entry
  53   // is not found.
  54   bool is_directory;
  55   base::File::Error error;
  56 };
  57
  58 typedef std::vector<FileDefinition> FileDefinitionList;
  59 typedef std::vector<EntryDefinition> EntryDefinitionList;
  60 typedef std::vector<ui::SelectedFileInfo> SelectedFileInfoList;
  61 typedef std::vector<content::FileChooserFileInfo> FileChooserFileInfoList;
  62
  63 // The callback used by ConvertFileDefinitionToEntryDefinition. Returns the
  64 // result of the conversion.
  65 typedef base::Callback<void(const EntryDefinition& entry_definition)>
  66     EntryDefinitionCallback;
  67
  68 // The callback used by ConvertFileDefinitionListToEntryDefinitionList. Returns
  69 // the result of the conversion as a list.
  70 typedef base::Callback<void(scoped_ptr<
  71     EntryDefinitionList> entry_definition_list)> EntryDefinitionListCallback;
  72
  73 // The callback used by
  74 // ConvertFileSelectedInfoListToFileChooserFileInfoList. Returns the result of
  75 // the conversion as a list.
  76 typedef base::Callback<void(const FileChooserFileInfoList&)>
  77     FileChooserFileInfoListCallback;
  78
  79 // Returns a file system context associated with the given profile and the
  80 // extension ID.
  81 storage::FileSystemContext* GetFileSystemContextForExtensionId(
  82     Profile* profile,
  83     const std::string& extension_id);
  84
  85 // Returns a file system context associated with the given profile and the
  86 // render view host.
  87 storage::FileSystemContext* GetFileSystemContextForRenderViewHost(
  88     Profile* profile,
  89     content::RenderViewHost* render_view_host);
  90
  91 // Converts DrivePath (e.g., "drive/root", which always starts with the fixed
  92 // "drive" directory) to a RelativeFileSystemPathrelative (e.g.,
  93 // "drive-xxx/root/foo". which starts from the "mount point" in the FileSystem
  94 // API that may be distinguished for each profile by the appended "xxx" part.)
  95 base::FilePath ConvertDrivePathToRelativeFileSystemPath(
  96     Profile* profile,
  97     const std::string& extension_id,
  98     const base::FilePath& drive_path);
  99
 100 // Converts DrivePath to FileSystem URL.
 101 // E.g., "drive/root" to filesystem://id/external/drive-xxx/root.
 102 GURL ConvertDrivePathToFileSystemUrl(Profile* profile,
 103                                      const base::FilePath& drive_path,
 104                                      const std::string& extension_id);
 105
 106 // Converts AbsolutePath (e.g., "/special/drive-xxx/root" or
 107 // "/home/chronos/u-xxx/Downloads") into filesystem URL. Returns false
 108 // if |absolute_path| is not managed by the external filesystem provider.
 109 bool ConvertAbsoluteFilePathToFileSystemUrl(Profile* profile,
 110                                             const base::FilePath& absolute_path,
 111                                             const std::string& extension_id,
 112                                             GURL* url);
 113
 114 // Converts AbsolutePath into RelativeFileSystemPath (e.g.,
 115 // "/special/drive-xxx/root/foo" => "drive-xxx/root/foo".) Returns false if
 116 // |absolute_path| is not managed by the external filesystem provider.
 117 bool ConvertAbsoluteFilePathToRelativeFileSystemPath(
 118     Profile* profile,
 119     const std::string& extension_id,
 120     const base::FilePath& absolute_path,
 121     base::FilePath* relative_path);
 122
 123 // Converts a file definition to a entry definition and returns the result
 124 // via a callback. |profile| cannot be null. Must be called on UI thread.
 125 void ConvertFileDefinitionToEntryDefinition(
 126     Profile* profile,
 127     const std::string& extension_id,
 128     const FileDefinition& file_definition,
 129     const EntryDefinitionCallback& callback);
 130
 131 // Converts a list of file definitions into a list of entry definitions and
 132 // returns it via |callback|. The method is safe, |file_definition_list| is
 133 // copied internally. The output list has the same order of items and size as
 134 // the input vector. |profile| cannot be null. Must be called on UI thread.
 135 void ConvertFileDefinitionListToEntryDefinitionList(
 136     Profile* profile,
 137     const std::string& extension_id,
 138     const FileDefinitionList& file_definition_list,
 139     const EntryDefinitionListCallback& callback);
 140
 141 // Converts SelectedFileInfoList into FileChooserFileInfoList.
 142 void ConvertSelectedFileInfoListToFileChooserFileInfoList(
 143     storage::FileSystemContext* context,
 144     const GURL& origin,
 145     const SelectedFileInfoList& selected_info_list,
 146     const FileChooserFileInfoListCallback& callback);
 147
 148 // Checks if a directory exists at |directory_path| absolute path.
 149 void CheckIfDirectoryExists(
 150     scoped_refptr<storage::FileSystemContext> file_system_context,
 151     const base::FilePath& directory_path,
 152     const storage::FileSystemOperationRunner::StatusCallback& callback);
 153
 154 // Get metadata for an entry at |entry_path| absolute path.
 155 void GetMetadataForPath(
 156     scoped_refptr<storage::FileSystemContext> file_system_context,
 157     const base::FilePath& entry_path,
 158     const storage::FileSystemOperationRunner::GetMetadataCallback& callback);
 159
 160 // Obtains isolated file system URL from |virtual_path| pointing a file in the
 161 // external file system.
 162 storage::FileSystemURL CreateIsolatedURLFromVirtualPath(
 163     const storage::FileSystemContext& context,
 164     const GURL& origin,
 165     const base::FilePath& virtual_path);
 166
 167 }  // namespace util
 168 }  // namespace file_manager
 169
 170 #endif  // CHROME_BROWSER_CHROMEOS_FILE_MANAGER_FILEAPI_UTIL_H_