test

chrome/browser/extensions/api/file_system/chrome_file_system_delegate.h

 // 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_CONSENT_PROVIDER_H_
-#define CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_CONSENT_PROVIDER_H_
+#ifndef CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_CHROME_FILE_SYSTEM_DELEGATE_H_
+#define CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_CHROME_FILE_SYSTEM_DELEGATE_H_
 
-#include "base/callback_forward.h"
+#include "extensions/browser/api/file_system/file_system_delegate.h"
+
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
-#include "ui/base/ui_base_types.h"
 
-class Profile;
-
-namespace content {
-class RenderFrameHost;
-}  // content
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/extensions/api/file_system/consent_provider.h"
+#endif
 
 namespace file_manager {
 class Volume;
-}  // namespace file_manager
+}
 
 namespace extensions {
-class Extension;
-class ScopedSkipRequestFileSystemDialog;
 
+#if defined(OS_CHROMEOS)
 namespace file_system_api {
 
-// Requests consent for the chrome.fileSystem.requestFileSystem() method.
-// Interaction with UI and environmental checks (kiosk mode, whitelist) are
-// provided by a delegate: ConsentProviderDelegate. For testing, it is
-// TestingConsentProviderDelegate.
-class ConsentProvider {
+// Dispatches an event about a mounted or unmounted volume in the system to
+// each extension which can request it.
+void DispatchVolumeListChangeEvent(content::BrowserContext* browser_context);
+
+}  // namespace file_system_api
+#endif  // defined(OS_CHROMEOS)
+
+class ChromeFileSystemDelegate : public FileSystemDelegate {
  public:
-  enum Consent { CONSENT_GRANTED, CONSENT_REJECTED, CONSENT_IMPOSSIBLE };
-  typedef base::Callback<void(Consent)> ConsentCallback;
-  typedef base::Callback<void(ui::DialogButton)> ShowDialogCallback;
+  ChromeFileSystemDelegate();
+  ~ChromeFileSystemDelegate() override;
 
-  // Interface for delegating user interaction for granting permissions.
-  class DelegateInterface {
-   public:
-    // Shows a dialog for granting permissions.
-    virtual void ShowDialog(const Extension& extension,
-                            const base::WeakPtr<file_manager::Volume>& volume,
-                            bool writable,
-                            const ShowDialogCallback& callback) = 0;
+  base::FilePath GetDefaultDirectory() override;
 
-    // Shows a notification about permissions automatically granted access.
-    virtual void ShowNotification(
-        const Extension& extension,
-        const base::WeakPtr<file_manager::Volume>& volume,
-        bool writable) = 0;
+  std::unique_ptr<ui::SelectFilePolicy> CreateSelectFilePolicy(
+      content::WebContents* web_contents) override;
 
-    // Checks if the extension was launched in auto-launch kiosk mode.
-    virtual bool IsAutoLaunched(const Extension& extension) = 0;
+  scoped_refptr<ui::SelectFileDialog> CreateSelectFileDialog(
+      ui::SelectFileDialog::Listener* listener,
+      std::unique_ptr<ui::SelectFilePolicy> policy) override;
 
-    // Checks if the extension is a whitelisted component extension or app.
-    virtual bool IsWhitelistedComponent(const Extension& extension) = 0;
-  };
+  void ShowSelectFileDialogForWebContents(
+      scoped_refptr<ui::SelectFileDialog> dialog,
+      content::WebContents* web_contents,
+      ui::SelectFileDialog::Type type,
+      const base::FilePath& default_path,
+      const ui::SelectFileDialog::FileTypeInfo* file_types) override;
 
-  explicit ConsentProvider(DelegateInterface* delegate);
-  ~ConsentProvider();
+  void ConfirmSensitiveDirectoryAccess(bool writable,
+                                       const base::string16& app_name,
+                                       content::WebContents* web_contents,
+                                       const base::Closure& on_accept,
+                                       const base::Closure& on_cancel) override;
 
-  // Requests consent for granting |writable| permissions to the |volume|
-  // volume by the |extension|. Must be called only if the extension is
-  // grantable, which can be checked with IsGrantable().
-  void RequestConsent(const Extension& extension,
-                      const base::WeakPtr<file_manager::Volume>& volume,
-                      bool writable,
-                      const ConsentCallback& callback);
+  // Finds a string describing the accept type. On success, returns true and
+  // populates |description_id|.
+  bool GetDescriptionIdForAcceptType(const std::string& accept_type,
+                                     int* description_id) override;
 
-  // Checks whether the |extension| can be granted access.
-  bool IsGrantable(const Extension& extension);
+#if defined(OS_CHROMEOS)
+  bool IsGrantable(content::BrowserContext* browser_context,
+                   content::RenderFrameHost* render_frame_host,
+                   const Extension& extension) override;
+
+  // Grants or denies an extension's request for access to the named file
+  // system. May prompt the user for consent.
+  void RequestFileSystem(content::BrowserContext* browser_context,
+                         scoped_refptr<UIThreadExtensionFunction> requester,
+                         const Extension& extension,
+                         std::string volume_id,
+                         bool writable,
+                         const FileSystemCallback& success_callback,
+                         const ErrorCallback& error_callback) override;
+
+  // Immediately calls VolumeListCallback or ErrorCallback.
+  void GetVolumeList(content::BrowserContext* browser_context,
+                     const VolumeListCallback& success_callback,
+                     const ErrorCallback& error_callback) override;
+#endif  // defined(OS_CHROMEOS)
+
+  std::unique_ptr<file_system_api::SavedFilesServiceDelegate>
+  CreateSavedFilesServiceDelegate(
+      content::BrowserContext* browser_context) override;
 
  private:
-  DelegateInterface* const delegate_;
+#if defined(OS_CHROMEOS)
+  void OnConsentReceived(content::BrowserContext* browser_context,
+                         scoped_refptr<UIThreadExtensionFunction> requester,
+                         const FileSystemCallback& success_callback,
+                         const ErrorCallback& error_callback,
+                         const std::string& extension,
+                         const base::WeakPtr<file_manager::Volume>& volume,
+                         bool writable,
+                         file_system_api::ConsentProvider::Consent result);
+#endif  // defined(OS_CHROMEOS)
 
-  DISALLOW_COPY_AND_ASSIGN(ConsentProvider);
+  DISALLOW_COPY_AND_ASSIGN(ChromeFileSystemDelegate);
 };
 
-// Handles interaction with user as well as environment checks (whitelists,
-// context of running extensions) for ConsentProvider.
-class ConsentProviderDelegate : public ConsentProvider::DelegateInterface {
- public:
-  ConsentProviderDelegate(Profile* profile, content::RenderFrameHost* host);
-  ~ConsentProviderDelegate();
-
- private:
-  friend ScopedSkipRequestFileSystemDialog;
-
-  // Sets a fake result for the user consent dialog. If ui::DIALOG_BUTTON_NONE
-  // then disabled.
-  static void SetAutoDialogButtonForTest(ui::DialogButton button);
-
-  // ConsentProvider::DelegateInterface overrides:
-  void ShowDialog(const Extension& extension,
-                  const base::WeakPtr<file_manager::Volume>& volume,
-                  bool writable,
-                  const file_system_api::ConsentProvider::ShowDialogCallback&
-                      callback) override;
-  void ShowNotification(const Extension& extension,
-                        const base::WeakPtr<file_manager::Volume>& volume,
-                        bool writable) override;
-  bool IsAutoLaunched(const Extension& extension) override;
-  bool IsWhitelistedComponent(const Extension& extension) override;
-
-  Profile* const profile_;
-  content::RenderFrameHost* const host_;
-
-  DISALLOW_COPY_AND_ASSIGN(ConsentProviderDelegate);
-};
-
-}  // namespace file_system_api
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_CONSENT_PROVIDER_H_
+#endif  // CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_CHROME_FILE_SYSTEM_DELEGATE_H_