Move fileSystem API FilePicker class to own file

chrome/browser/extensions/api/file_system/file_system_api.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "apps/saved_files_service.h"
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
+#include "chrome/browser/extensions/api/file_system/file_entry_picker.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/apps/directory_access_confirmation_dialog.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/api/file_system.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 13 matching lines @@
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/mime_util.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/file_system_operation_runner.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "storage/common/fileapi/file_system_types.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
-#include "ui/shell_dialogs/selected_file_info.h"
+#include "ui/shell_dialogs/select_file_policy.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #include "base/mac/foundation_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "base/strings/string16.h"
 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
@@ skipping 128 matching lines @@
   std::unique_ptr<base::File::Info> file_info(
       result == base::File::FILE_OK ? new base::File::Info(info) : NULL);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::BindOnce(callback, base::Passed(&file_info)));
 }
 
 // Gets a WebContents instance handle for a platform app hosted in
 // |render_frame_host|. If not found, then returns NULL.
 content::WebContents* GetWebContentsForRenderFrameHost(
-    Profile* profile,
+    content::BrowserContext* browser_context,
     content::RenderFrameHost* render_frame_host) {
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   // Check if there is an app window associated with the web contents; if not,
   // return null.
-  return AppWindowRegistry::Get(profile)->GetAppWindowForWebContents(
-             web_contents)
+  return AppWindowRegistry::Get(browser_context)
+                 ->GetAppWindowForWebContents(web_contents)
              ? web_contents
              : nullptr;
 }
 
 #if defined(OS_CHROMEOS)
 // Fills a list of volumes mounted in the system.
 void FillVolumeList(Profile* profile,
                     std::vector<api::file_system::Volume>* result) {
   file_manager::VolumeManager* const volume_manager =
       file_manager::VolumeManager::Get(profile);
   DCHECK(volume_manager);
 
   const auto& volume_list = volume_manager->GetVolumeList();
   // Convert volume_list to result_volume_list.
   for (const auto& volume : volume_list) {
     api::file_system::Volume result_volume;
     result_volume.volume_id = volume->volume_id();
     result_volume.writable = !volume->is_read_only();
     result->push_back(std::move(result_volume));
   }
 }
 #endif
 
