Add support for persistent file access in apps.

chrome/browser/extensions/api/file_system/file_system_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 "apps/saved_files_service.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/platform_app_browsertest_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/notification_observer.h"
 
 using extensions::FileSystemChooseEntryFunction;
 
 namespace {
 
 class AppInstallObserver : public content::NotificationObserver {
  public:
-  AppInstallObserver(const base::FilePath& choose_entry_directory,
-                     extensions::ExtensionPrefs* prefs)
-      : path_(choose_entry_directory),
-        prefs_(prefs) {
-    registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+  AppInstallObserver(
+      base::Callback<void(const extensions::Extension*)> callback)
+      : callback_(callback) {
+    registrar_.Add(this,
+                   chrome::NOTIFICATION_EXTENSION_LOADED,
                    content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     EXPECT_EQ(chrome::NOTIFICATION_EXTENSION_LOADED, type);
-    std::string extension_id = content::Details<const extensions::Extension>(
-        details).ptr()->id();
-    prefs_->SetLastChooseEntryDirectory(extension_id, path_);
+    callback_.Run(content::Details<const extensions::Extension>(details).ptr());
   }
 
  private:
   content::NotificationRegistrar registrar_;
-  const base::FilePath path_;
-  extensions::ExtensionPrefs* prefs_;
+  base::Callback<void(const extensions::Extension*)> callback_;
   DISALLOW_COPY_AND_ASSIGN(AppInstallObserver);
 };
 
+void SetLastChooseEntryDirectory(const base::FilePath& choose_entry_directory,
+                                 extensions::ExtensionPrefs* prefs,
+                                 const extensions::Extension* extension) {
+  prefs->SetLastChooseEntryDirectory(extension->id(), choose_entry_directory);
+}
+
+void AddSavedEntry(const base::FilePath& path_to_save,
+                   apps::SavedFilesService* service,
+                   const extensions::Extension* extension) {
+  service->RegisterFileEntry(
+      extension->id(), "magic id", path_to_save, /* writable */ true);
+}
+
 }  // namespace
 
 class FileSystemApiTest : public extensions::PlatformAppBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     extensions::PlatformAppBrowserTest::SetUpCommandLine(command_line);
     test_root_folder_ = test_data_dir_.AppendASCII("api_test")
         .AppendASCII("file_system");
     FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
         "test_root", test_root_folder_);
@@ skipping 99 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenExistingFileUsingPreviousPathTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   FileSystemChooseEntryFunction::
       SkipPickerAndSelectSuggestedPathForTest();
   {
     AppInstallObserver observer(
-        test_file.DirName(),
-        extensions::ExtensionSystem::Get(
-            profile())->extension_service()->extension_prefs());
+        base::Bind(SetLastChooseEntryDirectory,
+                   test_file.DirName(),
+                   extensions::ExtensionSystem::Get(
+                       profile())->extension_service()->extension_prefs()));
     ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_existing"))
         << message_;
   }
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
     FileSystemApiOpenExistingFilePreviousPathDoesNotExistTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
       chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false));
   FileSystemChooseEntryFunction::
       SkipPickerAndSelectSuggestedPathForTest();
   {
-    AppInstallObserver observer(
-        test_file.DirName().Append(base::FilePath::FromUTF8Unsafe(
-            "fake_directory_does_not_exist")),
+    AppInstallObserver observer(base::Bind(
+        SetLastChooseEntryDirectory,
+        test_file.DirName().Append(
+            base::FilePath::FromUTF8Unsafe("fake_directory_does_not_exist")),
         extensions::ExtensionSystem::Get(
-            profile())->extension_service()->extension_prefs());
+            profile())->extension_service()->extension_prefs()));
     ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_existing"))
         << message_;
   }
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenExistingFileDefaultPathTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
@@ skipping 136 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiIsWritableTest) {
   base::FilePath test_file = TempFilePath("writable.txt", true);
   ASSERT_FALSE(test_file.empty());
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_file);
   ASSERT_TRUE(RunPlatformAppTest(
       "api_test/file_system/is_writable_file_entry")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiGetEntryId) {
+IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiRetainEntry) {
   base::FilePath test_file = TempFilePath("writable.txt", true);
   ASSERT_FALSE(test_file.empty());
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_file);
   ASSERT_TRUE(RunPlatformAppTest(
-      "api_test/file_system/get_entry_id")) << message_;
+      "api_test/file_system/retain_entry")) << message_;
+  std::vector<apps::SavedFileEntry> file_entries = apps::SavedFilesService::Get(
+      profile())->GetAllFileEntries(GetSingleLoadedExtension()->id());
+  ASSERT_EQ(1u, file_entries.size());
+  EXPECT_EQ(test_file, file_entries[0].path);
+  EXPECT_EQ(1, file_entries[0].sequence_number);
+  EXPECT_FALSE(file_entries[0].writable);
 }
+
+IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiRestoreEntry) {
+  base::FilePath test_file = TempFilePath("writable.txt", true);
+  ASSERT_FALSE(test_file.empty());
+  FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
+      &test_file);
+  {
+    AppInstallObserver observer(base::Bind(
+        AddSavedEntry, test_file, apps::SavedFilesService::Get(profile())));
+    ASSERT_TRUE(RunPlatformAppTest(
+        "api_test/file_system/restore_entry")) << message_;
+  }
+}