Fix filesystem.retainEntry API to handle non-native directory.

chrome/browser/chromeos/file_manager/external_filesystem_apitest.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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 11 matching lines @@
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/test/result_catcher.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/test_util.h"
 #include "google_apis/drive/time_util.h"
 #include "storage/browser/fileapi/external_mount_points.h"
+#include "ui/shell_dialogs/select_file_dialog_factory.h"
 
 // Tests for access to external file systems (as defined in
 // storage/common/fileapi/file_system_types.h) from extensions with
 // fileManagerPrivate and fileBrowserHandler extension permissions.
 // The tests cover following external file system types:
 // - local (kFileSystemTypeLocalNative): a local file system on which files are
 //   accessed using native local path.
 // - restricted (kFileSystemTypeRestrictedLocalNative): a *read-only* local file
 //   system which can only be accessed by extensions that have full access to
 //   external file systems (i.e. extensions with fileManagerPrivate permission).
@@ skipping 25 matching lines @@
 const char kRestrictedMountPointName[] = "restricted";
 
 // Default file content for the test files.
 const char kTestFileContent[] = "This is some test content.";
 
 // User account email and directory hash for secondary account for multi-profile
 // sensitive test cases.
 const char kSecondProfileAccount[] = "profile2@test.com";
 const char kSecondProfileHash[] = "fileBrowserApiTestProfile2";
 
+class FakeSelectFileDialog : public ui::SelectFileDialog {
+ public:
+  FakeSelectFileDialog(ui::SelectFileDialog::Listener* listener,
+                       ui::SelectFilePolicy* policy)
+      : ui::SelectFileDialog(listener, policy) {}
+
+  virtual void SelectFileImpl(
+      Type type,
+      const base::string16& title,
+      const base::FilePath& default_path,
+      const FileTypeInfo* file_types,
+      int file_type_index,
+      const base::FilePath::StringType& default_extension,
+      gfx::NativeWindow owning_window,
+      void* params) override {
+    listener_->FileSelected(
+        base::FilePath("/special/drive-user/root/test_dir"), 0, NULL);
+  }
+
+  virtual bool IsRunning(gfx::NativeWindow owning_window) const override {
+    return false;
+  }
+
+  virtual void ListenerDestroyed() override {}
+
+  virtual bool HasMultipleFileTypeChoicesImpl() override { return false; }
+
+ private:
+  virtual ~FakeSelectFileDialog() {}
+};
+
+class FakeSelectFileDialogFactory : public ui::SelectFileDialogFactory {
+ private:
+  virtual ui::SelectFileDialog* Create(ui::SelectFileDialog::Listener* listener,
+                                       ui::SelectFilePolicy* policy) override {
+    return new FakeSelectFileDialog(listener, policy);
+  }
+};
+
 // Sets up the initial file system state for native local and restricted native
 // local file systems. The hierarchy is the same as for the drive file system.
 // The directory is created at unique_temp_dir/|mount_point_name| path.
 bool InitializeLocalFileSystem(std::string mount_point_name,
                                base::ScopedTempDir* tmp_dir,
                                base::FilePath* mount_point_dir) {
   if (!tmp_dir->CreateUniqueTempDir())
     return false;
 
   *mount_point_dir = tmp_dir->path().AppendASCII(mount_point_name);
@@ skipping 386 matching lines @@
     service_factory_for_test_.reset(
         new DriveIntegrationServiceFactory::ScopedFactoryForTest(
             &create_drive_integration_service_));
   }
 
   // FileSystemExtensionApiTestBase override.
   virtual void AddTestMountPoint() override {
     test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
   }
 
+  // FileSystemExtensionApiTestBase override.
+  virtual void TearDown() override {
+    FileSystemExtensionApiTestBase::TearDown();
+    ui::SelectFileDialog::SetFactory(NULL);
+  }
+
  protected:
   // DriveIntegrationService factory function for this test.
   drive::DriveIntegrationService* CreateDriveIntegrationService(
       Profile* profile) {
     fake_drive_service_ = new drive::FakeDriveService;
     fake_drive_service_->LoadAppListForDriveApi("drive/applist.json");
 
     std::map<std::string, std::string> resource_ids;
     EXPECT_TRUE(InitializeDriveService(fake_drive_service_, &resource_ids));
 
     return new drive::DriveIntegrationService(
-        profile, NULL,
-        fake_drive_service_, "drive", test_cache_root_.path(), NULL);
+        profile, NULL, fake_drive_service_, "", test_cache_root_.path(), NULL);
   }
 
   base::ScopedTempDir test_cache_root_;
   drive::FakeDriveService* fake_drive_service_;
   DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
   scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
 };
 
@@ skipping 260 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, AppFileHandler) {
   EXPECT_TRUE(RunFileSystemExtensionApiTest(
       "file_browser/handler_test_runner",
       FILE_PATH_LITERAL("manifest.json"),
       "file_browser/app_file_handler",
       FLAGS_USE_FILE_HANDLER)) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, RetainEntry) {
+  ui::SelectFileDialog::SetFactory(new FakeSelectFileDialogFactory());
+  EXPECT_TRUE(RunFileSystemExtensionApiTest("file_browser/retain_entry",
+                                            FILE_PATH_LITERAL("manifest.json"),
+                                            "",
+                                            FLAGS_NONE))
+      << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(MultiProfileDriveFileSystemExtensionApiTest,
                        CrossProfileCopy) {
   ASSERT_TRUE(AddTestHostedDocuments());
   EXPECT_TRUE(RunFileSystemExtensionApiTest(
       "file_browser/multi_profile_copy",
       FILE_PATH_LITERAL("manifest.json"),
       "",
       FLAGS_NONE)) << message_;
 }
 
 //
 // LocalAndDriveFileSystemExtensionApiTests.
 //
 IN_PROC_BROWSER_TEST_F(LocalAndDriveFileSystemExtensionApiTest,
                        AppFileHandlerMulti) {
   EXPECT_TRUE(
       RunFileSystemExtensionApiTest("file_browser/app_file_handler_multi",
                                     FILE_PATH_LITERAL("manifest.json"),
                                     "",
                                     FLAGS_NONE))
       << message_;
 }
 }  // namespace
 }  // namespace file_manager