Postpone setting up file handler's file permissions if handler is running lazy background page.

chrome/browser/chromeos/extensions/file_handler_util.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_
 #define CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_
 #pragma once
 
+#include <vector>
+
 #include "base/platform_file.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern_set.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 
 class Browser;
 class FileBrowserHandler;
 class GURL;
 class Profile;
 
 namespace file_handler_util {
 
 // Gets read-write file access permission flags.
 int GetReadWritePermissions();
@@ skipping 31 matching lines @@
                      const std::vector<GURL>& files_list,
                      LastUsedHandlerList* named_action_list);
 
 // Find the default task for a file whose url is |url|. (The default task is the
 // task that is assigned to file browser task button by default).
 bool GetDefaultTask(Profile* profile,
                     const GURL& url,
                     const FileBrowserHandler** handler);
 
 // Helper class for executing file browser file action.
-class FileTaskExecutor : public base::RefCountedThreadSafe<FileTaskExecutor> {
+class FileTaskExecutor : public base::RefCountedThreadSafe<FileTaskExecutor>,
+                         public content::NotificationObserver {
  public:
 
   FileTaskExecutor(Profile* profile,
                    const GURL source_url,
                    const std::string& extension_id,
                    const std::string& action_id);
 
   virtual ~FileTaskExecutor();
 
   // Initiates execution of file handler task for each element of |file_urls|.
   // Return |false| if the execution cannot be initiated.
   // Otherwise returns |true| and then eventually calls |Done|.
   bool Execute(const std::vector<GURL>& file_urls);
 
  protected:
    virtual Browser* browser() = 0;
    virtual void Done(bool success) = 0;
 
  private:
   struct FileDefinition {
     FileDefinition();
     ~FileDefinition();
 
     GURL target_file_url;
     FilePath virtual_path;
     FilePath absolute_path;
     bool is_directory;
   };
+
   typedef std::vector<FileDefinition> FileDefinitionList;
   class ExecuteTasksFileSystemCallbackDispatcher;
   void RequestFileEntryOnFileThread(
       const GURL& handler_base_url,
       const scoped_refptr<const Extension>& handler,
       int handler_pid,
       const std::vector<GURL>& file_urls);
-  void SetupFileAccessPermissionsForGDataCache(
-      const FileDefinitionList& file_list,
-      int handler_pid);
-  void RespondFailedOnUIThread(base::PlatformFileError error_code);
+
+  void ExecuteFailedOnUIThread();
   void ExecuteFileActionsOnUIThread(const std::string& file_system_name,
                                     const GURL& file_system_root,
                                     const FileDefinitionList& file_list,
                                     int handler_id);
-  void ExecuteFailedOnUIThread();
+
+  // Populates |handler_host_permissions| with file path-permissions pairs that
+  // will be given to the handler extension host process.
+  void InitHandlerHostFileAccessPermissions(
+      const FileDefinitionList& file_list,
+      const Extension* handler_extension,
+      const std::string& action_id);

[Matt Perry, 2012/04/13 18:45:17]

add blank line here

+  // Registers file permissions from |handler_host_permissions_| with
+  // ChildProcessSecurityPolicy for process with id |handler_pid|.
+  void SetupHandlerHostFileAccessPermissions(int handler_pid);
+
+  // If the handler has lazy background page, we'll have to wait until the
+  // extension host is loaded until we can setup file access permissions. To do
+  // that, we'll have to listen for notifications.
+  // Registers notifications we listen to.
+  void RegisterNotificationObservers();
+
+  // content::NotificationObserver interface.
+  // Called when observed notification is detected.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
 
   Profile* profile_;
   const GURL source_url_;
   const std::string extension_id_;
   const std::string action_id_;
+
+  // (File path, permission for file path) pairs for the handler.
+  std::vector<std::pair<FilePath, int> > handler_host_permissions_;
+  content::NotificationRegistrar registrar_;
 };
 
 }  // namespace file_handler_util
 
 #endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_