test

extensions/browser/api/file_system/file_system_api.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
-#define CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
+#ifndef EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
+#define EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "build/build_config.h"
-#include "chrome/browser/extensions/chrome_extension_function.h"
-#include "chrome/browser/extensions/chrome_extension_function_details.h"
-#include "chrome/common/extensions/api/file_system.h"
 #include "extensions/browser/extension_function.h"
+#include "extensions/common/api/file_system.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/extensions/api/file_system/consent_provider.h"
-#endif
-
 namespace extensions {
 class ExtensionPrefs;
 
 namespace file_system_api {
 
 // Methods to get and set the path of the directory containing the last file
 // chosen by the user in response to a chrome.fileSystem.chooseEntry() call for
 // the given extension.
 
 // Returns an empty path on failure.
 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
                                            const std::string& extension_id);
 
 void SetLastChooseEntryDirectory(ExtensionPrefs* prefs,
                                  const std::string& extension_id,
                                  const base::FilePath& path);
 
-#if defined(OS_CHROMEOS)
-// Dispatches an event about a mounted on unmounted volume in the system to
-// each extension which can request it.
-void DispatchVolumeListChangeEvent(Profile* profile);
-#endif
-
 }  // namespace file_system_api
 
 class FileSystemGetDisplayPathFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.getDisplayPath",
                              FILESYSTEM_GETDISPLAYPATH)
 
  protected:
   ~FileSystemGetDisplayPathFunction() override {}
   ResponseAction Run() override;
 };
 
-class FileSystemEntryFunction : public ChromeAsyncExtensionFunction {
+class FileSystemEntryFunction : public UIThreadExtensionFunction {
  protected:
   FileSystemEntryFunction();
 
   ~FileSystemEntryFunction() override {}
 
   // This is called when writable file entries are being returned. The function
   // will ensure the files exist, creating them if necessary, and also check
   // that none of the files are links. If it succeeds it proceeds to
   // RegisterFileSystemsAndSendResponse, otherwise to HandleWritableFileError.
   void PrepareFilesForWritableApp(const std::vector<base::FilePath>& path);
@@ skipping 22 matching lines @@
   bool is_directory_;
 };
 
 class FileSystemGetWritableEntryFunction : public FileSystemEntryFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.getWritableEntry",
                              FILESYSTEM_GETWRITABLEENTRY)
 
  protected:
   ~FileSystemGetWritableEntryFunction() override {}
-  bool RunAsync() override;
+  ResponseAction Run() override;
 
  private:
   void CheckPermissionAndSendResponse();
   void SetIsDirectoryAsync();
 
   // The path to the file for which a writable entry has been requested.
   base::FilePath path_;
 };
 
 class FileSystemIsWritableEntryFunction : public UIThreadExtensionFunction {
@@ skipping 34 matching lines @@
       const AcceptOptions* accepts,
       const bool* acceptsAllTypes);
   static void BuildSuggestion(const std::string* opt_name,
                               base::FilePath* suggested_name,
                               base::FilePath::StringType* suggested_extension);
 
  protected:
   class FilePicker;
 
   ~FileSystemChooseEntryFunction() override {}
-  bool RunAsync() override;
+  ResponseAction Run() override;
   void ShowPicker(const ui::SelectFileDialog::FileTypeInfo& file_type_info,
                   ui::SelectFileDialog::Type picker_type);
 
  private:
   void SetInitialPathAndShowPicker(
       const base::FilePath& previous_path,
       const base::FilePath& suggested_name,
       const ui::SelectFileDialog::FileTypeInfo& file_type_info,
       ui::SelectFileDialog::Type picker_type,
       bool is_path_non_native_directory);
 
   // FilesSelected and FileSelectionCanceled are called by the file picker.
   void FilesSelected(const std::vector<base::FilePath>& path);
   void FileSelectionCanceled();
 
   // Check if the chosen directory is or is an ancestor of a sensitive