+// Creates and shows a SelectFileDialog, or returns false if the dialog could
+// not be created.
+bool ShowSelectFileDialog(
+    scoped_refptr<UIThreadExtensionFunction> extension_function,
+    ui::SelectFileDialog::Type type,
+    const base::FilePath& default_path,
+    const ui::SelectFileDialog::FileTypeInfo* file_types,
+    FileEntryPicker::FilesSelectedCallback&& files_selected_callback,

[Devlin, 2017/07/05 19:08:05]

here, too, maybe pass by value.

[michaelpg, 2017/07/05 19:52:54]

Done.

+    base::OnceClosure&& file_selection_canceled_callback) {
+  // TODO(asargent/benwells) - As a short term remediation for
+  // crbug.com/179010 we're adding the ability for a whitelisted extension to
+  // use this API since chrome.fileBrowserHandler.selectFile is ChromeOS-only.
+  // Eventually we'd like a better solution and likely this code will go back
+  // to being platform-app only.
+  content::WebContents* const web_contents =
+      extension_function->extension()->is_platform_app()
+          ? GetWebContentsForRenderFrameHost(
+                extension_function->browser_context(),
+                extension_function->render_frame_host())
+          : extension_function->GetAssociatedWebContents();
+  if (!web_contents)
+    return false;
+
+  // The file picker will hold a reference to the UIThreadExtensionFunction
+  // instance, preventing its destruction (and subsequent sending of the
+  // function response) until the user has selected a file or cancelled the
+  // picker. At that point, the picker will delete itself, which will also free
+  // the function instance.
+  new FileEntryPicker(web_contents, default_path, *file_types, type,
+                      std::move(files_selected_callback),
+                      std::move(file_selection_canceled_callback));
+  return true;
+}
+
 }  // namespace
 
 namespace file_system_api {
 
 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
                                            const std::string& extension_id) {
   base::FilePath path;
   std::string string_path;
   if (prefs->ReadPrefAsString(extension_id, kLastChooseEntryDirectory,
                               &string_path)) {
@@ skipping 186 matching lines @@
     return RespondNow(Error(app_file_handler_util::kInvalidParameters));
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   int renderer_id = render_frame_host()->GetProcess()->GetID();
   bool is_writable = policy->CanReadWriteFileSystem(renderer_id, filesystem_id);
 
   return RespondNow(OneArgument(base::MakeUnique<base::Value>(is_writable)));
 }
 
-// Handles showing a dialog to the user to ask for the filename for a file to
-// save or open.
-class FileSystemChooseEntryFunction::FilePicker
-    : public ui::SelectFileDialog::Listener {
- public:
-  FilePicker(FileSystemChooseEntryFunction* function,
-             content::WebContents* web_contents,
-             const base::FilePath& suggested_name,
-             const ui::SelectFileDialog::FileTypeInfo& file_type_info,
-             ui::SelectFileDialog::Type picker_type)
-      : function_(function) {
-    select_file_dialog_ = ui::SelectFileDialog::Create(
-        this, new ChromeSelectFilePolicy(web_contents));
-    gfx::NativeWindow owning_window =
-        web_contents ? platform_util::GetTopLevel(web_contents->GetNativeView())
-                     : NULL;
-
-    if (g_skip_picker_for_test) {
-      if (g_use_suggested_path_for_test) {
-        content::BrowserThread::PostTask(
-            content::BrowserThread::UI, FROM_HERE,
-            base::BindOnce(
-                &FileSystemChooseEntryFunction::FilePicker::FileSelected,
-                base::Unretained(this), suggested_name, 1,
-                static_cast<void*>(NULL)));
-      } else if (g_path_to_be_picked_for_test) {
-        content::BrowserThread::PostTask(
-            content::BrowserThread::UI, FROM_HERE,
-            base::BindOnce(
-                &FileSystemChooseEntryFunction::FilePicker::FileSelected,
-                base::Unretained(this), *g_path_to_be_picked_for_test, 1,
-                static_cast<void*>(NULL)));
-      } else if (g_paths_to_be_picked_for_test) {
-        content::BrowserThread::PostTask(
-            content::BrowserThread::UI, FROM_HERE,
-            base::BindOnce(
-                &FileSystemChooseEntryFunction::FilePicker::MultiFilesSelected,
-                base::Unretained(this), *g_paths_to_be_picked_for_test,
-                static_cast<void*>(NULL)));
-      } else {
-        content::BrowserThread::PostTask(
-            content::BrowserThread::UI, FROM_HERE,
-            base::BindOnce(&FileSystemChooseEntryFunction::FilePicker::
-                               FileSelectionCanceled,
-                           base::Unretained(this), static_cast<void*>(NULL)));
-      }
-      return;
-    }
-
-    select_file_dialog_->SelectFile(
-        picker_type, base::string16(), suggested_name, &file_type_info, 0,
-        base::FilePath::StringType(), owning_window, NULL);
-  }
-
-  ~FilePicker() override {}
-
- private:
-  // ui::SelectFileDialog::Listener implementation.
-  void FileSelected(const base::FilePath& path,
-                    int index,
-                    void* params) override {
-    std::vector<base::FilePath> paths;
-    paths.push_back(path);
-    MultiFilesSelected(paths, params);
-  }
-
-  void FileSelectedWithExtraInfo(const ui::SelectedFileInfo& file,
-                                 int index,
-                                 void* params) override {
-    // Normally, file.local_path is used because it is a native path to the
-    // local read-only cached file in the case of remote file system like
-    // Chrome OS's Google Drive integration. Here, however, |file.file_path| is
-    // necessary because we need to create a FileEntry denoting the remote file,
-    // not its cache. On other platforms than Chrome OS, they are the same.
-    //
-    // TODO(kinaba): remove this, once after the file picker implements proper
-    // switch of the path treatment depending on the |allowed_paths|.
-    FileSelected(file.file_path, index, params);
-  }
-
-  void MultiFilesSelected(const std::vector<base::FilePath>& files,
-                          void* params) override {
-    function_->FilesSelected(files);
-    delete this;
-  }
-
-  void MultiFilesSelectedWithExtraInfo(
-      const std::vector<ui::SelectedFileInfo>& files,
-      void* params) override {
-    std::vector<base::FilePath> paths;
-    for (std::vector<ui::SelectedFileInfo>::const_iterator it = files.begin();
-         it != files.end(); ++it) {
-      paths.push_back(it->file_path);
-    }
-    MultiFilesSelected(paths, params);
-  }
-
-  void FileSelectionCanceled(void* params) override {
-    function_->FileSelectionCanceled();
-    delete this;
-  }
-
-  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
-  scoped_refptr<FileSystemChooseEntryFunction> function_;
-
-  DISALLOW_COPY_AND_ASSIGN(FilePicker);
-};
-
 void FileSystemChooseEntryFunction::ShowPicker(
     const ui::SelectFileDialog::FileTypeInfo& file_type_info,
     ui::SelectFileDialog::Type picker_type) {
-  // TODO(asargent/benwells) - As a short term remediation for crbug.com/179010
-  // we're adding the ability for a whitelisted extension to use this API since
-  // chrome.fileBrowserHandler.selectFile is ChromeOS-only. Eventually we'd
-  // like a better solution and likely this code will go back to being
-  // platform-app only.
-  content::WebContents* const web_contents =
-      extension_->is_platform_app()
-          ? GetWebContentsForRenderFrameHost(GetProfile(), render_frame_host())
-          : GetAssociatedWebContents();
-  if (!web_contents) {
-    error_ = kInvalidCallingPage;
-    SendResponse(false);
+  if (g_skip_picker_for_test) {
+    std::vector<base::FilePath> test_paths;
+    if (g_use_suggested_path_for_test)
+      test_paths.push_back(initial_path_);
+    else if (g_path_to_be_picked_for_test)
+      test_paths.push_back(*g_path_to_be_picked_for_test);
+    else if (g_paths_to_be_picked_for_test)
+      test_paths = *g_paths_to_be_picked_for_test;
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        test_paths.size() > 0
+            ? base::BindOnce(&FileSystemChooseEntryFunction::FilesSelected,
+                             this, test_paths)
+            : base::BindOnce(
+                  &FileSystemChooseEntryFunction::FileSelectionCanceled, this));
     return;
   }
 
-  // The file picker will hold a reference to this function instance, preventing
-  // its destruction (and subsequent sending of the function response) until the
-  // user has selected a file or cancelled the picker. At that point, the picker
-  // will delete itself, which will also free the function instance.
-  new FilePicker(this, web_contents, initial_path_, file_type_info,
-                 picker_type);
+  // The callbacks passed to the dialog will retain references to this
+  // UIThreadExtenisonFunction, preventing its destruction (and subsequent
+  // sending of the function response) until the user has selected a file or
+  // cancelled the picker.
+  if (!ShowSelectFileDialog(
+          this, picker_type, initial_path_, &file_type_info,
+          base::BindOnce(&FileSystemChooseEntryFunction::FilesSelected, this),
+          base::BindOnce(&FileSystemChooseEntryFunction::FileSelectionCanceled,
+                         this))) {
+    error_ = kInvalidCallingPage;
+    SendResponse(false);
+  }
 }
 
 // static
 void FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
     base::FilePath* path) {
   g_skip_picker_for_test = true;
   g_use_suggested_path_for_test = false;
   g_path_to_be_picked_for_test = path;
   g_paths_to_be_picked_for_test = NULL;
 }
@@ skipping 645 matching lines @@
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions