Add support for persistent file access in apps.

chrome/browser/extensions/platform_app_launcher.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/platform_app_launcher.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif
 
 using content::BrowserThread;
 using extensions::app_file_handler_util::FileHandlerForId;
 using extensions::app_file_handler_util::FileHandlerCanHandleFile;
 using extensions::app_file_handler_util::FirstFileHandlerForFile;
 using extensions::app_file_handler_util::CreateFileEntry;
 using extensions::app_file_handler_util::GrantedFileEntry;
-using extensions::app_file_handler_util::SavedFileEntry;
 
 namespace extensions {
 
 namespace {
 
 const char kFallbackMimeType[] = "application/octet-stream";
 
 bool MakePathAbsolute(const base::FilePath& current_directory,
                       base::FilePath* file_path) {
   DCHECK(file_path);
@@ skipping 208 matching lines @@
   // The extension providing the app.
   const Extension* extension_;
   // The path to be passed through to the app.
   const base::FilePath file_path_;
   // The ID of the file handler used to launch the app.
   std::string handler_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
-class SavedFileEntryLauncher
-    : public base::RefCountedThreadSafe<SavedFileEntryLauncher> {
- public:
-  SavedFileEntryLauncher(
-      Profile* profile,
-      const Extension* extension,
-      const std::vector<SavedFileEntry>& file_entries)
-      : profile_(profile),
-        extension_(extension),
-        file_entries_(file_entries) {}
-
-  void Launch() {
-    // Access needs to be granted to the file or filesystem for the process
-    // associated with the extension. To do this the ExtensionHost is needed.
-    // This might not be available, or it might be in the process of being
-    // unloaded, in which case the lazy background task queue is used to load
-    // he extension and then call back to us.
-    extensions::LazyBackgroundTaskQueue* queue =
-        ExtensionSystem::Get(profile_)->lazy_background_task_queue();
-    if (queue->ShouldEnqueueTask(profile_, extension_)) {
-      queue->AddPendingTask(profile_, extension_->id(), base::Bind(
-              &SavedFileEntryLauncher::GrantAccessToFilesAndLaunch,
-              this));
-      return;
-    }
-    ExtensionProcessManager* process_manager =
-        ExtensionSystem::Get(profile_)->process_manager();
-    extensions::ExtensionHost* host =
-        process_manager->GetBackgroundHostForExtension(extension_->id());
-    DCHECK(host);
-    GrantAccessToFilesAndLaunch(host);
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<SavedFileEntryLauncher>;
-  ~SavedFileEntryLauncher() {}
-
-  void GrantAccessToFilesAndLaunch(ExtensionHost* host) {
-    // If there was an error loading the app page, |host| will be NULL.
-    if (!host) {
-      LOG(ERROR) << "Could not load app page for " << extension_->id();
-      return;
-    }
-
-    int renderer_id = host->render_process_host()->GetID();
-    std::vector<GrantedFileEntry> granted_file_entries;
-    for (std::vector<SavedFileEntry>::const_iterator it =
-         file_entries_.begin(); it != file_entries_.end(); ++it) {
-      GrantedFileEntry file_entry = CreateFileEntry(
-          profile_, extension_->id(), renderer_id, it->path, it->writable);
-      file_entry.id = it->id;
-      granted_file_entries.push_back(file_entry);
-
-      // Record that we have granted this file permission.
-      app_file_handler_util::AddSavedFileEntry(
-          ExtensionSystem::Get(profile_)->extension_prefs(),
-          host->extension()->id(),
-          it->id,
-          it->path,
-          it->writable);
-    }
-    extensions::AppEventRouter::DispatchOnRestartedEvent(
-        profile_, extension_, granted_file_entries);
-  }
-
-  // The profile the app should be run in.
-  Profile* profile_;
-  // The extension providing the app.
-  const Extension* extension_;
-
-  std::vector<SavedFileEntry> file_entries_;
-};
-
 }  // namespace
 
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
                        const CommandLine* command_line,
                        const base::FilePath& current_directory) {
 #if defined(OS_WIN)
   // On Windows 8's single window Metro mode we can not launch platform apps.
   // Offer to switch Chrome to desktop mode.
   if (win8::IsSingleWindowMetroMode()) {
@@ skipping 28 matching lines @@
 
 void LaunchPlatformAppWithFileHandler(Profile* profile,
                                       const Extension* extension,
                                       const std::string& handler_id,
                                       const base::FilePath& file_path) {
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->LaunchWithHandler(handler_id);
 }
 
-void RestartPlatformAppWithFileEntries(
-    Profile* profile,
-    const Extension* extension,
-    const std::vector<SavedFileEntry>& file_entries) {
-  scoped_refptr<SavedFileEntryLauncher> launcher = new SavedFileEntryLauncher(
-      profile, extension, file_entries);
-  launcher->Launch();
+void RestartPlatformApp(Profile* profile, const Extension* extension) {
+  extensions::AppEventRouter::DispatchOnRestartedEvent(profile, extension);
 }
 
 }  // namespace extensions