src/chrome/browser/extensions/api/file_system/file_system_api.h

   1 // Copyright (c) 2012 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 #ifndef CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/files/file_path.h"
  12 #include "chrome/browser/extensions/chrome_extension_function.h"
  13 #include "chrome/common/extensions/api/file_system.h"
  14 #include "ui/shell_dialogs/select_file_dialog.h"
  15
  16 namespace extensions {
  17 class ExtensionPrefs;
  18
  19 namespace file_system_api {
  20
  21 // Methods to get and set the path of the directory containing the last file
  22 // chosen by the user in response to a chrome.fileSystem.chooseEntry() call for
  23 // the given extension.
  24
  25 // Returns an empty path on failure.
  26 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
  27                                            const std::string& extension_id);
  28
  29 void SetLastChooseEntryDirectory(ExtensionPrefs* prefs,
  30                                  const std::string& extension_id,
  31                                  const base::FilePath& path);
  32
  33 std::vector<base::FilePath> GetGrayListedDirectories();
  34
  35 }  // namespace file_system_api
  36
  37 class FileSystemGetDisplayPathFunction : public ChromeSyncExtensionFunction {
  38  public:
  39   DECLARE_EXTENSION_FUNCTION("fileSystem.getDisplayPath",
  40                              FILESYSTEM_GETDISPLAYPATH)
  41
  42  protected:
  43   virtual ~FileSystemGetDisplayPathFunction() {}
  44   virtual bool RunSync() OVERRIDE;
  45 };
  46
  47 class FileSystemEntryFunction : public ChromeAsyncExtensionFunction {
  48  protected:
  49   FileSystemEntryFunction();
  50
  51   virtual ~FileSystemEntryFunction() {}
  52
  53   // This is called when writable file entries are being returned. The function
  54   // will ensure the files exist, creating them if necessary, and also check
  55   // that none of the files are links. If it succeeds it proceeds to
  56   // RegisterFileSystemsAndSendResponse, otherwise to HandleWritableFileError.
  57   void PrepareFilesForWritableApp(const std::vector<base::FilePath>& path);
  58
  59   // This will finish the choose file process. This is either called directly
  60   // from FilesSelected, or from WritableFileChecker. It is called on the UI
  61   // thread.
  62   void RegisterFileSystemsAndSendResponse(
  63       const std::vector<base::FilePath>& path);
  64
  65   // Creates a response dictionary and sets it as the response to be sent.
  66   void CreateResponse();
  67
  68   // Adds an entry to the response dictionary.
  69   void AddEntryToResponse(const base::FilePath& path,
  70                           const std::string& id_override);
  71
  72   // called on the UI thread if there is a problem checking a writable file.
  73   void HandleWritableFileError(const base::FilePath& error_path);
  74
  75   // Whether multiple entries have been requested.
  76   bool multiple_;
  77
  78   // Whether a directory has been requested.
  79   bool is_directory_;
  80
  81   // The dictionary to send as the response.
  82   base::DictionaryValue* response_;
  83 };
  84
  85 class FileSystemGetWritableEntryFunction : public FileSystemEntryFunction {
  86  public:
  87   DECLARE_EXTENSION_FUNCTION("fileSystem.getWritableEntry",
  88                              FILESYSTEM_GETWRITABLEENTRY)
  89
  90  protected:
  91   virtual ~FileSystemGetWritableEntryFunction() {}
  92   virtual bool RunAsync() OVERRIDE;
  93
  94  private:
  95   void CheckPermissionAndSendResponse();
  96   void SetIsDirectoryOnFileThread();
  97
  98   // The path to the file for which a writable entry has been requested.
  99   base::FilePath path_;
 100 };
 101
 102 class FileSystemIsWritableEntryFunction : public ChromeSyncExtensionFunction {
 103  public:
 104   DECLARE_EXTENSION_FUNCTION("fileSystem.isWritableEntry",
 105                              FILESYSTEM_ISWRITABLEENTRY)
 106
 107  protected:
 108   virtual ~FileSystemIsWritableEntryFunction() {}
 109   virtual bool RunSync() OVERRIDE;
 110 };
 111
 112 class FileSystemChooseEntryFunction : public FileSystemEntryFunction {
 113  public:
 114   // Allow picker UI to be skipped in testing.
 115   static void SkipPickerAndAlwaysSelectPathForTest(base::FilePath* path);
 116   static void SkipPickerAndAlwaysSelectPathsForTest(
 117       std::vector<base::FilePath>* paths);
 118   static void SkipPickerAndSelectSuggestedPathForTest();
 119   static void SkipPickerAndAlwaysCancelForTest();
 120   static void StopSkippingPickerForTest();
 121   // Allow directory access confirmation UI to be skipped in testing.
 122   static void SkipDirectoryConfirmationForTest();
 123   static void AutoCancelDirectoryConfirmationForTest();
 124   static void StopSkippingDirectoryConfirmationForTest();
 125   // Call this with the directory for test file paths. On Chrome OS, accessed
 126   // path needs to be explicitly registered for smooth integration with Google
 127   // Drive support.
 128   static void RegisterTempExternalFileSystemForTest(const std::string& name,
 129                                                     const base::FilePath& path);
 130
 131   DECLARE_EXTENSION_FUNCTION("fileSystem.chooseEntry", FILESYSTEM_CHOOSEENTRY)
 132
 133   typedef std::vector<linked_ptr<extensions::api::file_system::AcceptOption> >
 134       AcceptOptions;
 135
 136   static void BuildFileTypeInfo(
 137       ui::SelectFileDialog::FileTypeInfo* file_type_info,
 138       const base::FilePath::StringType& suggested_extension,
 139       const AcceptOptions* accepts,
 140       const bool* acceptsAllTypes);
 141   static void BuildSuggestion(const std::string* opt_name,
 142                               base::FilePath* suggested_name,
 143                               base::FilePath::StringType* suggested_extension);
 144
 145  protected:
 146   class FilePicker;
 147
 148   virtual ~FileSystemChooseEntryFunction() {}
 149   virtual bool RunAsync() OVERRIDE;
 150   void ShowPicker(const ui::SelectFileDialog::FileTypeInfo& file_type_info,
 151                   ui::SelectFileDialog::Type picker_type);
 152
 153  private:
 154   void SetInitialPathOnFileThread(const base::FilePath& suggested_name,
 155                                   const base::FilePath& previous_path);
 156
 157   // FilesSelected and FileSelectionCanceled are called by the file picker.
 158   void FilesSelected(const std::vector<base::FilePath>& path);
 159   void FileSelectionCanceled();
 160
 161   // Check if |check_path|, the canonicalized form of the chosen directory
 162   // |paths|, is or is an ancestor of a sensitive directory. If so, show a
 163   // dialog to confirm that the user wants to open the directory.
 164   // Calls OnDirectoryAccessConfirmed if the directory isn't sensitive or the
 165   // user chooses to open it. Otherwise, calls FileSelectionCanceled.
 166   void ConfirmDirectoryAccessOnFileThread(
 167       const base::FilePath& check_path,
 168       const std::vector<base::FilePath>& paths,
 169       content::WebContents* web_contents);
 170   void OnDirectoryAccessConfirmed(const std::vector<base::FilePath>& paths);
 171
 172   base::FilePath initial_path_;
 173 };
 174
 175 class FileSystemRetainEntryFunction : public ChromeAsyncExtensionFunction {
 176  public:
 177   DECLARE_EXTENSION_FUNCTION("fileSystem.retainEntry", FILESYSTEM_RETAINENTRY)
 178
 179  protected:
 180   virtual ~FileSystemRetainEntryFunction() {}
 181   virtual bool RunAsync() OVERRIDE;
 182
 183  private:
 184   // Retains the file entry referenced by |entry_id| in apps::SavedFilesService.
 185   // |entry_id| must refer to an entry in an isolated file system.
 186   void RetainFileEntry(const std::string& entry_id);
 187
 188   void SetIsDirectoryOnFileThread();
 189
 190   // Whether the file being retained is a directory.
 191   bool is_directory_;
 192
 193   // The path to the file to retain.
 194   base::FilePath path_;
 195 };
 196
 197 class FileSystemIsRestorableFunction : public ChromeSyncExtensionFunction {
 198  public:
 199   DECLARE_EXTENSION_FUNCTION("fileSystem.isRestorable", FILESYSTEM_ISRESTORABLE)
 200
 201  protected:
 202   virtual ~FileSystemIsRestorableFunction() {}
 203   virtual bool RunSync() OVERRIDE;
 204 };
 205
 206 class FileSystemRestoreEntryFunction : public FileSystemEntryFunction {
 207  public:
 208   DECLARE_EXTENSION_FUNCTION("fileSystem.restoreEntry", FILESYSTEM_RESTOREENTRY)
 209
 210  protected:
 211   virtual ~FileSystemRestoreEntryFunction() {}
 212   virtual bool RunAsync() OVERRIDE;
 213 };
 214
 215 class FileSystemObserveDirectoryFunction : public ChromeSyncExtensionFunction {
 216  public:
 217   DECLARE_EXTENSION_FUNCTION("fileSystem.observeDirectory",
 218                              FILESYSTEM_OBSERVEDIRECTORY)
 219
 220  protected:
 221   virtual ~FileSystemObserveDirectoryFunction() {}
 222   virtual bool RunSync() OVERRIDE;
 223 };
 224
 225 class FileSystemUnobserveEntryFunction : public ChromeSyncExtensionFunction {
 226  public:
 227   DECLARE_EXTENSION_FUNCTION("fileSystem.unobserveEntry",
 228                              FILESYSTEM_UNOBSERVEENTRY)
 229
 230  protected:
 231   virtual ~FileSystemUnobserveEntryFunction() {}
 232   virtual bool RunSync() OVERRIDE;
 233 };
 234
 235 class FileSystemGetObservedEntriesFunction
 236     : public ChromeSyncExtensionFunction {
 237  public:
 238   DECLARE_EXTENSION_FUNCTION("fileSystem.getObservedEntries",
 239                              FILESYSTEM_GETOBSERVEDENTRIES);
 240
 241  protected:
 242   virtual ~FileSystemGetObservedEntriesFunction() {}
 243   virtual bool RunSync() OVERRIDE;
 244 };
 245
 246 }  // namespace extensions
 247
 248 #endif  // CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_