Home | History | Annotate | Download | only in file_system 
      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_
    249