Move chrome.fileSystem implementation to //extensions

extensions/browser/api/file_system/file_system_delegate.h

Index: extensions/browser/api/file_system/file_system_delegate.h
diff --git a/extensions/browser/api/file_system/file_system_delegate.h b/extensions/browser/api/file_system/file_system_delegate.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4782c967226f215ba4048da072288f3e8af1442
--- /dev/null
+++ b/extensions/browser/api/file_system/file_system_delegate.h
@@ -0,0 +1,115 @@
+// 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 EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_DELEGATE_H_
+#define EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_DELEGATE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "build/build_config.h"
+#include "extensions/browser/api/file_system/saved_files_service_interface.h"
+#include "extensions/common/api/file_system.h"
+#include "ui/shell_dialogs/select_file_dialog.h"
+
+#if defined(OS_CHROMEOS)
+class UIThreadExtensionFunction;
+#endif
+
+namespace base {
+class FilePath;
+}  // namespace base
+
+namespace content {
+class BrowserContext;
+class RenderFrameHost;
+class WebContents;
+}  // namespace content
+
+namespace ui {
+class SelectFilePolicy;
+}  // namespace ui
+
+namespace extensions {
+
+class Extension;
+
+// Delegate class for embedder-specific file system access.
+class FileSystemDelegate {
+ public:
+  using ErrorCallback = base::Callback<void(const std::string&)>;
+  using FileSystemCallback =
+      base::Callback<void(const std::string& id, const std::string& path)>;
+  using VolumeListCallback =
+      base::Callback<void(const std::vector<api::file_system::Volume>&)>;
+
+  virtual ~FileSystemDelegate() {}
+
+  virtual base::FilePath GetDefaultDirectory() = 0;
+
+  // Returns a new SelectFilePolicy for whether a file dialog can be shown.
+  virtual std::unique_ptr<ui::SelectFilePolicy> CreateSelectFilePolicy(
+      content::WebContents* web_contents) = 0;
+
+  // Creates a dialog for selecting files.
+  virtual scoped_refptr<ui::SelectFileDialog> CreateSelectFileDialog(
+      ui::SelectFileDialog::Listener* listener,
+      std::unique_ptr<ui::SelectFilePolicy> policy) = 0;
+
+  // Shows |dialog| to prompt the user to select files/directories.
+  virtual 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) = 0;
+
+  // Confirms (e.g. with a dialog) whether the user wants to open the directory
+  // for a given app.
+  virtual void ConfirmSensitiveDirectoryAccess(
+      bool has_write_permission,
+      const base::string16& app_name,
+      content::WebContents* web_contents,
+      const base::Closure& on_accept,
+      const base::Closure& on_cancel) = 0;
+
+  // Finds a string describing the accept type. Returns 0 if no applicable
+  // string ID is found.
+  virtual int GetDescriptionIdForAcceptType(const std::string& accept_type) = 0;
+
+#if defined(OS_CHROMEOS)
+  // Checks whether the extension can be granted access.
+  virtual bool IsGrantable(content::BrowserContext* browser_context,
+                           content::RenderFrameHost* render_frame_host,
+                           const Extension& extension) = 0;
+
+  // Grants or denies an extension's request for access to the named file
+  // system. May prompt the user for consent.
+  virtual 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) = 0;
+
+  // Immediately calls VolumeListCallback or ErrorCallback.
+  virtual void GetVolumeList(content::BrowserContext* browser_context,
+                             const VolumeListCallback& success_callback,
+                             const ErrorCallback& error_callback) = 0;
+#endif
+
+  virtual std::unique_ptr<SavedFilesServiceInterface>
+  CreateSavedFilesServiceInterface(

[michaelpg, 2017/06/23 21:30:53]

benwells: Awkward choice between calling this "CreateFooInterface" or calling it
"CreateFoo" but returning an interface. WDYT?

[benwells, 2017/06/26 02:28:15]

I'd go with CreateFoo. The underlying implementation will be a Foo, so I'm OK
with that.

[michaelpg, 2017/06/26 15:36:33]

Yeah, that's better. Done.

+      content::BrowserContext* browser_context) = 0;
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_API_FILE_SYSTEM_FILE_SYSTEM_DELEGATE_H_