-  // directory. If so, show a dialog to confirm that the user wants to open the
-  // directory. Calls OnDirectoryAccessConfirmed if the directory isn't
-  // sensitive or the user chooses to open it. Otherwise, calls
-  // FileSelectionCanceled.
+  // directory. If so, calls ConfirmSensitiveDirectoryAccess. Otherwise, calls
+  // OnDirectoryAccessConfirmed.
   void ConfirmDirectoryAccessAsync(bool non_native_path,
                                    const std::vector<base::FilePath>& paths,
                                    content::WebContents* web_contents);
+  // Shows a dialog to confirm whether the user wants to open the directory.
+  // Calls OnDirectoryAccessConfirmed or FileSelectionCanceled.
+  void ConfirmSensitiveDirectoryAccess(const std::vector<base::FilePath>& paths,
+                                       content::WebContents* web_contents);
   void OnDirectoryAccessConfirmed(const std::vector<base::FilePath>& paths);
 
   base::FilePath initial_path_;
 };
 
-class FileSystemRetainEntryFunction : public ChromeAsyncExtensionFunction {
+class FileSystemRetainEntryFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.retainEntry", FILESYSTEM_RETAINENTRY)
 
  protected:
   ~FileSystemRetainEntryFunction() override {}
-  bool RunAsync() override;
+  ResponseAction Run() override;
 
  private:
   // Retains the file entry referenced by |entry_id| in apps::SavedFilesService.
   // |entry_id| must refer to an entry in an isolated file system.  |path| is a
   // path of the entry.  |file_info| is base::File::Info of the entry if it can
   // be obtained.
   void RetainFileEntry(const std::string& entry_id,
                        const base::FilePath& path,
                        std::unique_ptr<base::File::Info> file_info);
 };
 
 class FileSystemIsRestorableFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.isRestorable", FILESYSTEM_ISRESTORABLE)
 
  protected:
   ~FileSystemIsRestorableFunction() override {}
   ResponseAction Run() override;
 };
 
 class FileSystemRestoreEntryFunction : public FileSystemEntryFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.restoreEntry", FILESYSTEM_RESTOREENTRY)
 
  protected:
   ~FileSystemRestoreEntryFunction() override {}
-  bool RunAsync() override;
+  ResponseAction Run() override;
 };
 
 class FileSystemObserveDirectoryFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.observeDirectory",
                              FILESYSTEM_OBSERVEDIRECTORY)
 
  protected:
   ~FileSystemObserveDirectoryFunction() override {}
   ResponseAction Run() override;
@@ skipping 56 matching lines @@
 
  protected:
   ~FileSystemRequestFileSystemFunction() override;
 
   // UIThreadExtensionFunction overrides.
   ExtensionFunction::ResponseAction Run() override;
 
  private:
   // Called when a user grants or rejects permissions for the file system
   // access.
-  void OnConsentReceived(const base::WeakPtr<file_manager::Volume>& volume,
-                         bool writable,
-                         file_system_api::ConsentProvider::Consent result);
-
-  ChromeExtensionFunctionDetails chrome_details_;
+  void OnGotFileSystem(const std::string& id, const std::string& path);
+  void OnError(const std::string& error);
 };
 
 // Requests a list of available volumes.
 class FileSystemGetVolumeListFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("fileSystem.getVolumeList",
                              FILESYSTEM_GETVOLUMELIST);
   FileSystemGetVolumeListFunction();
 
  protected:
   ~FileSystemGetVolumeListFunction() override;
 
   // UIThreadExtensionFunction overrides.
   ExtensionFunction::ResponseAction Run() override;
 
  private:
-  ChromeExtensionFunctionDetails chrome_details_;
+  void OnGotVolumeList(const std::vector<api::file_system::Volume>& volumes);
+  void OnError(const std::string& error);
 };
 #endif
 
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_FILE_SYSTEM_API_H_
+#endif  // EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_API_H_