Add support for persistent file access in apps.

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 "apps/saved_files_service.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 23 matching lines @@
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #include "base/mac/foundation_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #endif
 
+using apps::SavedFileEntry;
+using apps::SavedFilesService;
 using fileapi::IsolatedContext;
 
 const char kInvalidParameters[] = "Invalid parameters";
 const char kSecurityError[] = "Security error";
 const char kInvalidCallingPage[] = "Invalid calling page. This function can't "
     "be called from a background page.";
 const char kUserCancelled[] = "User cancelled";
 const char kWritableFileError[] = "Invalid file for writing";
 const char kRequiresFileSystemWriteError[] =
     "Operation requires fileSystem.write permission";
+const char kUnknownIdError[] = "Unknown id";
 
 namespace file_system = extensions::api::file_system;
 namespace ChooseEntry = file_system::ChooseEntry;
 
 namespace {
 
 #if defined(OS_MACOSX)
 // Retrieves the localized display name for the base name of the given path.
 // If the path is not localized, this will just return the base name.
 std::string GetDisplayBaseName(const base::FilePath& path) {
@@ skipping 63 matching lines @@
     return display_path;
 #endif
   return source_path;
 }
 #endif  // defined(OS_MACOSX)
 
 bool g_skip_picker_for_test = false;
 bool g_use_suggested_path_for_test = false;
 base::FilePath* g_path_to_be_picked_for_test;
 
-bool GetFilePathOfFileEntry(const std::string& filesystem_name,
-                            const std::string& filesystem_path,
-                            const content::RenderViewHost* render_view_host,
-                            base::FilePath* file_path,
-                            std::string* error) {
-  std::string filesystem_id;
-  if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
+bool GetFileSystemAndPathOfFileEntry(
+    const std::string& filesystem_name,
+    const std::string& filesystem_path,
+    const content::RenderViewHost* render_view_host,
+    std::string* filesystem_id,
+    base::FilePath* file_path,
+    std::string* error) {
+  if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, filesystem_id)) {
     *error = kInvalidParameters;
     return false;
   }
 
   // Only return the display path if the process has read access to the
   // filesystem.
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   if (!policy->CanReadFileSystem(render_view_host->GetProcess()->GetID(),
-                                 filesystem_id)) {
+                                 *filesystem_id)) {
     *error = kSecurityError;
     return false;
   }
 
   IsolatedContext* context = IsolatedContext::GetInstance();
   base::FilePath relative_path =
       base::FilePath::FromUTF8Unsafe(filesystem_path);
-  base::FilePath virtual_path = context->CreateVirtualRootPath(filesystem_id)
+  base::FilePath virtual_path = context->CreateVirtualRootPath(*filesystem_id)
       .Append(relative_path);
   if (!context->CrackVirtualPath(virtual_path,
-                                 &filesystem_id,
+                                 filesystem_id,
                                  NULL,
                                  file_path)) {
     *error = kInvalidParameters;
     return false;
   }
 
   return true;
 }
 
+bool GetFilePathOfFileEntry(const std::string& filesystem_name,
+                            const std::string& filesystem_path,
+                            const content::RenderViewHost* render_view_host,
+                            base::FilePath* file_path,
+                            std::string* error) {
+  std::string filesystem_id;
+  return GetFileSystemAndPathOfFileEntry(filesystem_name,
+                                         filesystem_path,
+                                         render_view_host,
+                                         &filesystem_id,
+                                         file_path,
+                                         error);
+}
+
 bool DoCheckWritableFile(const base::FilePath& path) {
   // Don't allow links.
   if (file_util::PathExists(path) && file_util::IsLink(path))
     return false;
 
   // Create the file if it doesn't already exist.
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   int creation_flags = base::PLATFORM_FILE_CREATE |
                        base::PLATFORM_FILE_READ |
                        base::PLATFORM_FILE_WRITE;
@@ skipping 129 matching lines @@
         base::Bind(&CheckRemoteWritableFile, on_success, on_failure));
     return;
   }
 #endif
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&CheckLocalWritableFile, path, on_success, on_failure));
 }
 
 void FileSystemEntryFunction::RegisterFileSystemAndSendResponse(
     const base::FilePath& path, EntryType entry_type) {
+  RegisterFileSystemAndSendResponseWithIdOverride(path, entry_type, "");
+}
+
+void FileSystemEntryFunction::RegisterFileSystemAndSendResponseWithIdOverride(
+    const base::FilePath& path, EntryType entry_type, const std::string& id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   fileapi::IsolatedContext* isolated_context =
       fileapi::IsolatedContext::GetInstance();
   DCHECK(isolated_context);
 
   bool writable = entry_type == WRITABLE;
   extensions::app_file_handler_util::GrantedFileEntry file_entry =
       extensions::app_file_handler_util::CreateFileEntry(profile(),
           GetExtension()->id(), render_view_host_->GetProcess()->GetID(), path,
           writable);
 
   DictionaryValue* dict = new DictionaryValue();
   SetResult(dict);
   dict->SetString("fileSystemId", file_entry.filesystem_id);
   dict->SetString("baseName", file_entry.registered_name);
-  dict->SetString("id", file_entry.id);
+  if (id.empty())
+    dict->SetString("id", file_entry.id);
+  else
+    dict->SetString("id", id);
 
   SendResponse(true);
 }
 
 void FileSystemEntryFunction::HandleWritableFileError() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   error_ = kWritableFileError;
   SendResponse(false);
 }
 
@@ skipping 338 matching lines @@
       FROM_HERE,
       base::Bind(
           &FileSystemChooseEntryFunction::SetInitialPathOnFileThread, this,
           suggested_name, previous_path),
       base::Bind(
           &FileSystemChooseEntryFunction::ShowPicker, this, file_type_info,
           picker_type, entry_type));
   return true;
 }
 
+bool FileSystemRetainEntryFunction::RunImpl() {
+  std::string entry_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
+  SavedFilesService* saved_files_service = SavedFilesService::Get(profile());
+  // Add the file to the retain list if it is not already on there.
+  if (!saved_files_service->IsRetained(extension_->id(), entry_id) &&
+      !RetainFileEntry(entry_id)) {
+    return false;
+  }
+  saved_files_service->MoveEntryToFrontOfQueue(extension_->id(), entry_id);
+  return true;
+}
+
+bool FileSystemRetainEntryFunction::RetainFileEntry(
+    const std::string& entry_id) {
+  std::string filesystem_name;
+  std::string filesystem_path;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_name));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &filesystem_path));
+  std::string filesystem_id;
+  base::FilePath path;
+  if (!GetFileSystemAndPathOfFileEntry(filesystem_name,
+                                       filesystem_path,
+                                       render_view_host_,
+                                       &filesystem_id,
+                                       &path,
+                                       &error_)) {
+    return false;
+  }
+
+  content::ChildProcessSecurityPolicy* policy =
+      content::ChildProcessSecurityPolicy::GetInstance();
+  bool is_writable = policy->CanReadWriteFileSystem(
+      render_view_host_->GetProcess()->GetID(), filesystem_id);
+  SavedFilesService::Get(profile())->RetainFileEntry(
+      extension_->id(), entry_id, path, is_writable);
+  return true;
+}
+
+bool FileSystemIsRestorableFunction::RunImpl() {
+  std::string entry_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
+  SetResult(new base::FundamentalValue(SavedFilesService::Get(
+      profile())->IsRetained(extension_->id(), entry_id)));
+  return true;
+}
+
+bool FileSystemRestoreEntryFunction::RunImpl() {
+  std::string entry_id;
+  bool needs_new_entry;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &needs_new_entry));
+  SavedFileEntry file_entry;
+  if (!SavedFilesService::Get(profile())->GetFileEntry(
+      extension_->id(), entry_id, &file_entry)) {
+    error_ = kUnknownIdError;
+    return false;
+  }
+  SavedFilesService::Get(profile())->MoveEntryToFrontOfQueue(
+      extension_->id(), entry_id);
+
+  // Only create a new file entry if the renderer requests one.
+  // |needs_new_entry| will be false if the renderer already has an Entry for
+  // |entry_id|.
+  if (needs_new_entry) {
+    RegisterFileSystemAndSendResponseWithIdOverride(
+        file_entry.path,
+        file_entry.writable ? WRITABLE : READ_ONLY,
+        file_entry.id);
+  }
+  return true;
+}
+
 }  // namespace extensions